总阅读量:次

⭐⭐⭐ Spring Boot 项目实战 ⭐⭐⭐ Spring Cloud 项目实战
《Dubbo 实现原理与源码解析 —— 精品合集》 《Netty 实现原理与源码解析 —— 精品合集》
《Spring 实现原理与源码解析 —— 精品合集》 《MyBatis 实现原理与源码解析 —— 精品合集》
《Spring MVC 实现原理与源码解析 —— 精品合集》 《数据库实体设计合集》
《Spring Boot 实现原理与源码解析 —— 精品合集》 《Java 面试题 + Java 学习指南》

摘要: 原创出处 江南一点雨 「江南一点雨」欢迎转载，保留摘要，谢谢！

🙂🙂🙂关注微信公众号：【芋道源码】有福利：

  1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
  2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
  3. 您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。
  4. 新的源码解析文章实时收到通知。每周更新一篇左右。
  5. 认真的源码交流微信群。

今天和大伙总结下 Spring 中都用到了哪些设计模式。

Spring 作为企业级应用开发中最受欢迎的框架之一，其内部广泛采用了多种设计模式，使得框架不仅功能强大，而且具有很高的可扩展性和灵活性。是我们学习设计模式不可多得的优质材料。

一 单例模式 （Singleton Pattern）

在 Spring 框架中，单例模式被广泛应用于各种组件和工具类，以确保在整个应用程序生命周期中，这些对象只有一个实例，从而节省内存和提高性能。

这里给大家举几个常见的 Spring 中单例的应用。

BeanFactory

BeanFactory 是 Spring 框架中的另一个核心接口，它负责创建和管理 bean。BeanFactory 的实现类（如 DefaultListableBeanFactory）也通常以单例模式存在。

源码示例:

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

    @Override
    public Object getSingleton(String beanName) {
        return getSingleton(beanName, true);
    }

    @Override
    public Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    singletonObject = getEarlyBeanReference(beanName, mbd, bean);
                }
            }
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }
}

DefaultListableBeanFactory 本身的初始化逻辑如下：

可以看到，如果存在 BeanFactory，则先销毁，再创建新的 BeanFactory。

二 工厂模式 （Factory Pattern）

工厂模式提供了一种创建对象的接口，但让子类决定实例化哪一个类。Spring 中的 BeanFactory 接口及其实现类（如 DefaultListableBeanFactory）就是工厂模式的应用。通过这些工厂，我们可以方便地管理和创建bean实例。

Spring 源码案例

public interface BeanFactory {
    Object getBean(String name) throws BeansException;
}

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
    
    @Override
    public Object getBean(String name) throws BeansException {
        return doGetBean(name, null, null, false);
    }
}

DefaultListableBeanFactory 是 BeanFactory 的一个实现，负责创建和管理 bean 的实例。

三 原型模式 （Prototype Pattern）

原型模式通过复制现有对象来创建新对象，而无需知道任何创建细节。在 Spring 中，我们可以通过设置 bean 的 scope 属性为 prototype 来实现每次请求时都创建一个新的 bean 实例。

Spring 源码案例

<bean id="exampleBean" class="com.example.ExampleBean" scope="prototype"/>

这个配置表示每次请求 exampleBean 时，都会创建一个新的实例。

四 模板方法模式 （Template Method Pattern）

在 Spring 框架中，模板方法模式被广泛应用于多个模块，以提供灵活且可扩展的解决方案。模板方法模式的核心思想是定义一个操作中的算法骨架，而将一些步骤延迟到子类中实现。这样，子类可以不改变算法结构的情况下重新定义算法的某些特定步骤。

这里和大家分享两个经典的模版方法模式：JdbcTemplate 和 PlatformTransactionManager。

JdbcTemplate

JdbcTemplate 是 Spring JDBC 模块中的一个核心类，它使用模板方法模式来简化数据库操作。

模板方法:

  • execute：执行 SQL 语句的基本方法。
  • query：查询数据库的基本方法。
  • update：执行更新操作的基本方法。

具体实现:

  • queryForObject：查询单个对象。
  • queryForList：查询列表。
  • batchUpdate：批量更新。

源码示例:

