跟着Spring 学习 23 种设计模式

已于 2025-06-20 21:19:50 修改
阅读量447 收藏 15
点赞数 25
CC 4.0 BY-SA版权
分类专栏： # 设计模式23+1条 文章标签： spring 学习 设计模式
于 2025-06-20 21:19:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/csdn_tom_168/article/details/148799585

以下是 Spring 框架中涉及的 23 种设计模式的分类、技术原理及代码示例：

一、创建型模式

1. 工厂方法模式 (Factory Method)

作用：定义创建对象的接口，由子类决定实例化哪个类。

Spring 实现：

  • BeanFactory：顶级工厂接口，通过 getBean 方法创建 Bean。
  • FactoryBean：自定义 Bean 创建逻辑的接口。
// BeanFactory 示例
public interface BeanFactory {
    Object getBean(String name) throws BeansException;
}

// FactoryBean 示例
public class MyFactoryBean implements FactoryBean<MyObject> {
    @Override
    public MyObject getObject() {
        return new MyObject(); // 自定义创建逻辑
    }
}
2. 抽象工厂模式 (Abstract Factory)

作用：创建一组相关或依赖的对象，而无需指定具体类。

Spring 实现：

  • DataSource：通过 DataSource 抽象工厂创建不同数据库的连接（如 HikariCP、DBCP）。
// 定义抽象工厂接口
public interface DataSource {
    Connection getConnection() throws SQLException;
}

// 具体实现（HikariCP）
public class HikariDataSource implements DataSource {
    @Override
    public Connection getConnection() {
        return new HikariConnection(); // 返回具体连接
    }
}
3. 单例模式 (Singleton)

作用：确保一个类只有一个实例，并提供全局访问点。

Spring 实现：

  • DefaultSingletonBeanRegistry：通过 ConcurrentHashMap 缓存单例 Bean。
public class DefaultSingletonBeanRegistry {
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();

    public Object getSingleton(String beanName) {
        return singletonObjects.get(beanName); // 从缓存获取单例
    }
}
4. 建造者模式 (Builder)

作用：逐步构建复杂对象，允许用户通过链式调用设置属性。

Spring 实现：

  • BeanDefinitionBuilder：构建 BeanDefinition 对象。
//
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MyBean.class);
builder.addPropertyValue("name", "test");
BeanDefinition beanDefinition = builder.getBeanDefinition();
5. 原型模式 (Prototype)

作用：通过克隆现有对象创建新实例。

Spring 实现：

  • prototype 作用域：在 XML 或注解中配置 Bean 的作用域为原型。
@Bean
@Scope("prototype") // 声明为原型模式
public MyBean myBean() {
    return new MyBean();
}

二、结构型模式

6. 适配器模式 (Adapter)

作用：将接口转换为客户端期望的另一个接口。

Spring 实现：

  • HandlerAdapter：Spring MVC 中适配不同处理器（如 Controller、HttpRequestHandler）。
public interface HandlerAdapter {
    boolean supports(Object handler);
    ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler);
}

// 具体适配器
public class SimpleControllerHandlerAdapter implements HandlerAdapter {
    @Override
    public boolean supports(Object handler) {
        return (handler instanceof Controller);
    }

    @Override
    public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        return ((Controller) handler).handleRequest(request, response);
    }
}
7. 装饰器模式 (Decorator)

作用：动态为对象添加附加功能。

Spring 实现：

  • AOP 增强：通过 @Aspect 注解动态增强 Bean。
@Aspect
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Method called: " + joinPoint.getSignature().getName());
    }
}
8. 代理模式 (Proxy)

作用：通过代理对象控制对原对象的访问。

Spring 实现：

  • AOP 动态代理：使用 JDK 动态代理或 CGLIB 代理。
// JDK 动态代理示例
public class JdkDynamicProxy implements InvocationHandler {
    private final Object target;

    public JdkDynamicProxy(Object target) {
        this.target = target;
    }

