Spring框架中的设计模式应用全解析

Spring框架作为Java生态系统中最流行的应用开发框架，其内部广泛运用了多种经典设计模式。这些模式不仅使Spring架构优雅灵活，也为开发者提供了极好的学习范例。下面我将详细解析Spring中应用的主要设计模式及其实现场景。

一、创建型模式

1. 工厂模式（Factory Pattern）

应用场景：Bean的创建与管理

核心实现：

• BeanFactory：Spring容器的基础接口
• ApplicationContext：扩展的工厂接口
• FactoryBean：特殊Bean的工厂接口

// 典型使用示例
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
MyService service = context.getBean(MyService.class);

// FactoryBean示例
public class MyFactoryBean implements FactoryBean<MyObject> {
    @Override
    public MyObject getObject() {
        return new MyObject();
    }
    //...
}

设计优势：

• 将对象创建与使用分离
• 统一管理对象生命周期
• 支持多种配置方式(XML/注解/Java配置)

2. 单例模式（Singleton Pattern）

应用场景：Bean的默认作用域

实现特点：

• 默认情况下Spring容器中的Bean是单例的
• 不同于传统单例，Spring管理的是"上下文单例"
• 通过@Scope("singleton")显式声明

@Service  // 默认就是单例
public class UserServiceImpl implements UserService {
    //...
}

源码片段：

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

protected Object getSingleton(String beanName) {
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null) {
        synchronized (this.singletonObjects) {
            //...
        }
    }
    return singletonObject;
}

3. 原型模式（Prototype Pattern）

应用场景：需要每次获取新实例的Bean

实现方式：

• @Scope("prototype")注解
• 每次getBean()调用都会创建新实例

@Component
@Scope("prototype")
public class ShoppingCart {
    // 每次注入都是新实例
}

二、结构型模式

4. 代理模式（Proxy Pattern）

应用场景：AOP实现的核心

实现技术：

• JDK动态代理（接口代理）
• CGLIB字节码生成（类代理）
• ProxyFactory：创建代理的核心类

// AOP代理创建示例
ProxyFactory factory = new ProxyFactory(new MyService());
factory.addAdvice(new MyMethodInterceptor());
MyService proxy = (MyService) factory.getProxy();

Spring AOP流程：

1. 创建目标对象
2. 创建代理工厂
3. 添加通知(Advice)
4. 生成代理对象

5. 装饰器模式（Decorator Pattern）

应用场景：

• HttpServletRequest的多次读取
• Spring Cache的装饰器链
• BeanDefinition的装饰

// HttpServletRequest装饰器示例
public class CachedBodyHttpServletRequest extends HttpServletRequestWrapper {
    private byte[] cachedBody;
    
    public CachedBodyHttpServletRequest(HttpServletRequest request) {
        super(request);
        // 缓存请求体
        this.cachedBody = StreamUtils.copyToByteArray(request.getInputStream());
    }
    
    @Override
    public ServletInputStream getInputStream() {
        return new CachedBodyServletInputStream(this.cachedBody);
    }
}

6. 适配器模式（Adapter Pattern）

应用场景：

• Spring MVC的HandlerAdapter
• Spring AOP的AdvisorAdapter
• 事件监听器的适配

// HandlerAdapter接口定义
public interface HandlerAdapter {
    boolean supports(Object handler);
    ModelAndView handle(HttpServletRequest request, 
                      HttpServletResponse response, 
                      Object handler) throws Exception;
    //...
}

// 实际实现如RequestMappingHandlerAdapter

三、行为型模式

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

应用场景：

• JdbcTemplate等XXXTemplate类
• 抽象ApplicationContext的实现
• AbstractBeanFactory

// JdbcTemplate示例
public <T> T execute(ConnectionCallback<T> action) throws DataAccessException {
    Connection con = DataSourceUtils.getConnection(getDataSource());
    try {
        return action.doInConnection(con);
    }
    catch (SQLException ex) {
        throw translateException("ConnectionCallback", ex);
    }
    finally {
        DataSourceUtils.releaseConnection(con, getDataSource());
    }
}

设计特点：

• 定义算法骨架
• 具体步骤由子类实现
• 避免重复代码

8. 观察者模式（Observer Pattern）

应用场景：Spring事件机制

核心组件：

