-
本章的源码解析建议
结合源码观看（文章结尾会带有写好注释源码） -
解析源码目的：在Spring注解编程中，
AnnotationConfigApplicationContext核心的两个组件一个是读取器，一个是扫描器，而本章源码解析的就是读取器。 -
源码位置
org.springframework.context.annotation.AnnotatedBeanDefinitionReader#AnnotatedBeanDefinitionReader(org.springframework.beans.factory.support.BeanDefinitionRegistry)
一、时序图
二、类继承关系
1. AnnotationConfigApplicationContext
三、解析流程
1. 触发
- 在
AnnotationConfigApplicationContext构造器链结束后，在本类会创建AnnotatedBeanDefinitionReader读取器实例和ClassPathBeanDefinitionScanner扫描器实例。 - 本章源码讲解的就是读取器实例。
- ClassPathBeanDefinitionScanner初始化源码详解
public AnnotationConfigApplicationContext() {
StartupStep createAnnotatedBeanDefReader = getApplicationStartup().start("spring.context.annotated-bean-reader.create");
this.reader = new AnnotatedBeanDefinitionReader(this);
createAnnotatedBeanDefReader.end();
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
2. 构造函数链启动
步骤1：调用主构造函数
- 触发点：用户通过
new AnnotatedBeanDefinitionReader(registry)创建读取器实例。- registry参数就是AnnotationConfigApplicationContext对象。
- 核心逻辑：
- 调用重载构造函数AnnotatedBeanDefinitionReader(registry, getOrCreateEnvironment(registry))。
- 将BeanDefinitionRegistry（简称BR，如DefaultListableBeanFactory）传入，并通过
getOrCreateEnvironment获取环境对象。 - getOrCreateEnvironment作用：若BR已关联
Environment（如通过ConfigurableApplicationContext创建），则直接获取；否则创建默认的StandardEnvironment（包含系统属性、环境变量等）。
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
// 调用本地构造器，通过getOrCreateEnvironment方法获取环境对象传入 参数
this(registry, getOrCreateEnvironment(registry));
}
- getOrCreateEnvironment源码
private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
if (registry instanceof EnvironmentCapable) {
return ((EnvironmentCapable) registry).getEnvironment();
}
return new StandardEnvironment();
}
步骤2：执行重载构造函数
- 参数校验
- 校验
registry和environment非空，确保容器基础组件可用。
- 校验
- 属性赋值
- 将registry赋值给阅读器实例变量this.registry，用于后续注册Bean定义。
- 创建
ConditionEvaluator对象。- 该对象用于解析条件注解（如
@Conditional）。
- 该对象用于解析条件注解（如
- 源码
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
// 校验
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
Assert.notNull(environment, "Environment must not be null");
// 属性赋值
this.registry = registry;
// 属性赋值， 创建ConditionEvaluator对象
this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
// 添加Spring底层工作内置的BeanPostProcessor、BeanFactoryPostProcessor到beanDefinitionMap中
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
3. ConditionEvaluator初始化：
步骤3：调用ConditionEvaluator构造函数
- 参数传递：传入
registry、environment和null（resourceLoader后续推导）。 - 核心逻辑：创建
ConditionContextImpl实例，作为条件评估的上下文，封装容器环境、资源加载器等信息。 - ConditionEvaluator创建源码
public ConditionEvaluator(@Nullable BeanDefinitionRegistry registry,
@Nullable Environment environment, @Nullable ResourceLoader resourceLoader) {
// 初始化对象ConditionContextImpl
this.context = new ConditionContextImpl(registry, environment, resourceLoader);
}
步骤4：ConditionContextImpl构造函数初始化
beanFactory推导- 用于获取Bean工厂相关功能（如类型转换、依赖解析）。
environment初始化- 优先使用传入的environment，否则从registry中获取（若registry实现了
EnvironmentCapable接口）。
- 优先使用传入的environment，否则从registry中获取（若registry实现了
resourceLoader初始化- 优先使用传入的resourceLoader，否则若registry是ResourceLoader（如ApplicationContext），则直接使用；否则创建默认的DefaultResourceLoader。
classLoader推导- 优先从resourceLoader获取类加载器，其次从beanFactory获取，最后使用当前线程上下文类加载器。
- ConditionContextImpl创建源码
- 作用
ConditionContextImpl为@Conditional注解的条件判断提供运行时环境（如系统属性、类加载器、资源访问等）。
public ConditionContextImpl(@Nullable BeanDefinitionRegistry registry,
@Nullable Environment environment, @Nullable ResourceLoader resourceLoader) {
// 属性复制
this.registry = registry;
this.beanFactory = deduceBeanFactory(registry);
this.environment = (environment != null ? environment : deduceEnvironment(registry));
this.resourceLoader = (resourceLoader != null ? resourceLoader : deduceResourceLoader(registry));
this.classLoader = deduceClassLoader(resourceLoader, this.beanFactory);
}
4. 注册Spring内置处理器
步骤5：调用注册内置处理器方法（process）
- 核心目标：向
registry中注册Spring注解驱动所需的核心后处理器（BeanPostProcessor和BeanFactoryPostProcessor），确保容器能解析注解配置。
步骤6：解包BeanDefinitionRegistry
- 作用： 若registry是
DefaultListableBeanFactory（如AnnotationConfigApplicationContext内部工厂），则获取其实例，用于设置工厂级属性。 - DefaultListableBeanFactory源码解析请看这篇文章
- 源码
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
@Nullable
private static DefaultListableBeanFactory unwrapDefaultListableBeanFactory(BeanDefinitionRegistry registry) {
if (registry instanceof DefaultListableBeanFactory) {
return (DefaultListableBeanFactory) registry;
}
// 情况一：AnnotationConfigWebApplicationContext是GenericApplicationContext的子类，
// 在创建GenericApplicationContext对象是会new一个DefaultListableBeanFactory对象作为属性
// 所以在这里返回的就是DefaultListableBeanFactory对象
else if (registry instanceof GenericApplicationContext) {
return ((GenericApplicationContext) registry).getDefaultListableBeanFactory();
}
else {
return null;
}
}
步骤7：设置工厂级依赖比较器和自动装配解析器
- 依赖比较器：按
@Orde注解对Bean进行排序。 - 自动装配解析器：解析
@Lazy、@Value、@Qualifier等注解，处理依赖注入的候选Bean匹配。
步骤8：注册ConfigurationClassPostProcessor
- 条件：若不存在org.springframework.context.annotation.internalConfigurationAnnotationProcessor Bean定义。
- 操作：创建
RootBeanDefinition指向ConfigurationClassPostProcessor类，注册BeanFactoryPostProcessor。 - 作用：在容器refresh阶段解析
@Configuration类，处理@Bean、@Import等注解，生成对应的Bean定义。 - Spring ConfigurationClassPostProcessor工作原理与实践
- 源码
public static final String CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME =
"org.springframework.context.annotation.internalConfigurationAnnotationProcessor";
// 添加ConfigurationClassPostProcessor
// ConfigurationClassPostProcessor作用：用于在refresh中解析配置类
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
// 注册ConfigurationClassPostProcessor对于的BeanDefinition到beanDefinitionMap中。
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
步骤9：注册AutowiredAnnotationBeanPostProcessor
- 条件：若不存在org.springframework.context.annotation.internalAutowiredAnnotationProcessor Bean定义。
- 操作：注册AutowiredAnnotationBeanPostProcessor为BeanPostProcessor。
- 作用：在Bean初始化阶段解析
@Autowired、@Qualifier注解，完成依赖注入。 - Spring AutowiredAnnotationBeanPostProcessor：自动装配的核心引擎
- 源码
public static final String AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME =
"org.springframework.context.annotation.internalAutowiredAnnotationProcessor";
// 添加AutowiredAnnotationBeanPostProcessor
// AutowiredAnnotationBeanPostProcessor作用：用于解析@Autowired注解
if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
// 将BeanDefinition添加到beanDefinitionMap中
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
步骤10：注册CommonAnnotationBeanPostProcessor
- 条件
- 类路径存在
javax.annotation.PostConstruct等JSR-250相关类（jsr250Present为true）。 - 不存在org.springframework.context.annotation.internalCommonAnnotationProcessor Bean定义。
- 类路径存在
- 操作：注册该处理器，处理
@Resource、@PostConstruct等注解。 - Spring CommonAnnotationBeanPostProcessor：核心原理与实战案例
- 源码
public static final String COMMON_ANNOTATION_PROCESSOR_BEAN_NAME =
"org.springframework.context.annotation.internalCommonAnnotationProcessor";
// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
// 添加CommonAnnotationBeanPostProcessor
// CommonAnnotationBeanPostProcessor作用：用于解析@Resource注解、@WebServiceRef注解、@EJB注解
if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
def.setSource(source);
// 将BeanDefinition添加到beanDefinitionMap中
beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
}
步骤11：注册PersistenceAnnotationBeanPostProcessor
- 条件：
- 类路径存在javax.persistence.EntityManagerFactory等JPA相关类（jpaPresent为true）。
- 不存在org.springframework.context.annotation.internalPersistenceAnnotationProcessor Bean定义。
- 操作：动态加载类并注册，处理
@PersistenceContext等JPA注解。 - Spring PersistenceAnnotationBeanPostProcessor：原理、应用与实战
- 源码
public static final String PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME =
"org.springframework.context.annotation.internalPersistenceAnnotationProcessor";
// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition();
try {
def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
AnnotationConfigUtils.class.getClassLoader()));
}
catch (ClassNotFoundException ex) {
throw new IllegalStateException(
"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
}
def.setSource(source);
// 将BeanDefinition添加到beanDefinitionMap中
beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
}
步骤12：注册EventListenerMethodProcessor
- 条件：若不存在org.springframework.context.event.internalEventListenerProcessor Bean定义。
- 操作：注册该处理器，扫描
@EventListener注解方法，建立事件监听器映射。 - Spring EventListenerMethodProcessor：事件监听器的幕后英雄
- 源码
public static final String EVENT_LISTENER_PROCESSOR_BEAN_NAME =
"org.springframework.context.event.internalEventListenerProcessor";
// 添加EventListenerMethodProcessor
// EventListenerMethodProcessor作用：用于解析@EventListener注解
if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
def.setSource(source);
// 将BeanDefinition添加到beanDefinitionMap中
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
}
步骤13：注册DefaultEventListenerFactory
- 条件：若不存在org.springframework.context.event.internalEventListenerFactory Bean定义。
- 操作：注册默认
事件监听器工厂，用于创建事件监听器实例。 - Spring DefaultEventListenerFactory：事件监听器的核心工厂
- 源码
public static final String EVENT_LISTENER_FACTORY_BEAN_NAME =
"org.springframework.context.event.internalEventListenerFactory";
if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
}
四、流程图
AnnotatedBeanDefinitionReader初始化
├── 1. 构造函数启动
│ └── ABR(BeanDefinitionRegistry registry)
│ ├── 调用重载构造函数：ABR(registry, getOrCreateEnvironment(registry))
│ │ └── getOrCreateEnvironment(registry)：若registry未关联环境，创建默认StandardEnvironment（含系统属性、环境变量）
│ ├── 校验：registry和environment非空（null检查）
│ └── 赋值成员变量：this.registry = registry
│
├── 2. 初始化ConditionEvaluator（CE）
│ └── ABR->>CE: CE构造函数(registry, environment, null)
│ └── CE内部创建ConditionContextImpl（CCI）实例
│ └── CCI构造函数(registry, environment, null)
│ ├── 步骤1：赋值this.registry = registry
│ ├── 步骤2：调用deduceBeanFactory(registry)获取beanFactory（从registry推导，若为ConfigurableListableBeanFactory则直接获取）
│ ├── 步骤3：初始化environment（优先使用入参environment，否则推导默认环境）
│ ├── 步骤4：初始化resourceLoader（优先入参，否则推导默认PathMatchingResourcePatternResolver）
│ ├── 步骤5：初始化classLoader（从beanFactory或线程上下文类加载器推导）
│ └── CE赋值：this.context = CCI实例（关联上下文）
│
├── 3. 注册注解配置处理器（ACU.registerAnnotationConfigProcessors）
│ └── ABR->>ACU: registerAnnotationConfigProcessors(registry)
│ ├── 步骤1：解包获取DefaultListableBeanFactory beanFactory（从registry解包）
│ ├── 步骤2：设置依赖比较器：beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE)
│ ├── 步骤3：设置自动装配解析器：beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver())
│ └── 步骤4：条件注册后置处理器（逐个检查是否已注册，未注册则注册）
│ ├── ① ConfigurationClassPostProcessor（处理@Configuration、@Bean）
│ │ └── 若未注册 → ACU->>BR: 注册其BeanDefinition
│ ├── ② AutowiredAnnotationBeanPostProcessor（处理@Autowired、@Value）
│ │ └── 若未注册 → ACU->>BR: 注册其BeanDefinition
│ ├── ③ CommonAnnotationBeanPostProcessor（JSR-250支持，如@Resource）
│ │ └── 若JSR-250存在且未注册 → ACU->>BR: 注册其BeanDefinition
│ ├── ④ PersistenceAnnotationBeanPostProcessor（JPA支持，如@PersistenceContext）
│ │ └── 若JPA存在且未注册 → ACU->>BR: 注册其BeanDefinition
│ ├── ⑤ EventListenerMethodProcessor（处理@EventListener）
│ │ └── 若未注册 → ACU->>BR: 注册其BeanDefinition
│ └── ⑥ DefaultEventListenerFactory（事件监听器工厂）
│ └── 若未注册 → ACU->>BR: 注册其BeanDefinition
│
└── 流程结束：ABR初始化完成，后续可通过ABR注册带注解的Bean类（如@Component），容器基于已注册的后置处理器完成解析和装配。
五、总结
- 环境与上下文构建：通过AnnotatedBeanDefinitionReader构造函数链初始化Environment和ConditionEvaluator，确保条件注解解析所需的运行时环境。
- 容器能力配置：为DefaultListableBeanFactory设置依赖比较器和自动装配解析器，增强注解感知能力
- 注解驱动核心后处理器注册： 按顺序注册处理
@Configuration、@Autowired、@Resource、@EventListener等注解的后处理器，形成完整的注解解析链路。
- 关键意义
- 这些步骤是Spring注解驱动（如
@Configuration + @Bean）的基石，确保容器在后续refresh阶段能正确解析用户定义的注解配置，完成Bean的加载、依赖注入和生命周期管理。 - 后置处理器的注册顺序影响容器启动流程（如ConfigurationClassPostProcessor作为BeanFactoryPostProcessor优先执行，解析配置类后再处理其他注解）。
- 这些步骤是Spring注解驱动（如
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
