聊聊Spring中最常用的11种设计模式

作者：苏三2025-08-16

前言

最近缺项目经历想快速提升项目实战能力（包含多个AI项目），或者最近找工作，或者想学习AI的小伙伴，可以看看下面👇🏻的这个链接（或许真的能够帮到你）。

十年架构踩坑心得：不懂这些设计模式，Spring用再熟也枉然！

作为工作10年的Java老炮，看过太多"只会用@Autowired却不懂Spring精髓"的开发者。

有些小伙伴在工作中可能觉得："框架能用就行，何必深究？" 但当线上突发循环依赖报错、AOP失效、事务不回滚时，设计模式知识就是你的救命指南针！

今天，就让我们揭开Spring源码的神秘面纱，看看这11种设计模式如何支撑起这个史诗级框架。

1 工厂模式：Spring的创世神

核心作用：解耦对象创建与使用

经典应用：BeanFactory、ApplicationContext

// 源码精髓：工厂接口定义
public interface BeanFactory {
    Object getBean(String name);
    <T> T getBean(Class<T> requiredType);
}

// 实际开发中的工厂
@Configuration
public class MyConfig {
    @Bean // ⬅️ 工厂方法
    public DataSource dataSource() {
        return new HikariDataSource();
    }
}

设计价值：

隐藏复杂创建逻辑（如代理增强）
统一生命周期管理（单例/原型作用域）
解决循环依赖的三级缓存机制

2 单例模式：全局资源守护者

实现关键：容器级单例（非ClassLoader级）

// AbstractBeanFactory源码片段
public Object getSingleton(String beanName) {
    Object singleton = this.singletonObjects.get(beanName);
    if (singleton == null) {
        synchronized (this.singletonObjects) {
            singleton = this.singletonObjects.get(beanName);
            if (singleton == null) {
                singleton = createBean(beanName);
                addSingleton(beanName, singleton); // 存入一级缓存
            }
        }
    }
    return singleton;
}

三级缓存解密：

singletonObjects：成品Bean
earlySingletonObjects：半成品Bean（刚实例化）
singletonFactories：Bean工厂（解决循环依赖关键）

三、代理模式：AOP的基石

动态代理双雄：

// JDK动态代理（基于接口）
public class JdkProxy implements InvocationHandler {
    public Object createProxy(Object target) {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(), // 关键要求接口
            this);
    }
}

// CGLIB代理（基于继承）
public class CglibProxy implements MethodInterceptor {
    public Object createProxy(Class<?> targetClass) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(targetClass); // 继承目标类
        enhancer.setCallback(this);
        return enhancer.create();
    }
}

Spring的选择策略：

有接口 → JDK代理（Spring AOP默认）
无接口 → CGLIB代理（需添加spring-core依赖）

四、模板方法模式：重复劳动的终结者

经典实现：JdbcTemplate

// 伪代码展示模板结构
public class JdbcTemplate extends JdbcAccessor {
    // 定义算法骨架（final禁止重写）
    public final <T> T query(String sql, ResultSetExtractor<T> rse) {
        Connection con = getConnection(); // 抽象方法
        Statement stmt = con.createStatement();
        ResultSet rs = stmt.executeQuery(sql);
        T result = rse.extractData(rs);   // 回调方法 ⬅️ 扩展点
        releaseResources(con, stmt, rs);  // 固定流程
        return result;
    }
}

设计精髓：

固定流程：资源获取/释放等通用操作
开放扩展：通过回调接口（如RowMapper）实现业务定制

五、观察者模式：事件驱动之王

Spring事件三要素：

// 1. 自定义事件（继承ApplicationEvent）
public class OrderEvent extends ApplicationEvent {
    public OrderEvent(Order source) {
        super(source);
    }
}

// 2. 发布者（注入ApplicationEventPublisher）
@Service
public class OrderService {
    @Autowired 
    private ApplicationEventPublisher publisher;
    
    public void createOrder() {
        publisher.publishEvent(new OrderEvent(order)); // 发布事件
    }
}

// 3. 监听者（实现ApplicationListener或@EventListener）
@Component
public class LogListener implements ApplicationListener<OrderEvent> {
    @Override
    public void onApplicationEvent(OrderEvent event) {
        // 记录日志
    }
}

异步事件技巧：

@Configuration
@EnableAsync // 开启异步支持
public class AsyncConfig {}

@EventListener
@Async // ⬅️ 异步监听
public void asyncHandle(OrderEvent event) { ... }

六、适配器模式：兼容万物的转换器

MVC中的经典应用：HandlerAdapter