    public Object getProxy() {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            this
        );
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) {
        before(); // 前置增强
        Object result = method.invoke(target, args);
        after();  // 后置增强
        return result;
    }
}
9. 外观模式 (Facade)

作用：为复杂子系统提供简化的接口。

Spring 实现：

  • JdbcTemplate：封装 JDBC 操作，简化数据库访问。
public class JdbcTemplate {
    public <T> T execute(ConnectionCallback<T> action) {
        Connection con = DataSourceUtils.getConnection();
        try {
            return action.doInConnection(con); // 调用子类实现
        } finally {
            DataSourceUtils.releaseConnection(con);
        }
    }
}
10. 桥接模式 (Bridge)

作用：将抽象与实现解耦，使两者可以独立变化。

Spring 实现：

  • 事务管理：通过 PlatformTransactionManager 桥接不同事务实现（如 JDBC、JTA）。
public interface PlatformTransactionManager {
    TransactionStatus getTransaction(TransactionDefinition definition);
    void commit(TransactionStatus status);
    void rollback(TransactionStatus status);
}

// 具体实现（DataSourceTransactionManager）
public class DataSourceTransactionManager implements PlatformTransactionManager {
    @Override
    public TransactionStatus getTransaction(TransactionDefinition definition) {
        return new DataSourceTransactionObject(); // 返回具体事务对象
    }
}
11. 组合模式 (Composite)

作用：将对象组合成树形结构，以表示“部分-整体”的层次结构。

Spring 实现：

  • Bean 容器：通过 BeanDefinitionRegistry 管理 Bean 的层次结构。
public interface BeanDefinitionRegistry {
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);
    BeanDefinition getBeanDefinition(String beanName);
}
12. 享元模式 (Flyweight)

作用：共享对象以减少内存占用。

Spring 实现：

  • Bean 作用域：通过 @Scope("prototype") 或单例作用域复用 Bean。
@Bean
@Scope("singleton") // 默认单例，共享实例
public MyBean myBean() {
    return new MyBean();
}

三、行为型模式

13. 模板方法模式 (Template Method)

作用：定义算法骨架，将某些步骤延迟到子类实现。

Spring 实现：

  • JdbcTemplate：定义数据库操作流程，子类实现具体步骤。
public class JdbcTemplate {
    public <T> T execute(ConnectionCallback<T> action) {
        Connection con = DataSourceUtils.getConnection();
        try {
            return action.doInConnection(con); // 调用子类实现
        } finally {
            DataSourceUtils.releaseConnection(con);
        }
    }
}
14. 观察者模式 (Observer)

作用：定义对象间的一对多依赖，当一个对象状态改变时，所有依赖者收到通知。

Spring 实现：

  • 事件监听机制：通过 ApplicationEvent 和 ApplicationListener 实现。
// 定义事件
public class MyEvent extends ApplicationEvent {
    public MyEvent(Object source) {
        super(source);
    }
}

// 定义监听器
@Component
public class MyEventListener implements ApplicationListener<MyEvent> {
    @Override
    public void onApplicationEvent(MyEvent event) {
        System.out.println("Received event: " + event.getSource());
    }
}
15. 策略模式 (Strategy)

作用：定义一系列算法，并将每个算法封装起来，使它们可以互换。

Spring 实现：

  • HandlerMapping：根据请求类型选择不同的处理器策略。
public interface HandlerMapping {
    HandlerExecutionChain getHandler(HttpServletRequest request);
}

// 具体策略（RequestMappingHandlerMapping）
public class RequestMappingHandlerMapping implements HandlerMapping {
    @Override
    public HandlerExecutionChain getHandler(HttpServletRequest request) {
        // 根据请求路径查找对应的 Controller 方法
        return lookupHandlerMethod(request);
    }
}
16. 命令模式 (Command)

作用：将请求封装为对象，以便用不同的请求、队列或日志参数化其他对象。

Spring 实现：

  • HibernateTemplate：封装数据库操作命令。