public abstract class JdbcOperations {
    public <T> T queryForObject(String sql, RowMapper<T> rowMapper, Object... args) throws DataAccessException {
        return queryForObject(sql, args, getJdbcOperations().new SingleColumnRowMapper(rowMapper));
    }

    public int update(String sql, PreparedStatementSetter pss) throws DataAccessException {
        Assert.notNull(sql, "SQL must not be null");
        if (logger.isDebugEnabled()) {
            logger.debug("Executing SQL update [" + sql + "]");
        }
        Connection con = DataSourceUtils.getConnection(getDataSource());
        PreparedStatement ps = null;
        try {
            ps = con.prepareStatement(sql);
            pss.setValues(ps);
            int rows = ps.executeUpdate();
            if (logger.isDebugEnabled()) {
                logger.debug(rows + " rows affected");
            }
            return rows;
        } catch (Throwable ex) {
            // Handle exception
            throw translateException("PreparedStatement", sql, ex);
        } finally {
            JdbcUtils.closeStatement(ps);
            DataSourceUtils.releaseConnection(con, getDataSource());
        }
    }
}
PlatformTransactionManager

PlatformTransactionManager 接口定义了事务管理的基本方法，具体的事务管理实现类（如 DataSourceTransactionManager）则提供了具体的实现。

模板方法:

  • getTransaction：获取事务。
  • commit：提交事务。
  • rollback：回滚事务。

具体实现:

  • DataSourceTransactionManager：基于数据源的事务管理。
  • JtaTransactionManager：基于JTA的事务管理。

源码示例:

public interface PlatformTransactionManager {
    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
    void commit(TransactionStatus status) throws TransactionException;
    void rollback(TransactionStatus status) throws TransactionException;
}

public class DataSourceTransactionManager extends AbstractPlatformTransactionManager {
    @Override
    protected TransactionStatus doBegin(Object transaction, TransactionDefinition definition) {
        // 获取数据库连接
        ConnectionHolder conHolder = (ConnectionHolder) transaction;
        Connection con = conHolder.getConnection();

        // 设置事务隔离级别
        Integer previousIsolationLevel = DataSourceUtils.storeIsolationLevelIfNotSet(con, definition.getIsolationLevel());

        // 开启事务
        boolean newTransaction = false;
        if (!con.getAutoCommit()) {
            logger.debug("Not switching JDBC Connection [" + con + "] to manual commit because already manually committed");
        } else {
            newTransaction = true;
            if (logger.isDebugEnabled()) {
                logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
            }
            con.setAutoCommit(false);
        }

        // 返回事务状态
        return new DataSourceTransactionObject(conHolder, previousIsolationLevel, newTransaction);
    }
}

五 适配器模式 （Adapter Pattern）

适配器模式将一个类的接口转换成客户希望的另一个接口。SpringMVC 中的 HandlerAdapter 接口及其多个实现类（如 RequestMappingHandlerAdapter）就是适配器模式的应用，它们负责处理不同类型的控制器方法。

Spring 源码案例

public interface HandlerAdapter {
    boolean supports(Object handler);
    ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
}

public class RequestMappingHandlerAdapter implements HandlerAdapter {
    @Override
    public boolean supports(Object handler) {
        return handler instanceof HandlerMethod;
    }

    @Override
    public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return ((HandlerMethod) handler).invokeAndHandle(request, response);
    }
}

RequestMappingHandlerAdapter 适配了 HandlerMethod 类型的控制器方法，使其能够处理HTTP请求。

六 装饰者模式 （Decorator Pattern）

装饰者模式允许动态地给一个对象添加一些额外的职责。Spring AOP 中的切面实现可以看作是对原有对象的一种装饰。通过 @Around 注解定义的环绕通知可以在不改变原有业务逻辑的情况下增加额外的功能。

Spring 源码案例

public class TransactionInterceptor implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        // 开始事务
        TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());

        try {
            Object result = invocation.proceed();
            transactionManager.commit(status);
            return result;
        } catch (RuntimeException ex) {
            transactionManager.rollback(status);
            throw ex;
        }
    }
}

TransactionInterceptor 是一个典型的装饰者模式应用，它在方法调用前后添加了事务管理的逻辑。

七 观察者模式 （Observer Pattern）

