Spring 框架中都用到了哪些设计模式？

Spring框架是一个全功能的企业级Java应用开发框架，它提供了广泛的功能，包括依赖注入、面向切面编程、事务管理等。在Spring的实现中，使用了多种设计模式来实现这些功能，以提高代码的可维护性、可扩展性和灵活性。本文将深入讨论Spring框架中使用的一些主要设计模式。

1. 单例模式（Singleton Pattern）

单例模式是一种创建型设计模式，其主要目的是确保类只有一个实例，并提供一个全局访问点。在Spring中，Bean的默认作用域就是单例（Singleton），这意味着在整个应用程序中只有一个Bean实例，由Spring容器负责管理。

单例模式可以确保在应用程序中只存在一个共享的实例，从而节省资源并提高性能。在Spring中，单例模式广泛应用于管理Bean，例如Service层的业务逻辑组件、DAO层的数据访问组件等。

@Service
public class MyService {
    // ...
}

2. 工厂模式（Factory Pattern）

工厂模式是一种创建型设计模式，它提供了一个创建对象的接口，但允许子类决定实例化哪个类。在Spring中，工厂模式通过Bean工厂来创建和管理Bean。

Spring中的Bean工厂（例如ApplicationContext）负责创建和配置Bean，隐藏了具体实例化的细节，使得应用程序更易于扩展和维护。工厂模式有助于将对象的创建和配置过程解耦，提高了代码的可维护性。

@Configuration
public class AppConfig {
    
    @Bean
    public MyService myService() {
        return new MyServiceImpl();
    }
}

3. 代理模式（Proxy Pattern）

代理模式是一种结构型设计模式，它允许通过代理类控制对其他对象的访问。在Spring AOP（面向切面编程）中，代理模式被广泛用于实现横切关注点的代码分离，例如日志记录、事务管理等。

Spring通过动态代理和CGLIB（Code Generation Library）来实现代理模式。动态代理可以在运行时创建代理类，而CGLIB可以在编译时生成代理类的字节码。

public interface MyService {
    void doSomething();
}

public class MyServiceImpl implements MyService {
    public void doSomething() {
        // 实际业务逻辑
    }
}

public class MyServiceProxy implements MyService {
    private MyService target;

    // 构造函数注入目标对象
    public MyServiceProxy(MyService target) {
        this.target = target;
    }

    public void doSomething() {
        // 在实际业务逻辑执行前后添加额外的操作
        System.out.println("Before calling doSomething()");
        target.doSomething();
        System.out.println("After calling doSomething()");
    }
}

4. 观察者模式（Observer Pattern）

观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，使得当一个对象的状态发生改变时，所有依赖它的对象都得到通知并自动更新。在Spring中，事件驱动模型广泛使用了观察者模式。

Spring的事件机制允许应用程序中的组件发布和监听事件，从而实现解耦和灵活性。通过观察者模式，不同的组件可以对应用程序中发生的事件做出响应，而不需要显式的调用。

@Component
public class EventPublisher {

    @Autowired
    private ApplicationEventPublisher eventPublisher;

    public void publishEvent(String message) {
        MyEvent customEvent = new MyEvent(this, message);
        eventPublisher.publishEvent(customEvent);
    }
}

@Component
public class EventListener implements ApplicationListener<MyEvent> {

    @Override
    public void onApplicationEvent(MyEvent event) {
        // 处理事件
        System.out.println("Received custom event: " + event.getMessage());
    }
}

5. 策略模式（Strategy Pattern）

策略模式是一种行为型设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以互相替换。在Spring中，策略模式常用于定义不同的Bean实现，并根据需要在运行时动态切换它们。

Spring的@Qualifier注解和@Primary注解就是策略模式的一种应用，它们允许开发者选择特定的Bean实现或者指定默认的实现。

public interface PaymentStrategy {
    void pay();
}

@Component
@Qualifier("creditCard")
public class CreditCardPayment implements PaymentStrategy {
    public void pay() {
        // Credit card payment logic
    }
}

@Component
@Qualifier("paypal")
public class PaypalPayment implements PaymentStrategy {
    public void pay() {
        // Paypal payment logic
    }
}