// 源码：DispatcherServlet如何统一调用Controller
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) {
    HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    ModelAndView mv = ha.handle(request, response, mappedHandler.getHandler());
}

// 不同Controller的适配器实现
1. RequestMappingHandlerAdapter → 处理@Controller
2. HttpRequestHandlerAdapter → 处理静态资源
3. SimpleControllerHandlerAdapter → 处理Controller接口

设计价值：新增Controller类型时，只需扩展适配器而不修改DispatcherServlet

七、装饰器模式：功能增强的隐身衣

典型案例：HttpServletRequestWrapper

// 缓存请求体装饰器
public class ContentCachingRequestWrapper extends HttpServletRequestWrapper {
    private ByteArrayOutputStream cachedContent;
    
    @Override
    public ServletInputStream getInputStream() {
        // 装饰原方法：读取时缓存数据
        if (cachedContent == null) cacheInputStream();
        return new CachedServletInputStream();
    }
    
    public byte[] getContentAsByteArray() {
        return cachedContent.toByteArray(); // 多次读取
    }
}

// Filter中使用
public void doFilter(ServletRequest req, ServletResponse res) {
    HttpServletRequest wrappedRequest = 
        new ContentCachingRequestWrapper((HttpServletRequest) req);
    chain.doFilter(wrappedRequest, res);
}

八、策略模式：灵活切换的算法库

资源加载策略：

Resource resource = new ClassPathResource("config.xml"); // 类路径策略
// 或
Resource resource = new UrlResource("https://config.com"); // 网络策略
// 或
Resource resource = new FileSystemResource("/data/config.xml"); // 文件系统策略

// 统一调用
InputStream inputStream = resource.getInputStream();

Spring的优雅实现：

public interface ResourceLoader {
    Resource getResource(String location); // 根据前缀自动选择策略
}

// 前缀映射：
// "classpath:" → ClassPathResource
// "http://" → UrlResource
// 无前缀 → 根据上下文决定

九、建造者模式：复杂对象的组装工

Spring应用：BeanDefinitionBuilder

// 构建复杂Bean定义
BeanDefinitionBuilder builder = BeanDefinitionBuilder
    .genericBeanDefinition(UserService.class)
    .addPropertyValue("maxRetry", 3)   // 设置属性
    .setInitMethodName("init")         // 初始化方法
    .setScope(BeanDefinition.SCOPE_PROTOTYPE); // 作用域

// 注册到容器
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
factory.registerBeanDefinition("userService", builder.getBeanDefinition());

对比构造器优势：

避免构造器参数爆炸（尤其可选参数多时）
构建过程更符合人类阅读习惯

十、责任链模式：拦截器的骨架

MVC拦截器实现：

// 伪代码：拦截器链执行
public class HandlerExecutionChain {
    private final List<HandlerInterceptor> interceptors = new ArrayList<>();
    
    boolean applyPreHandle(HttpRequest req, HttpResponse res) {
        for (HandlerInterceptor interceptor : interceptors) {
            if (!interceptor.preHandle(req, res)) return false; // 中断链
        }
        return true;
    }
}

// 自定义拦截器
public class LogInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest req, HttpServletResponse res) {
        System.out.println("请求进入: " + req.getRequestURI());
        return true; // 继续执行
    }
}

十一、访问者模式：AST的操作神器

Spring应用：ASM字节码操作

// 使用ASM访问Class字节码
ClassReader reader = new ClassReader("com.example.User");
ClassVisitor visitor = new ClassVisitor(Opcodes.ASM9) {
    @Override
    public MethodVisitor visitMethod(int access, String name, String desc) {
        System.out.println("访问方法: " + name);
        return super.visitMethod(access, name, desc);
    }
};
reader.accept(visitor, 0); // 开始访问

Spring中的应用场景：

AOP生成代理类
@Configuration类的CGLIB增强
事务管理的字节码插桩

终极总结：Spring设计哲学的三重境界

解耦的艺术
- 工厂模式解耦创建/使用
- 观察者模式解耦事件/监听
- 适配器模式解耦接口/实现
扩展的智慧
- 模板方法固定流程开放扩展
- 策略模式灵活切换算法
- 装饰器模式透明增强功能
复杂的封装
- 建造者模式封装对象构建
- 责任链模式封装处理流程
- 访问者模式封装结构遍历

灵魂拷问：为什么Spring需要这么多模式？
答案在源码AbstractApplicationContext的注释中：
"This implementation is based on classic design patterns and enables maximum flexibility."

最后送大家一句话：框架的尽头是设计模式，而设计模式的尽头是抽象的艺术。当你下次被Spring的魔法困扰时，不妨想想这11种模式——它们就是打开Spring源码宝库的金钥匙！