一、AnnotationConfigApplicationContext 入口
依赖于 Spring5.X 版本，目前大多数项目已放弃基于 XML 配置的方式，所以本文基于 JavaConfig 注解配置的方式理解 Spring 上下文启动的流程。
1
2
3
| AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
|
二、AnnotationConfigApplicationContext 构造方法
无论通过哪种方式最终都会调用默认构造器。
1
2
3
4
5
6
7
8
| public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
this();
register(componentClasses);
refresh();
}
|
默认构造器，优先调用父类 GenericApplicationContext 的构造器。
1
2
3
4
5
6
7
8
9
| public AnnotationConfigApplicationContext() {
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
|
1
2
3
| public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}
|
AnnotationConfigApplicationContext 默认构造器中做了两件事：
- 初始化
AnnotatedBeanDefinitionReader BeanDefinition 读取器
- 初始化
ClassPathBeanDefinitionScanner 仅供程序员外部调用，并不是 Spring 内部扫描包的类
2.1 初始化 AnnotatedBeanDefinitionReader
为 BeanFactory 注册后置处理器
实例化一个 AnnotatedBeanDefinitionReader 委托 AnnotationConfigUtils，
registerAnnotationConfigProcessors 方法很重要，在这个方法中为容器注册一系列内部的 BeanPostProcessor 后置处理器（6 个）。
- ConfigurationClassPostProcessor: 提供 Java 配置类处理能力。
- AutowiredAnnotationBeanPostProcessor: 提供 Autowired 注解的 Bean 后置处理器功能。
- CommonAnnotationBeanPostProcessor: 提供 JSR250 标准的通用注解处理器功能，Resource 注解，@@PostConstruct，@PreDestroy 等。
- PersistenceAnnotationBeanPostProcessor: 提供 JPA 相关支持。
- DefaultEventListenerFactory
- EventListenerMethodProcessor
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
| public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
if (beanFactory != null) {
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
}
if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
}
}
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
}
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);
beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
}
if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
}
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));
}
return beanDefs;
}
|
BeanPostProcessor 后置处理器
BeanPostProcessor 是 Spring 框架的一个扩展点（不止一个，5 个扩展点），通过实现 BeanPostProcessor 接口，
程序员可以干预 Bean 的实例化的过程，从而减轻了 BeanFactory 的负担，这个接口可以设置多个，会形成一个列表，然后依次执行。
比如，AOP 就是在 Bean 实例化后期将切面逻辑织入 Bean 实例中的，AOP 也正是通过 BeanPostProcessor 和 IOC 容器建立联系的
（由 Spring 提供的默认的 PostProcessor，Spring 提供了很多默认的 PostProcessor 的实现类）。
BeanPostProcessor 常用实现类：
- ApplicationContextAwareProcessor
- InitDestroyAnnotationBeanPostProcessor
- InstantiationAwareBeanPostProcessor
- CommonAnnotationBeanPostProcessor
- AutowiredAnnotationBeanPostProcessor
- RequiredAnnotationBeanPostProcessor
- BeanValidationPostProcessor
- AbstractAutoProxyCreator
- BeanFactoryPostProcessor
- ConfigurableListableBeanFactory
2.2 初始化 ClassPathBeanDefinitionScanner
初始化 ClassPath 下 BeanDefinition 的扫描器，这里的 scanner 仅仅是提供给程序员外部调用的，Spring 内部扫描包使用的是下面方法中的 scanner
org.springframework.context.annotation.ComponentScanAnnotationParser#parse()