Spring源码解析 – AnnotationConfigApplicationContext容器创建过程
本文内容纲要：
- 1. this() 初始化bean读取器和扫描器- 2. register(annotatedClasses)
- 3. refresh()刷新上下文
- 1. 刷新上线文前的预处理 prepareRefresh()：
- 2. 获取刷新后的内部Bean工厂，obtainFreshBeanFactory方法为内部bean工厂重新生成id，并返回bean工厂
- 3.BeanFactory的预准备工作 prepareBeanFactory(beanFactory):
- 5.执行bean工厂的后置处理器 invokeBeanFactoryPostProcessors（beanFactory）
- 6.注册BeanPostProcessor（Bean的后置处理器）,用于拦截bean创建过程
- 7.初始化MessageSource组件（做国际化功能；消息绑定，消息解析）
- 8.初始化事件派发器
- 10. 注册时间监听器，将项目里面的ApplicationListener注册到容器中来
- 11. 初始化所有剩下的单实例bean,单例bean在初始化容器时创建，原型bean在获取时（getbean）时创建
- 12. 完成BeanFactory的初始化创建工作，IOC容器就创建完成
Spring在BeanFactory基础上提供了一些列具体容器的实现，其中AnnotationConfigApplicationContext是一个用来管理注解bean的容器，从AnnotationConfigApplicationContext的实现结构图中可以看出：
- AnnotationConfigApplicationContext继承GenericApplicationContext这个通用应用上下文，GenericApplicationContext内部定义了一个DefaultListableBeanFactory实例，GenericApplicationContext实现了BeanDefinitionRegistry接口，所以可以通过AnnotationConfigApplicationContext实例注册bean defintion，然后调用refresh()方法来初始化上下文。
- AnnotationConfigApplicationContext继承AbstractApplicationContext，AbstractApplicationContext提供了ApplicationContext的抽象实现。
下面通过一个示例分析AnnotationConfigApplicationContext的初始化过程：
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ExtensionConfig.class);构造函数：
1 //1. 初始化bean读取器和扫描器;2 //调用父类GenericApplicationContext无参构造函数，初始化一个BeanFactory: DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory()
3 this();
4 //2.注册bean配置类
5 register(annotatedClasses);
6 //3.刷新上下文
7 refresh();
8 }
1. this() 初始化bean读取器和扫描器
1 public AnnotationConfigApplicationContext() {2 //在IOC容器中初始化一个 注解bean读取器AnnotatedBeanDefinitionReader
3 this.reader = new AnnotatedBeanDefinitionReader(this);
4 //在IOC容器中初始化一个 按类路径扫描注解bean的 扫描器
5 this.scanner = new ClassPathBeanDefinitionScanner(this);
父类GenericApplicationContext部分代码:
1 public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry { 2 private final DefaultListableBeanFactory beanFactory;
3
4 //初始化一个BeanFactory
5 public GenericApplicationContext() {
6 this.beanFactory = new DefaultListableBeanFactory();
7 }
8
9 …
10 }
2. register(annotatedClasses)
注册bean配置类, AnnotationConfigApplicationContext容器通过AnnotatedBeanDefinitionReader的register方法实现注解bean的读取，具体源码如下：
AnnotationConfigApplicationContext.java中register方法
1 //按指定bean配置类读取bean 2 public void register(Class<?>... annotatedClasses) {
3 for (Class<?> annotatedClass : annotatedClasses) {
4 registerBean(annotatedClass);
5 }
6 }
7
8 public void registerBean(Class<?> annotatedClass) {
9 doRegisterBean(annotatedClass, null, null, null);
10 }
11
12 //核心实现逻辑
13 <T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
14 @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
15 //将Bean配置类信息转成容器中AnnotatedGenericBeanDefinition数据结构, AnnotatedGenericBeanDefinition继承自BeanDefinition作用是定义一个bean的数据结构，下面的getMetadata可以获取到该bean上的注解信息
16 AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
17 //@Conditional装配条件判断是否需要跳过注册
18 if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
19 return;
20 }
21 //@param instanceSupplier a callback for creating an instance of the bean
22 //设置回调
23 abd.setInstanceSupplier(instanceSupplier);
24 //解析bean作用域(单例或者原型)，如果有@Scope注解，则解析@Scope，没有则默认为singleton
25 ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
26 //作用域写回BeanDefinition数据结构, abd中缺损的情况下为空，将默认值singleton重新赋值到abd
27 abd.setScope(scopeMetadata.getScopeName());
28 //生成bean配置类beanName
29 String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
30 //通用注解解析到abd结构中，主要是处理Lazy, primary DependsOn, Role ,Description这五个注解
31 AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
32 //@param qualifiers specific qualifier annotations to consider, if any, in addition to qualifiers at the bean class level
33 // @Qualifier特殊限定符处理，
34 if (qualifiers != null) {
35 for (Class<? extends Annotation> qualifier : qualifiers) {
36 if (Primary.class == qualifier) {
37 // 如果配置@Primary注解，则设置当前Bean为自动装配autowire时首选bean
38 abd.setPrimary(true);
39 }
40 else if (Lazy.class == qualifier) {
41 //设置当前bean为延迟加载
42 abd.setLazyInit(true);
43 }
44 else {
45 //其他注解，则添加到abd结构中
46 abd.addQualifier(new AutowireCandidateQualifier(qualifier));
47 }
48 }
49 }
50 //自定义bean注册，通常用在applicationContext创建后，手动向容器中一lambda表达式的方式注册bean,
51 //比如：applicationContext.registerBean(UserService.class, () -> new UserService());
52 for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
53 //自定义bean添加到BeanDefinition
54 customizer.customize(abd);
55 }
56 //根据beanName和bean定义信息封装一个beanhold,heanhold其实就是一个 beanname和BeanDefinition的映射
57 BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
58 //创建代理对象
59 definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
60 // BeanDefinitionReaderUtils.registerBeanDefinition 内部通过DefaultListableBeanFactory.registerBeanDefinition(String beanName, BeanDefinition beanDefinition)按名称将bean定义信息注册到容器中，
61 // 实际上DefaultListableBeanFactory内部维护一个Map<String, BeanDefinition>类型变量beanDefinitionMap，用于保存注bean定义信息（beanname 和 beandefine映射）
62 BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
63 }
register方法重点完成了bean配置类本身的解析和注册，处理过程可以分为以下几个步骤：
- 根据bean配置类，使用BeanDefinition解析Bean的定义信息，主要是一些注解信息
- Bean作用域的处理，默认缺少@Scope注解，解析成单例
- 借助AnnotationConfigUtils工具类解析通用注解
- 将bean定义信息已beanname，beandifine键值对的形式注册到ioc容器中
3. refresh()刷新上下文
refresh方法在AbstractApplicationContext容器中实现，refresh()方法的作用加载或者刷新当前的配置信息，如果已经存在spring容器，则先销毁之前的容器，重新创建spring容器，载入bean定义，完成容器初始化工作，debug进源码可以看出AnnotationConfigApplicationContext容器是通过调用其父类AbstractApplicationContext的refresh()函数启动整个IoC容器完成对Bean定义的载入。
AbstractApplicationContext.java中refresh方法的实现代码如下：
1 public void refresh() throws BeansException, IllegalStateException { 2 synchronized (this.startupShutdownMonitor) {
3 //1.刷新上下文前的预处理
4 prepareRefresh();
5
6 //2.获取刷新后的内部Bean工厂
7 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
8
9 //3.BeanFactory的预准备工作
10 prepareBeanFactory(beanFactory);
11
12 try {
13 // BeanFactory准备工作完成后，可以做一些后置处理工作，
14 // 4.空方法，用于在容器的子类中扩展
15 postProcessBeanFactory(beanFactory);
16
17 // 5. 执行BeanFactoryPostProcessor的方法，BeanFactory的后置处理器，在BeanFactory标准初始化之后执行的
18 invokeBeanFactoryPostProcessors(beanFactory);
19
20 // 6. 注册BeanPostProcessor（Bean的后置处理器）,用于拦截bean创建过程
21 registerBeanPostProcessors(beanFactory);
22
23 // 7. 初始化MessageSource组件（做国际化功能；消息绑定，消息解析）
24 initMessageSource();
25
26 // 8. 初始化事件派发器
27 initApplicationEventMulticaster();
28
29 // 9.空方法，可以用于子类实现在容器刷新时自定义逻辑
30 onRefresh();
31
32 // 10. 注册时间监听器，将所有项目里面的ApplicationListener注册到容器中来
33 registerListeners();
34
35 // 11. 初始化所有剩下的单实例bean,单例bean在初始化容器时创建，原型bean在获取时（getbean）时创建
36 finishBeanFactoryInitialization(beanFactory);
37
38 // 12. 完成BeanFactory的初始化创建工作，IOC容器就创建完成；
39 finishRefresh();
40 }
41
42 catch (BeansException ex) {
43 if (logger.isWarnEnabled()) {
44 logger.warn("Exception encountered during context initialization - " +
45 "cancelling refresh attempt: " + ex);
46 }
47
48 // Destroy already created singletons to avoid dangling resources.
49 destroyBeans();
50
51 // Reset 'active' flag.
52 cancelRefresh(ex);
53
54 // Propagate exception to caller.
55 throw ex;
56 }
57
58 finally {
59 // Reset common introspection caches in Spring's core, since we
60 // might not ever need metadata for singleton beans anymore...
61 resetCommonCaches();
62 }
63 }
64 }
具体分析refresh中的函数逻辑：
1. 刷新上线文前的预处理 prepareRefresh()：
AbstractApplicationContext. prepareRefresh ()方法:
1 protected void prepareRefresh() { 2 //设置容器启动时间
3 this.startupDate = System.currentTimeMillis();
4 //启动标识
5 this.closed.set(false);
6 this.active.set(true);
7
8 if (logger.isInfoEnabled()) {
9 logger.info("Refreshing " + this);
10 }
11
12 //空方法，用于子容器自定义个性化的属性设置方法
13 initPropertySources();
14 //检验属性的合法等
15 getEnvironment().validateRequiredProperties();
16
17 //保存容器中的一些早期的事件
18 this.earlyApplicationEvents = new LinkedHashSet<>();
19 }
2. 获取刷新后的内部Bean工厂，obtainFreshBeanFactory方法为内部bean工厂重新生成id，并返回bean工厂
AbstractApplicationContext. obtainFreshBeanFactory()方法
1 protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { 2 //为beanfactory生成唯一序列化id，beanfactory已经在GenericApplicationContext构造函数中初始化了，refreshBeanFactory的逻辑在AbstractApplicationContext的实现类GenericApplicationContext中
3 refreshBeanFactory();
4 //获取beanfactory
5 ConfigurableListableBeanFactory beanFactory = getBeanFactory();
6 if (logger.isDebugEnabled()) {
7 logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
8 }
9 return beanFactory;
10 }
GenericApplicationContext.refreshBeanFactory()实现代码
1 protected final void refreshBeanFactory() throws IllegalStateException {2 if (!this.refreshed.compareAndSet(false, true)) {
3 throw new IllegalStateException(
4 "GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
5 }
6 //生成一个序列化id
7 this.beanFactory.setSerializationId(getId());
8 }
这里使用AbstractApplicationContext. refreshBeanFactory()在不同实现容器中有点区别，如果是以xml方式配置bean，会使用AbstractRefreshableApplicationContext容器中的实现，该容器中实现xml配置文件定位，并通过BeanDefinition载入和解析xml配置文件。
而如果是注解的方式，则并没有解析项目包下的注解，而是通过在refresh()方法中执行ConfigurationClassPostProcessor后置处理器完成对bean的加载.
3.BeanFactory的预准备工作 prepareBeanFactory(beanFactory):
prepareBeanFactory主要完成beanFactory的一些属性设置
1 protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { 2 // Tell the internal bean factory to use the context's class loader etc.
3 beanFactory.setBeanClassLoader(getClassLoader()); //设置类加载器
4 beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); //bean表达式解析器
5 beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
6
7 // Configure the bean factory with context callbacks.
8 beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); //添加一个BeanPostProcessor实现ApplicationContextAwareProcessor
9 //设置忽略的自动装配接口，表示这些接口的实现类不允许通过接口自动注入
10 beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
11 beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
12 beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
13 beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
14 beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
15 beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
16
17 // BeanFactory interface not registered as resolvable type in a plain factory.
18 // MessageSource registered (and found for autowiring) as a bean.
19 //注册可以自动装配的组件，就是可以在任何组件中允许自动注入的组件
20 beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
21 beanFactory.registerResolvableDependency(ResourceLoader.class, this);
22 beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
23 beanFactory.registerResolvableDependency(ApplicationContext.class, this);
24
25 // Register early post-processor for detecting inner beans as ApplicationListeners.
26 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
27
28 //添加编译时的AspectJ
29 if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
30 beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
31 // Set a temporary ClassLoader for type matching.
32 beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
33 }
34
35 // 给beanfactory容器中注册组件ConfigurableEnvironment、systemProperties、systemEnvironment
36 if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
37 beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
38 }
39 if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
40 beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
41 }
42 if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
43 beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
44 }
45 }
5.执行bean工厂的后置处理器 invokeBeanFactoryPostProcessors（beanFactory）
IOC容器初始化过程中有三个重要的步骤，
1：资源定位，2：bean定义的载入，3：将bean名称、bean定义以key-value形式注册到容器，这三个步骤都将在此完成。
AbstractApplicationContext. invokeBeanFactoryPostProcessors方法实现：
1 protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { 2 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
3
4 // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
5 // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
6 if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
7 beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
8 beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
9 }
10 }
invokeBeanFactoryPostProcessors（beanFactory，getBeanFactoryPostProcessors()）方法内部执行实现了BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor这两个接口的Processor，先获取所有BeanDefinitionRegistryPostProcessor的实现，按优先级执行（是否实现PriorityOrdered优先级接口，是否实现Ordered顺序接口）；再以相同的策略执行所有BeanFactoryPostProcessor的实现。
PostProcessorRegistrationDelegate. invokeBeanFactoryPostProcessors实现:
1 public static void invokeBeanFactoryPostProcessors( 2 ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
3
4 // Invoke BeanDefinitionRegistryPostProcessors first, if any.
5 Set<String> processedBeans = new HashSet<>();
6
7 if (beanFactory instanceof BeanDefinitionRegistry) {
8 BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
9 List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
10 List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
11
12 for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
13 if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
14 BeanDefinitionRegistryPostProcessor registryProcessor =
15 (BeanDefinitionRegistryPostProcessor) postProcessor;
16 registryProcessor.postProcessBeanDefinitionRegistry(registry);
17 registryProcessors.add(registryProcessor);
18 }
19 else {
20 regularPostProcessors.add(postProcessor);
21 }
22 }
23
24 // Do not initialize FactoryBeans here: We need to leave all regular beans
25 // uninitialized to let the bean factory post-processors apply to them!
26 // Separate between BeanDefinitionRegistryPostProcessors that implement
27 // PriorityOrdered, Ordered, and the rest.
28 List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
29
30 // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
31 String[] postProcessorNames =
32 beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
33 for (String ppName : postProcessorNames) {
34 if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
35 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
36 processedBeans.add(ppName);
37 }
38 }
39 sortPostProcessors(currentRegistryProcessors, beanFactory);
40 registryProcessors.addAll(currentRegistryProcessors);
41 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
42 currentRegistryProcessors.clear();
43
44 // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
45 postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
46 for (String ppName : postProcessorNames) {
47 if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
48 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
49 processedBeans.add(ppName);
50 }
51 }
52 sortPostProcessors(currentRegistryProcessors, beanFactory);
53 registryProcessors.addAll(currentRegistryProcessors);
54 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
55 currentRegistryProcessors.clear();
56
57 // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
58 boolean reiterate = true;
59 while (reiterate) {
60 reiterate = false;
61 postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
62 for (String ppName : postProcessorNames) {
63 if (!processedBeans.contains(ppName)) {
64 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
65 processedBeans.add(ppName);
66 reiterate = true;
67 }
68 }
69 sortPostProcessors(currentRegistryProcessors, beanFactory);
70 registryProcessors.addAll(currentRegistryProcessors);
71 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
72 currentRegistryProcessors.clear();
73 }
74
75 // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
76 invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
77 invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
78 }
79
80 else {
81 // Invoke factory processors registered with the context instance.
82 invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
83 }
84
85 // Do not initialize FactoryBeans here: We need to leave all regular beans
86 // uninitialized to let the bean factory post-processors apply to them!
87 String[] postProcessorNames =
88 beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
89
90 // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
91 // Ordered, and the rest.
92 List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
93 List<String> orderedPostProcessorNames = new ArrayList<>();
94 List<String> nonOrderedPostProcessorNames = new ArrayList<>();
95 for (String ppName : postProcessorNames) {
96 if (processedBeans.contains(ppName)) {
97 // skip - already processed in first phase above
98 }
99 else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
100 priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
101 }
102 else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
103 orderedPostProcessorNames.add(ppName);
104 }
105 else {
106 nonOrderedPostProcessorNames.add(ppName);
107 }
108 }
109
110 // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
111 sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
112 invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
113
114 // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
115 List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
116 for (String postProcessorName : orderedPostProcessorNames) {
117 orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
118 }
119 sortPostProcessors(orderedPostProcessors, beanFactory);
120 invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
121
122 // Finally, invoke all other BeanFactoryPostProcessors.
123 List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
124 for (String postProcessorName : nonOrderedPostProcessorNames) {
125 nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
126 }
127 invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
128
129 // Clear cached merged bean definitions since the post-processors might have
130 // modified the original metadata, e.g. replacing placeholders in values...
131 beanFactory.clearMetadataCache();
132 }
这里面在处理BeanDefinitionRegistryPostProcessors时有一个非常重要的过程，AnnotationConfigApplicationContext构造函数在初始化reader时为内部beanFactory容器初始化了一个id为org.springframework.context.annotation.internalConfigurationAnnotationProcessor的组件，这是一个ConfigurationClassPostProcessor组件，用来处理添加@Configuration注解的类，并将Bean定义注册到BeanFactory中。
invokeBeanFactoryPostProcessors的实现过程是较复杂，一路debug可以发现最终在org.springframework.context.annotation.ComponentScanAnnotationParser#parse方法完成第一步：【资源文件的定位】，其实就是拿到配置类的所在的包名：
继续查看doScan方法源码：
protected Set<BeanDefinitionHolder> doScan(String... basePackages) { Assert.notEmpty(basePackages, "At least one base package must be specified");
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
for (String basePackage : basePackages) {
//从指定的包中扫描需要装载的类（bean）
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
//将扫描出的bean定义注册到IOC容器的beanDefinitionMap中
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
可以看到这个方法完成了第二和第三步，findCandidateComponents（basePackages）根据指定的扫描路径扫描并解析成beandefine, 后面通过registerBeanDefinition(definitionHolder,this.regsistry)将这些beandefine注册到IOC容器，及添加到IOC容器的beanDefinitionMap中。
6.注册BeanPostProcessor（Bean的后置处理器）,用于拦截bean创建过程
注册后置处理器的大致逻辑是：
1.获取所有的 BeanPostProcessor
2.根据处理器实现的接口区分出4中类型：
a.实现PriorityOrdered接口的处理器
b.实现Ordered接口的处理器，
c.实现MergedBeanDefinitionPostProcessor接口的处理器，
d.普通后置处理器
3.按这个4中类型依次注册到容器中
4.注册一个特殊的后置处理器ApplicationListenerDetector，ApplicationListenerDetector本身也实现了MergedBeanDefinitionPostProcessor接口，有个问题，这个为什么没有在上面c,d之间注册，而是放到最后？
AbstractApplicationContext .registerBeanPostProcessors(beanFactory);实现逻辑：
1 protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {2 PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
3 }
1 public static void registerBeanPostProcessors(
2 ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
3
4 String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
5
6 // Register BeanPostProcessorChecker that logs an info message when
7 // a bean is created during BeanPostProcessor instantiation, i.e. when
8 // a bean is not eligible for getting processed by all BeanPostProcessors.
9 int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
10 beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
11
12 // Separate between BeanPostProcessors that implement PriorityOrdered,
13 // Ordered, and the rest.
14 //按优先级分类
15 List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
16 List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
17 List<String> orderedPostProcessorNames = new ArrayList<>();
18 List<String> nonOrderedPostProcessorNames = new ArrayList<>();
19 for (String ppName : postProcessorNames) {
20 if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
21 BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
22 priorityOrderedPostProcessors.add(pp);
23 if (pp instanceof MergedBeanDefinitionPostProcessor) {
24 internalPostProcessors.add(pp);
25 }
26 }
27 else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
28 orderedPostProcessorNames.add(ppName);
29 }
30 else {
31 nonOrderedPostProcessorNames.add(ppName);
32 }
33 }
34
35 //先注册实现PriorityOrdered接口的处理器，添加到beanfactory容器中beanFactory.addBeanPostProcessor(postProcessor);
36 sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
37 registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
38
39 //注册实现Ordered接口的处理器
40 List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
41 for (String ppName : orderedPostProcessorNames) {
42 BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
43 orderedPostProcessors.add(pp);
44 if (pp instanceof MergedBeanDefinitionPostProcessor) {
45 internalPostProcessors.add(pp);
46 }
47 }
48 sortPostProcessors(orderedPostProcessors, beanFactory);
49 registerBeanPostProcessors(beanFactory, orderedPostProcessors);
50
51 // 注册没有实现Ordered或PriorityOrdered的处理器（nonOrderedPostProcessors）
52 List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
53 for (String ppName : nonOrderedPostProcessorNames) {
54 BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
55 nonOrderedPostProcessors.add(pp);
56 if (pp instanceof MergedBeanDefinitionPostProcessor) {
57 internalPostProcessors.add(pp);
58 }
59 }
60 registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
61
62 // Finally, re-register all internal BeanPostProcessors.
63 //最后，重新注册所有internal BeanPostProcessors（实现MergedBeanDefinitionPostProcessor接口的后置处理器
64 65 sortPostProcessors(internalPostProcessors, beanFactory);
66 registerBeanPostProcessors(beanFactory, internalPostProcessors);
67
68 //注册ApplicationListenerDetector，用于Bean创建完时检查是否是ApplicationListener
69 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
70 }
7.初始化MessageSource组件（做国际化功能；消息绑定，消息解析）
AbstractApplicationContext .initMessageSource()方法实现代码：
1 protected void initMessageSource() { 2 //获取beanFactory
3 ConfigurableListableBeanFactory beanFactory = getBeanFactory();
4 //判断是否已经存在id为MESSAGE_SOURCE_BEAN_NAME的组件
5 if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
6 this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
7 // Make MessageSource aware of parent MessageSource.
8 if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
9 HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
10 if (hms.getParentMessageSource() == null) {
11 // Only set parent context as parent MessageSource if no parent MessageSource
12 // registered already.
13 hms.setParentMessageSource(getInternalParentMessageSource());
14 }
15 }
16 if (logger.isDebugEnabled()) {
17 logger.debug("Using MessageSource [" + this.messageSource + "]");
18 }
19 }
20 else {
21 // Use empty MessageSource to be able to accept getMessage calls.
22 DelegatingMessageSource dms = new DelegatingMessageSource();
23 dms.setParentMessageSource(getInternalParentMessageSource());
24 this.messageSource = dms;
25 beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
26 if (logger.isDebugEnabled()) {
27 logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
28 "': using default [" + this.messageSource + "]");
29 }
30 }
31 }
8.初始化事件派发器
AbstractApplicationContext .initApplicationEventMulticaster()方法实现逻辑
1 protected void initApplicationEventMulticaster() { 2 //获取BeanFactory
3 ConfigurableListableBeanFactory beanFactory = getBeanFactory();
4 //如果有配置beanName为applicationEventMulticaster的事件派发器，则将其赋给容器中的applicationEventMulticaster对象
5 if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
6 this.applicationEventMulticaster =
7 beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
8 if (logger.isDebugEnabled()) {
9 logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
10 }
11 }
12 else {
13 //不存在，则创建一个SimpleApplicationEventMulticaster事件派发器，并注册到beanfactory中
14 this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
15 beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
16 if (logger.isDebugEnabled()) {
17 logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
18 APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
19 "': using default [" + this.applicationEventMulticaster + "]");
20 }
21 }
22 }
10. 注册时间监听器，将项目里面的ApplicationListener注册到容器中来
registerListeners方法主要实现将事件监听器添加到IOC容器中的事件派发器中，并在最后做了一个事件发布的逻辑(如果之前的步骤有产生事件，则将earlyApplicationEvents中保存的事件逐一发布)
AbstractApplicationContext .registerListeners()方法实现逻辑：
1 protected void registerListeners() { 2 // Register statically specified listeners first.
3 for (ApplicationListener<?> listener : getApplicationListeners()) {
4 getApplicationEventMulticaster().addApplicationListener(listener);
5 }
6
7 // Do not initialize FactoryBeans here: We need to leave all regular beans
8 // uninitialized to let post-processors apply to them!
9 String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
10 for (String listenerBeanName : listenerBeanNames) {
11 getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
12 }
13
14 // Publish early application events now that we finally have a multicaster...
15 Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
16 this.earlyApplicationEvents = null;
17 if (earlyEventsToProcess != null) {
18 for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
19 getApplicationEventMulticaster().multicastEvent(earlyEvent);
20 }
21 }
22 }
11. 初始化所有剩下的单实例bean,单例bean在初始化容器时创建，原型bean在获取时（getbean）时创建
AbstractApplicationContext.finishBeanFactoryInitialization(beanFactory);方法实现代码：
1 protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { 2 //组件转换器相关
3 if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
4 beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
5 beanFactory.setConversionService(
6 beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
7 }
8
9 // Register a default embedded value resolver if no bean post-processor
10 // (such as a PropertyPlaceholderConfigurer bean) registered any before:
11 // at this point, primarily for resolution in annotation attribute values.
12 if (!beanFactory.hasEmbeddedValueResolver()) {
13 beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
14 }
15
16 //aspectj相关.
17 String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
18 for (String weaverAwareName : weaverAwareNames) {
19 getBean(weaverAwareName);
20 }
21
22 // Stop using the temporary ClassLoader for type matching.
23 beanFactory.setTempClassLoader(null);
24
25 // Allow for caching all bean definition metadata, not expecting further changes.
26 beanFactory.freezeConfiguration();
27
28 // 初始化后剩下的单实例bean
29 beanFactory.preInstantiateSingletons();
30 }
DefaultListableBeanFactory. preInstantiateSingletons()方法实现逻辑：
1 public void preInstantiateSingletons() throws BeansException { 2 if (logger.isDebugEnabled()) {
3 logger.debug("Pre-instantiating singletons in " + this);
4 }
5
6 // Iterate over a copy to allow for init methods which in turn register new bean definitions.
7 // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
8 //容器中所有bean名称
9 List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
10
11 // Trigger initialization of all non-lazy singleton beans...
12 for (String beanName : beanNames) {
13 //获取Bean的定义信息；RootBeanDefinition
14 RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
15 //非抽象，单例，非延迟加载
16 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
17 //是否是FactoryBean
18 if (isFactoryBean(beanName)) {
19 // 通过"&beanName"获取工厂Bean实例
20 Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
21 if (bean instanceof FactoryBean) {
22 final FactoryBean<?> factory = (FactoryBean<?>) bean;
23 boolean isEagerInit;
24 if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
25 isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
26 ((SmartFactoryBean<?>) factory)::isEagerInit,
27 getAccessControlContext());
28 }
29 else {
30 isEagerInit = (factory instanceof SmartFactoryBean &&
31 ((SmartFactoryBean<?>) factory).isEagerInit());
32 }
33 if (isEagerInit) {
34 getBean(beanName);
35 }
36 }
37 }
38 else {
39 //不是FactoryBean,则利用getBean(beanName)实例化bean
40 getBean(beanName);
41 }
42 }
43 }
44
45 // Trigger post-initialization callback for all applicable beans...
46 for (String beanName : beanNames) {
47 Object singletonInstance = getSingleton(beanName);
48 if (singletonInstance instanceof SmartInitializingSingleton) {
49 final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
50 if (System.getSecurityManager() != null) {
51 AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
52 smartSingleton.afterSingletonsInstantiated();
53 return null;
54 }, getAccessControlContext());
55 }
56 else {
57 smartSingleton.afterSingletonsInstantiated();
58 }
59 }
60 }
61 }
12. 完成BeanFactory的初始化创建工作，IOC容器就创建完成
AbstractApplicationContext.finishRefresh()实现逻辑：
1 protected void finishRefresh() { 2 // Clear context-level resource caches (such as ASM metadata from scanning).
3 clearResourceCaches();
4
5 //初始化和生命周期有关的后置处理器LifecycleProcessor，默认DefaultLifecycleProcessor
6 initLifecycleProcessor();
7
8 // 回调生命周期处理器
9 getLifecycleProcessor().onRefresh();
10
11 //发布容器刷新完成事件：ContextRefreshedEvent
12 publishEvent(new ContextRefreshedEvent(this));
13
14 LiveBeansView.registerApplicationContext(this);
15 }
以上基本分析了AnnotationConfigApplicationContext容器的初始化过程， Spring容器在启动过程中，会先保存所有注册进来的Bean的定义信息；Spring容器根据条件创建Bean实例，区分单例，还是原型，后置处理器等（后置处理器会在容器创建过程中通过getBean创建，并执行相应的逻辑）；Spring容器在创建bean实例后，会使用多种后置处理器来增加bean的功能，比如处理自动注入，AOP，异步，这种后置处理器机制也丰富了bean的功能。
本文内容总结：1. this() 初始化bean读取器和扫描器，2. register(annotatedClasses)，3. refresh()刷新上下文，1. 刷新上线文前的预处理 prepareRefresh()：，2. 获取刷新后的内部Bean工厂，obtainFreshBeanFactory方法为内部bean工厂重新生成id，并返回bean工厂，3.BeanFactory的预准备工作 prepareBeanFactory(beanFactory):，5.执行bean工厂的后置处理器 invokeBeanFactoryPostProcessors（beanFactory），6.注册BeanPostProcessor（Bean的后置处理器）,用于拦截bean创建过程，7.初始化MessageSource组件（做国际化功能；消息绑定，消息解析），8.初始化事件派发器，10. 注册时间监听器，将项目里面的ApplicationListener注册到容器中来，11. 初始化所有剩下的单实例bean,单例bean在初始化容器时创建，原型bean在获取时（getbean）时创建，12. 完成BeanFactory的初始化创建工作，IOC容器就创建完成，
原文链接：https://www.cnblogs.com/ashleyboy/p/9662119.html
以上是 Spring源码解析 – AnnotationConfigApplicationContext容器创建过程 的全部内容， 来源链接： utcz.com/z/362550.html