• ApplicationEvent：事件抽象
• ApplicationListener：观察者接口
• ApplicationEventPublisher：发布者接口

// 自定义事件
public class OrderCreatedEvent extends ApplicationEvent {
    public OrderCreatedEvent(Order source) {
        super(source);
    }
}

// 事件监听
@Component
public class OrderEventListener implements ApplicationListener<OrderCreatedEvent> {
    @Override
    public void onApplicationEvent(OrderCreatedEvent event) {
        // 处理事件
    }
}

// 事件发布
applicationContext.publishEvent(new OrderCreatedEvent(order));

9. 策略模式（Strategy Pattern）

应用场景：

• 资源访问策略(Resource接口)
• 缓存策略(CacheManager)
• 事务管理策略(PlatformTransactionManager)

// 资源访问策略
Resource resource = new ClassPathResource("application.xml");
InputStream is = resource.getInputStream();

// 事务策略
PlatformTransactionManager txManager = new DataSourceTransactionManager(dataSource);
TransactionStatus status = txManager.getTransaction(new DefaultTransactionDefinition());
try {
    // 业务操作
    txManager.commit(status);
} catch (Exception e) {
    txManager.rollback(status);
}

四、其他重要模式

10. 责任链模式（Chain of Responsibility）

应用场景：

• Spring Security的过滤器链
• Spring MVC的拦截器链
• AOP的通知链

// HandlerInterceptor链
public class LogInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, 
                           HttpServletResponse response, 
                           Object handler) {
        // 前置处理
        return true; // 继续链
    }
}

11. 建造者模式（Builder Pattern）

应用场景：

• RestTemplateBuilder
• SpringApplicationBuilder
• BeanDefinitionBuilder

// RestTemplate构建示例
RestTemplate restTemplate = new RestTemplateBuilder()
    .rootUri("https://api.example.com")
    .defaultHeader("Authorization", "Bearer token")
    .setConnectTimeout(Duration.ofSeconds(5))
    .build();

12. 组合模式（Composite Pattern）

应用场景：

• CompositeCacheManager
• JSR-303验证器的ConstraintValidator
• Spring表达式语言的复合表达式

// 组合缓存管理器
@Bean
public CacheManager cacheManager() {
    CompositeCacheManager composite = new CompositeCacheManager();
    composite.setCacheManagers(Arrays.asList(
        new ConcurrentMapCacheManager("cache1"),
        new EhCacheCacheManager()
    ));
    composite.setFallbackToNoOpCache(true);
    return composite;
}

五、Spring设计模式应用总结

模式应用统计表

设计模式	应用场景示例	Spring类示例
工厂模式	Bean创建	BeanFactory, ApplicationContext
单例模式	Bean作用域	DefaultSingletonBeanRegistry
原型模式	多例Bean	AbstractBeanFactory
代理模式	AOP实现	ProxyFactory, AopProxy
装饰器模式	Request包装, Cache增强	HttpServletRequestWrapper
适配器模式	Handler适配, Advisor适配	HandlerAdapter, AdvisorAdapter
模板方法	JdbcTemplate工作流程	JdbcTemplate, RestTemplate
观察者模式	事件监听机制	ApplicationEvent, EventListener
策略模式	资源访问, 事务管理	Resource, PlatformTransactionManager
责任链模式	过滤器链, 拦截器链	FilterChain, HandlerInterceptor
建造者模式	复杂对象构建	RestTemplateBuilder
组合模式	缓存组合, 验证器组合	CompositeCacheManager

设计模式带来的优势

1. 灵活性：通过策略、适配器等模式支持多种实现
2. 扩展性：模板方法、观察者等模式便于功能扩展
3. 解耦：工厂、代理等模式分离关注点
4. 一致性：通过模板方法等统一处理流程
5. 可维护性：清晰的设计模式使代码更易理解维护

最佳实践建议

1. 理解模式本质：不要为了用模式而用模式
2. 结合Spring特性：如单例模式要考虑线程安全
3. 优先使用Spring现有实现：如事件机制代替自定义观察者
4. 注意性能影响：如原型模式频繁创建对象
5. 合理选择AOP实现：JDK代理 vs CGLIB

Spring框架通过精妙地应用各种设计模式，构建了一个高度灵活、可扩展的轻量级容器。深入理解这些模式的应用，不仅能更好地使用Spring，也能提升我们的架构设计能力。