观察者模式定义了对象之间的一对多依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都会得到通知并自动更新。Spring 中的 ApplicationEvent 和 ApplicationListener 接口共同实现了观察者模式。

Spring 源码案例

public interface ApplicationListener<E extends ApplicationEvent> {
    void onApplicationEvent(E event);
}

public class ContextRefreshedEvent extends ApplicationEvent {
    public ContextRefreshedEvent(Object source) {
        super(source);
    }
}

public class MyApplicationListener implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        System.out.println("Context refreshed!");
    }
}

MyApplicationListener 监听了 ContextRefreshedEvent 事件，当上下文刷新时，会输出一条消息。

八 代理模式 （Proxy Pattern）

代理模式为其他对象提供一个代理以控制对这个对象的访问。Spring AOP 使用动态代理技术（JDK 动态代理或 CGLIB）来实现代理模式。例如，当你在方法上添加事务管理注解 @Transactional 时，Spring 会自动创建一个代理对象来管理事务的开始和结束。

Spring 源码案例

public class DefaultAopProxyFactory implements AopProxyFactory {
    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            Class<?> targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: " +
                        "Either an interface or a target is required for proxy creation.");
            }
            return new ObjenesisCglibAopProxy(config);
        } else {
            return new JdkDynamicAopProxy(config);
        }
    }
}

DefaultAopProxyFactory 根据配置选择使用 CGLIB 或 JDK 动态代理来创建代理对象。

九 组合模式 （Composite Pattern）

组合模式允许将对象组合成树形结构以表示“部分-整体”的层次结构。在 Spring 配置中，可以将多个 bean 组合在一起形成一个复杂的结构。

Spring 源码案例

<beans>
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/testdb"/>
        <property name="username" value="root"/>
        <property name="password" value="password"/>
    </bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

这个配置文件中，jdbcTemplate 依赖于 dataSource，形成了一个简单的组合结构。

十 策略模式 （Strategy Pattern）

策略模式定义了一系列算法，并将每一个算法封装起来，使它们可以互换。Spring 中的 Resource 接口及其多个实现类（如 ClassPathResource, FileSystemResource）就是策略模式的应用，可以根据需要选择不同的资源访问方式。

Spring 源码案例

public interface ResourceLoader {
    Resource getResource(String location);
}

public class DefaultResourceLoader implements ResourceLoader {
    @Override
    public Resource getResource(String location) {
        if (location.startsWith("classpath:")) {
            return new ClassPathResource(location.substring("classpath:".length()));
        } else {
            return new FileSystemResource(location);
        }
    }
}

DefaultResourceLoader 根据资源路径的前缀选择合适的 Resource 实现类。

十一 小结

通过上述案例，我们可以看到 Spring 框架巧妙地运用了多种设计模式，不仅提高了代码的复用性和可维护性，还增强了框架的灵活性和扩展性。希望这篇文章能帮助大家更好地理解和掌握 Spring 中的设计模式，如果有任何疑问或建议，欢迎在评论区留言交流。

文章目录
  1. 1. 一 单例模式 （Singleton Pattern）
    1. 1.0.0.0.1. BeanFactory
  • 2. 二 工厂模式 （Factory Pattern）
    1. 2.0.1. Spring 源码案例
  • 3. 三 原型模式 （Prototype Pattern）
    1. 3.0.1. Spring 源码案例
  • 4. 四 模板方法模式 （Template Method Pattern）
    1. 4.0.0.0.1. JdbcTemplate
    2. 4.0.0.0.2. PlatformTransactionManager
  • 5. 五 适配器模式 （Adapter Pattern）
    1. 5.0.1. Spring 源码案例
  • 6. 六 装饰者模式 （Decorator Pattern）
    1. 6.0.1. Spring 源码案例
  • 7. 七 观察者模式 （Observer Pattern）
    1. 7.0.1. Spring 源码案例
  • 8. 八 代理模式 （Proxy Pattern）
    1. 8.0.1. Spring 源码案例
  • 9. 九 组合模式 （Composite Pattern）
    1. 9.0.1. Spring 源码案例
  • 10. 十 策略模式 （Strategy Pattern）
    1. 10.0.1. Spring 源码案例
  • 11. 十一 小结