通过Spring源码学习设计模式

• 📖 什么是设计模式
• 模式的四要素
• 🌟 Spring框架与设计模式
• 📊 23种设计模式分类
• 📦 创建型模式（5种）
• 🏗️ 结构型模式（7种）
• 🔄 行为型模式（11种）
• 🏗️ UML类图基础
• 类图符号说明
• Spring中的常见关系
• 🔍 如何识别设计模式
• 模式识别线索
• 源码阅读技巧
• 🎯 Spring设计模式图谱
• 📚 学习Spring源码的步骤
• 第一步：搭建环境
• 第二步：核心包分析顺序
• 第三步：定位关键类
• ⚡ 快速参考：Spring中的设计模式
• 📝 下一步
• 参考

大家好，我是你们的技术老友科威舟，计划在最近的一段时间内不定期更新设计模式专栏，结合Spring中的源码学习Java设计模式。

📖 什么是设计模式

设计模式（Design Pattern）是软件设计中常见问题的可复用解决方案。1994年，GoF（Gang of Four）总结了23种经典模式，形成《设计模式：可复用面向对象软件的基础》。

模式的四要素

🌟 Spring框架与设计模式

Spring是设计模式的集大成者，深度应用了23种设计模式：

// Spring源码中的模式示例

// 1. 工厂模式 - BeanFactory
publicinterfaceBeanFactory{
Object getBean(String name)throws BeansException;
}

// 2. 单例模式 - DefaultSingletonBeanRegistry
publicclassDefaultSingletonBeanRegistry{
privatefinal Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
// ...
}

// 3. 模板方法 - JdbcTemplate
publicclassJdbcTemplate{
public <T> T query(...){
        Connection con = DataSourceUtils.getConnection(getDataSource());
try {
            Statement stmt = con.createStatement();
// 固定流程，execute回调留给子类/参数
        }
    }
}

// 4. 代理模式 - JdkDynamicAopProxy
publicclassJdkDynamicAopProxyimplementsAopProxy, InvocationHandler{
public Object invoke(Object proxy, Method method, Object[] args){
// 拦截调用，织入切面
    }
}

// 5. 观察者模式 - ApplicationEventMulticaster
publicabstractclassAbstractApplicationEventMulticaster{
protected List<ApplicationListener<?>> listeners = new CopyOnWriteArrayList<>();
publicvoidmulticastEvent(ApplicationEvent event){
for (ApplicationListener<?> listener : this.listeners) {
            listener.onApplicationEvent(event);  // 通知所有观察者
        }
    }
}

📊 23种设计模式分类

📦 创建型模式（5种）

关注对象的创建过程

🏗️ 结构型模式（7种）

关注类和对象的组合

🔄 行为型模式（11种）

关注对象间的职责分配

🏗️ UML类图基础

类图符号说明

classDiagram
    class AbstractClass {
        <<abstract>>
        +abstractMethod()
        +concreteMethod()
        #protectedField
        -privateField
        +publicField
    }
    class Interface {
        <<interface>>
        +method()
    }
    class Implementation {
        +method()
    }

    Interface <|-- Implementation : 实现
    AbstractClass <|-- ConcreteClass : 继承
    ConcreteClass ..> Interface : 依赖
    ConcreteClass *-- "1..*" Component : 组合
    ConcreteClass o-- OtherClass : 关联

Spring中的常见关系

// 继承（泛化）
publicclassClassPathXmlApplicationContext
extendsAbstractRefreshableConfigApplicationContext{
// 继承实现
}

// 实现
publicclassAnnotationConfigApplicationContext
extendsAbstractApplicationContext
implementsBeanDefinitionRegistry, BeanNameAware{
// 实现 BeanDefinitionRegistry 接口
}

// 组合（聚合）
publicclassDefaultListableBeanFactoryextendsAbstractBeanFactory{
privatefinal Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();
// 组合 Map
}

// 依赖注入
@Service
publicclassUserService{
@Autowired
private UserRepository repository;  // 依赖注入
}

🔍 如何识别设计模式

模式识别线索

源码阅读技巧

// 1. 看类名 - 包含模式关键词
classJdkDynamicAopProxy  // Proxy → 代理模式
classAbstractFactory    // Factory → 工厂模式
classBeanDefinitionBuilder // Builder → 建造者模式

