Spring 框架源码

学海无涯，志当存远。燃心砺志，奋进不辍。

愿诸君得此鸡汤，如沐春风，事业有成。

若觉此言甚善，烦请赐赞一枚，共励学途，同铸辉煌！

分模块讲解，选取核心部分如Bean的生命周期、依赖注入的实现、AOP的动态代理等。
同时，结合代码示例和流程图展示。

设计模：比如模板方法、工厂模式在Spring中的应用。

源码中的关键类，如ApplicationContext、BeanFactory、BeanPostProcessor等，需要重点解释。

先介绍整体架构，再深入具体模块，结合调试技巧，比如如何通过IDE调试Spring源码。
这样不仅可以理解理论，还能动手实践。

解决实际问题，可能需要关注扩展点、自定义Bean处理等。需要平衡理论和实用技巧。

要深入分析Spring框架的源码，需要分模块、分层次逐步解剖其核心机制。以下是Spring框架源码的核心模块解析及关键实现原理，涵盖 IoC（控制反转）容器、AOP（面向切面编程）、事务管理 和 模块化设计等核心功能：

总：核心模块与架构

Spring 源码分为多个模块，核心模块包括：

1. spring-core
   • 提供基础工具类（如 StringUtils、Assert）和核心接口（如 BeanFactory）。
   • 实现了 IoC 容器的基础功能，负责 Bean 的定义、加载和管理。
2. spring-beans
   • 定义了 Bean 的生命周期、依赖注入（DI）和 BeanDefinition 解析。
   • 核心类包括 BeanFactory、DefaultListableBeanFactory、BeanDefinitionRegistry。
3. spring-context
   • 扩展了 BeanFactory，提供应用上下文（ApplicationContext）功能。
   • 支持事件发布、国际化（i18n）、资源加载等企业级特性。
4. spring-aop
   • 实现 AOP 功能，支持动态代理（JDK 动态代理和 CGLIB）。
   • 核心类包括 Advisor、Advice、Pointcut 和 AopProxy。
5. spring-expression（SpEL）
   • 提供强大的表达式语言，用于在运行时解析和操作对象。

---

一、IoC容器核心流程

IoC 容器是 Spring 的核心，其核心接口是 BeanFactory 和 ApplicationContext。

1. BeanFactory

• 功能：负责 Bean 的创建、管理和依赖注入。
• 实现类：
  • DefaultListableBeanFactory：默认实现，支持 Bean 的注册和解析。
  • XmlBeanFactory（已废弃）：基于 XML 配置的 BeanFactory。

2. ApplicationContext

• 功能：扩展了 BeanFactory，提供更多企业级功能。
• 核心特性：
  • 事件发布（ApplicationEventPublisher）。
  • 国际化支持（MessageSource）。
  • 资源加载（ResourceLoader）。
  • 父子容器支持（HierarchicalBeanFactory）。
• 实现类：
  • ClassPathXmlApplicationContext：从类路径加载 XML 配置。
  • AnnotationConfigApplicationContext：支持基于注解的配置。

2.1 AnnotationConfigApplicationContext源码

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    this();
    register(componentClasses);
    refresh(); // 核心初始化方法
}

• refresh()方法流程：

  // AbstractApplicationContext.java
  public void refresh() {
      // 1. 准备上下文
      prepareRefresh();
      // 2. 获取BeanFactory并加载Bean定义
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
      // 3. 配置BeanFactory（如设置类加载器、注册BeanPostProcessor）
      prepareBeanFactory(beanFactory);
      // 4. 子类扩展点（如Web环境处理）
      postProcessBeanFactory(beanFactory);
      // 5. 调用BeanFactoryPostProcessor
      invokeBeanFactoryPostProcessors(beanFactory);
      // 6. 注册BeanPostProcessor
      registerBeanPostProcessors(beanFactory);
      // 7. 初始化消息源（国际化）
      initMessageSource();
      // 8. 初始化事件广播器
      initApplicationEventMulticaster();
      // 9. 子类扩展点（如Web容器初始化）
      onRefresh();
      // 10. 注册监听器
      registerListeners();
      // 11. 初始化所有单例Bean（非懒加载）
      finishBeanFactoryInitialization(beanFactory);
      // 12. 完成刷新（发布事件）
      finishRefresh();
  }

3. Bean生命周期管理

• 关键接口：BeanPostProcessor（前后置处理）、BeanFactoryPostProcessor（Bean工厂后置处理）

• 生命周期流程：

  1. 实例化：createBeanInstance()（反射调用构造器）

  2. 属性填充：populateBean()（依赖注入）

  3. 初始化：initializeBean()（调用@PostConstruct、InitializingBean）

  4. 销毁：destroyBean()（调用@PreDestroy、DisposableBean）

---

二、依赖注入（DI）实现

1. 依赖注入类型

• 字段注入：通过AutowiredAnnotationBeanPostProcessor处理@Autowired

• 构造器注入：ConstructorResolver.autowireConstructor()