public class HibernateTemplate {
    public void execute(HibernateCallback action) {
        Session session = getSession();
        try {
            action.doInHibernate(session); // 执行具体命令
        } finally {
            releaseSession(session);
        }
    }
}
17. 责任链模式 (Chain of Responsibility)

作用：将请求的发送者和接收者解耦，使多个对象都有机会处理请求。

Spring 实现：

  • 拦截器链：通过 HandlerInterceptor 处理请求。
public interface HandlerInterceptor {
    boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler);
    void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView);
}

// 责任链配置
public class HandlerExecutionChain {
    private final List<HandlerInterceptor> interceptors = new ArrayList<>();

    public boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) {
        for (HandlerInterceptor interceptor : interceptors) {
            if (!interceptor.preHandle(request, response, handler)) {
                return false; // 终止责任链
            }
        }
        return true;
    }
}
18. 备忘录模式 (Memento)

作用：捕获并保存对象的内部状态，以便后续恢复。

Spring 实现：

  • Bean 状态管理：通过 BeanWrapper 保存和恢复 Bean 状态。
public class BeanWrapper {
    private Object bean;
    private Map<String, Object> state = new HashMap<>();

    public void saveState() {
        state.putAll(BeanUtils.describe(bean)); // 保存当前状态
    }

    public void restoreState() {
        BeanUtils.populate(bean, state); // 恢复保存的状态
    }
}
19. 状态模式 (State)

作用：允许对象在内部状态改变时改变行为。

Spring 实现：

  • Bean 生命周期管理：通过 Lifecycle 接口管理 Bean 的不同状态。
public interface Lifecycle {
    void start();
    void stop();
    boolean isRunning();
}

// 具体状态实现
public class MyBean implements Lifecycle {
    private boolean running;

    @Override
    public void start() {
        running = true;
    }

    @Override
    public void stop() {
        running = false;
    }

    @Override
    public boolean isRunning() {
        return running;
    }
}
20. 访问者模式 (Visitor)

作用：在对象结构中定义新操作，而无需修改结构本身。

Spring 实现：

  • BeanPostProcessor：在 Bean 初始化前后访问和修改 Bean。
public interface BeanPostProcessor {
    Object postProcessBeforeInitialization(Object bean, String beanName);
    Object postProcessAfterInitialization(Object bean, String beanName);
}

// 具体访问者
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("Before initialization: " + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("After initialization: " + beanName);
        return bean;
    }
}
21. 解释器模式 (Interpreter)

作用：给定一种语言，定义其文法表示，并构建解释器来解释语言中的句子。

Spring 实现：

  • SpEL 表达式解析：通过 SpelExpressionParser 解析表达式。
ExpressionParser parser = new SpelExpressionParser();
Expression expression = parser.parseExpression("'Hello, ' + name");
EvaluationContext context = new StandardEvaluationContext();
context.setVariable("name", "World");
String result = expression.getValue(context, String.class); // 输出 "Hello, World"
22. 迭代器模式 (Iterator)

作用：提供一种顺序访问集合元素的方法，而无需暴露其内部表示。

Spring 实现：

  • 集合操作：通过 Iterable 遍历 Bean。
public class BeanContainer {
    private List<Object> beans = new ArrayList<>();

    public Iterator<Object> iterator() {
        return beans.iterator(); // 返回迭代器
    }
}
23. 中介者模式 (Mediator)

作用：定义一个中介对象来封装一系列对象之间的交互。

Spring 实现：

  • ApplicationContext：作为中介者协调 Bean 之间的交互。
public class ApplicationContext {
    private Map<String, Object> beans = new HashMap<>();

    public Object getBean(String name) {
        return beans.get(name); // 协调 Bean 的获取
    }

    public void publishEvent(ApplicationEvent event) {
        // 协调事件发布
    }
}

总结

Spring 框架通过灵活运用 23 种设计模式，实现了高扩展性、低耦合性和灵活性。这些模式覆盖了对象创建、结构组织、行为交互等各个方面，是学习 Java 框架设计的经典案例。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值