@Service
public class ShoppingCart {

    private final PaymentStrategy paymentStrategy;

    @Autowired
    public ShoppingCart(@Qualifier("paypal") PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout() {
        // 其他购物车结算逻辑
        paymentStrategy.pay(); // 根据配置的策略执行支付
    }
}

6. 模板方法模式（Template Method Pattern）

模板方法模式是一种行为型设计模式，它定义了一个算法的骨架，将一些步骤推迟到子类中实现。在Spring中，模板方法模式被广泛应用于定义一些基础设施的模板，例如Spring中JdbcTemplate。

JdbcTemplate是Spring提供的用于简化JDBC操作的模板类，它封装了一些常见的JDBC操作，同时提供了回调机制，允许开发者在执行SQL语句的过程中插入自定义的逻辑。这正是模板方法模式的应用。

public abstract class JdbcTemplate {

    public final void execute(String sql) {
        // 公共逻辑
        DataSource dataSource = getDataSource();
        Connection connection = dataSource.getConnection();
        
        try {
            // 子类实现的具体逻辑
            Statement statement = connection.createStatement();
            statement.execute(sql);
        } catch (SQLException e) {
            // 异常处理逻辑
            e.printStackTrace();
        } finally {
            // 关闭资源逻辑
            connection.close();
        }
    }

    protected abstract DataSource getDataSource();
}

public class MyJdbcTemplate extends JdbcTemplate {

    @Override
    protected DataSource getDataSource() {
        // 返回特定的数据源
        return new MyDataSource();
    }
}

7. 装饰器模式（Decorator Pattern）

装饰器模式是一种结构型设计模式，它允许向一个对象添加新的行为，而无需修改其代码。在Spring中，AOP中的切面就是装饰器模式的一种应用，它允许在不改变原有业务逻辑的情况下，动态地添加新的功能。

public interface MyService {
    void doSomething();
}

@Service
public class MyServiceImpl implements MyService {
    public void doSomething() {
        // 实际业务逻辑
    }
}

@Aspect
@Component
public class MyAspect {

    @Before("execution(* com.example.MyService.doSomething(..))")
    public void beforeDoSomething() {
        // 在实际业务逻辑执行前添加额外的操作
        System.out.println("Before calling doSomething()");
    }
}

8. 适配器模式（Adapter Pattern）

适配器模式是一种结构型设计模式，它允许将一个类的接口转换成客户端期望的另一个接口。在Spring中，适配器模式被用于适应不同的框架或技术，使它们能够与Spring框架集成。

例如，Spring的JpaVendorAdapter就是一个适配器，它允许开发者在Spring应用中使用不同的JPA提供商（如Hibernate、EclipseLink）而不需要修改应用代码。

@Configuration
public class JpaConfig {

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(EntityManagerFactoryBuilder builder,
                                                                       DataSource dataSource) {
        return builder
                .dataSource(dataSource)
                .packages("com.example.domain")
                .persistenceUnit("myUnit")
                .build();
    }

    @Bean
    public JpaTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
        return new JpaTransactionManager(entityManagerFactory);
    }

    @Bean
    public JpaVendorAdapter jpaVendorAdapter() {
        HibernateJpaVendorAdapter adapter = new HibernateJpaVendorAdapter();
        adapter.setShowSql(true);
        adapter.setGenerateDdl(false);
        adapter.setDatabase(Database.H2);
        return adapter;
    }
}

黑马程序员新版Spring零基础入门到精通，一套搞定spring全套视频教程（含实战源码）

最后

Spring框架作为一个全功能的企业级Java应用开发框架，巧妙地运用了多种设计模式，包括但不限于单例模式、工厂模式、代理模式、观察者模式、策略模式、模板方法模式、装饰器模式和适配器模式。这些设计模式的使用使得Spring框架更具灵活性、可维护性和可扩展性，同时提高了代码的可读性和可理解性。通过深入了解这些设计模式在Spring框架中的应用，开发者可以更好地理解框架的设计思想，从而更加高效地使用和扩展Spring框架。