• Setter注入：BeanWrapperImpl.setPropertyValues()

2. 解决循环依赖

• 三级缓存机制：

  // DefaultSingletonBeanRegistry.java
  private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();        // 一级缓存：完整Bean
  private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>();  // 二级缓存：早期引用
  private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>();     // 三级缓存：对象工厂

• 流程示例：

  1. Bean A创建 → 实例化后放入三级缓存。

  2. 注入Bean B → 触发Bean B创建。

  3. Bean B注入Bean A → 从三级缓存获取A的工厂对象 → 生成A的早期引用。

  4. Bean B完成 → Bean A完成属性填充和初始化。

---

三、AOP实现原理

1. 动态代理选择

• JDK动态代理：基于接口（Proxy.newProxyInstance()）

• CGLIB代理：基于类继承（Enhancer.create()）

• 选择逻辑：DefaultAopProxyFactory.createAopProxy()

  if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces()) {
      return new ObjenesisCglibAopProxy(config);
  } else {
      return new JdkDynamicAopProxy(config);
  }

2. 切面织入过程

• 关键类：AnnotationAwareAspectJAutoProxyCreator

• 流程：

  1. 解析切面：解析@Aspect类中的@Pointcut和@Around。

  2. 创建代理：在Bean初始化后阶段（BeanPostProcessor.postProcessAfterInitialization()）生成代理对象。

  3. 拦截调用：代理对象执行时触发MethodInterceptor链。

---

四、事务管理实现

1. 事务拦截器

• 核心类：TransactionInterceptor（实现MethodInterceptor）

• 事务属性源：AnnotationTransactionAttributeSource解析@Transactional

2. 事务执行流程

1. 开启事务：PlatformTransactionManager.getTransaction()

2. 执行业务逻辑：反射调用目标方法。

3. 提交/回滚：根据异常类型决定commit()或rollback()。

---

五、设计模式应用

设计模式	应用场景	源码示例
工厂模式	BeanFactory创建Bean	DefaultListableBeanFactory
模板方法	refresh()流程中的钩子方法	AbstractApplicationContext
代理模式	AOP动态代理、@Configuration类代理	JdkDynamicAopProxy
观察者模式	事件发布与监听机制	ApplicationEventMulticaster
策略模式	资源加载策略（ClassPath/FileSystem）	ResourceLoader

---

六、调试Spring源码的实践方法

1. 源码环境搭建

1. 克隆源码：

   git clone https://github.com/spring-projects/spring-framework.git
   cd spring-framework
   git checkout v5.3.18  # 选择稳定版本

2. Gradle构建：

   ./gradlew build -x test  # 跳过测试加速构建

2. 调试技巧

• 断点位置：

  • Bean创建：AbstractAutowireCapableBeanFactory.createBean()

  • AOP代理：AbstractAutoProxyCreator.postProcessAfterInitialization()

  • 事务拦截：TransactionInterceptor.invoke()

• 日志输出：启用Spring内部日志

  logging.level.org.springframework=DEBUG

---

七、核心源码模块速查表

模块	核心类/接口	职责
spring-beans	BeanFactory, BeanDefinition	Bean定义、实例化、依赖注入
spring-context	ApplicationContext, BeanPostProcessor	容器扩展、事件机制、资源管理
spring-aop	ProxyFactory, AspectJExpressionPointcut	AOP代理、切面匹配
spring-tx	PlatformTransactionManager, TransactionTemplate	事务抽象、声明式事务实现
spring-core	DefaultSingletonBeanRegistry, Resource	单例管理、资源加载

---

八、常见问题源码分析

1. 为什么@Transactional失效？

• 源码定位：事务代理未生成 → 检查AbstractAutoProxyCreator是否跳过该Bean。

• 常见原因：同类方法调用（未通过代理对象）、非public方法。

2. Bean循环依赖如何解决？

• 源码追踪：DefaultSingletonBeanRegistry.getSingleton()中的三级缓存逻辑。

3. @Autowired注入失败的可能原因？

• 调试点：AutowiredAnnotationBeanPostProcessor.postProcessProperties()中的依赖解析过程

特殊的面试问题： java重点学习-spring-CSDN博客

3.1 Spring框架中的单例bean是线程安全的吗?

3.2 什么是AOP，你们项目中有没有使用到AOP

3.3 Spring中事务失效的场景有哪些

3.4 spring的bean的生命周期

3.5 Spring中的循环引用

3.6 构造方法出现了循环依赖怎么解决?

3.7 SpringMVC的执行流程

3.8 springboot自动配置原理

3.9 Spring 、SpringMVC 、Springboot的常见注解有哪些

---

通过以上分析，可以系统性掌握Spring源码的核心机制。建议从IoC容器入手，逐步扩展到AOP、事务等模块，结合断点调试加深理解。

学海无涯，志当存远。燃心砺志，奋进不辍。

愿诸君得此鸡汤，如沐春风，事业有成。

若觉此言甚善，烦请赐赞一枚，共励学途，同铸辉煌！