// 2. 看接口 - 定义扩展点
publicinterfaceBeanPostProcessor{
Object postProcessBeforeInitialization(Object bean, String beanName);
Object postProcessAfterInitialization(Object bean, String beanName);
// 观察者模式的回调方法
}

// 3. 看继承层次 - 模板方法
publicabstractclassAbstractApplicationContext
extendsDefaultResourceLoader
implementsConfigurableApplicationContext{
// 抽象类定义流程骨架，子类实现步骤
publicvoidrefresh()throws BeansException {
        prepareRefresh();
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        prepareBeanFactory(beanFactory);
        postProcessBeanFactory(beanFactory);  // 模板方法钩子
        invokeBeanFactoryPostProcessors(beanFactory);
        registerBeanPostProcessors(beanFactory);
        onRefresh();  // 子类可覆盖
        finishRefresh();
    }
}

🎯 Spring设计模式图谱

graph TB
    subgraph "创建型 (5)"
        F1[工厂方法<br/>BeanFactory]
        F2[抽象工厂<br/>ApplicationContext]
        F3[建造者<br/>BeanDefinitionBuilder]
        F4[原型<br/>PrototypeScope]
        F5[单例<br/>SingletonBeanRegistry]
    end

    subgraph "结构型 (7)"
        S1[适配器<br/>MethodInterceptor]
        S2[桥接<br/>Resource/Access]
        S3[组合<br/>BeanDefinition]
        S4[装饰器<br/>BeanPostProcessor]
        S5[外观<br/>ApplicationContext]
        S6[享元<br/>ConcurrentReferenceHashMap]
        S7[代理<br/>AopProxy]
    end

    subgraph "行为型 (11)"
        B1[责任链<br/>InterceptorChain]
        B2[命令<br/>Runnable]
        B3[解释器<br/>SpEL]
        B4[迭代器<br/>Iterator]
        B5[中介者<br/>EventMulticaster]
        B6[备忘录<br/>Transaction]
        B7[观察者<br/>ApplicationEvent]
        B8[状态<br/>Connection]
        B9[策略<br/>Cache]
        B10[模板方法<br/>JdbcTemplate]
        B11[访问者<br/>BeanDefinitionVisitor]
    end

    Core[Spring Core<br/>IoC容器] --> F1
    Core --> F2
    Core --> F3
    Core --> F4
    Core --> F5

    AOP[Spring AOP] --> S7
    AOP --> S1
    AOP --> S4

    Context[Spring Context] --> S5
    Context --> B5
    Context --> B7

    JDBC[Spring JDBC] --> B10
    ORM[Spring ORM] --> S1

📚 学习Spring源码的步骤

第一步：搭建环境

# 1. 克隆Spring源码
git clone https://github.com/spring-projects/spring-framework.git
cd spring-framework
git checkout 6.1.x

# 2. 导入IDEA
# File → Open → 选择spring-framework目录
# 等待索引完成（可能需要30分钟）

# 3. 编译
./gradlew clean build -x test

第二步：核心包分析顺序

1. spring-core      (基础工具、转换、资源)
2. spring-beans     (BeanFactory、依赖注入)
3. spring-context   (ApplicationContext、事件)
4. spring-aop       (AOP、代理)
5. spring-jdbc      (模板方法)
6. spring-orm       (ORM集成、适配器)
7. spring-webmvc    (MVC、DispatcherServlet)

第三步：定位关键类

# 查找BeanFactory的实现
find . -name "*BeanFactory*.java" -type f

# 查找Template
find . -name "*Template*.java" -type f

# 查找Adapter
find . -name "*Adapter*.java" -type f

⚡ 快速参考：Spring中的设计模式

📝 下一步

✅ 掌握Spring设计模式识别后，继续学习：

👉 工厂方法模式

参考

• 📖 Johnson, R. et al. (2004). Expert One-on-One J2EE Development Without EJB
• 📖 Walls, C. & Breidenbach, R. (2018). Spring in Action
• 🌐 Spring Framework GitHub
• 🌐 Spring Docs – Core Technologies

• 本文主要观点基于以上参考资料，结合实际开发经验整理而成。转载请注明出处。*

更多技术干货欢迎关注微信公众号科威舟的AI笔记~

【转载须知】：转载请注明原文出处及作者信息