Spring IOC加载源码
# Spring IOC加载过程
# 一、实例化容器 new AnnotationConfigApplicationContext(componentClasses)
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(KevinConfig.class);
1
# AnnotationConfigApplicationContext的结构关系
# 创建AnnotationConfigApplicationContext对象
//根据参数类型可以知道，其实可以传入多个annotatedClasses，但是这种情况出现的比较少
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
/**
* 调用构造函数
* 首先会调用父类GenericApplicationContext的构造函数
* 父类构造函数里边只做一件事：初始化BeanFactory：this.beanFactory = new DefaultListableBeanFactory()
* 本类构造函数里边做了两件事：初始化BeanDefinition配置类读取器（AnnotatedBeanDefinitionReader reader）和一个扫描器（ClassPathBeanDefinitionScanner scanner）
* scanner初始化之后用处不大，仅仅只会在外部手动调用 `.scan()`方法才会使用到这个对象，常规方式Spring用不到这个scanner对象，会重新new一个新的scanner对象
*/
this();
/**
* 将传入的类进行注册
* 这个配置类有两种情况，一种是传统意义上的带上@Configuration注解的配置类，还有一种是没有带上@Configuration，
* 但是带有@Component，@Import，@ImportResouce，@Service，@ComponentScan等注解的配置类，在Spring内部把前者称为Full配置类，把后者称之为Lite配置类。
* 有些地方也把Lite配置类称为普通Bean
* 有两种情况：
* 1、传入传统配置类（@Configuration修饰的类）
* 2、传入普通类（一般不会这么做）
* 注册配置类为BeanDefinition
*/
register(componentClasses);
//IOC容器刷新接口
refresh();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 二、调用无参构造方法this()
public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
/**
* beanDefinition（Bean定义）读取器，主要作用用来读取被注解修饰的bean并解析注解信息
* 它能解析的注解信息：@Conditional，@Scope、@Lazy、@Primary、@DependsOn、@Role、@Description
*/
private final AnnotatedBeanDefinitionReader reader;
/**
* 扫描器功能与上述BeanDefinitionReader类似，它可以扫描某个包路径，对扫描的类进行解析，如果扫描到类上边有@Component注解
* 那么就会将该类解析为一个BeanDefinition
*/
private final ClassPathBeanDefinitionScanner scanner;
public AnnotationConfigApplicationContext() {
/**
* TODO 会隐式调用父类GenericApplicationContext的构造方法，初始化DefaultListableBeanFactory
* this.beanFactory = new DefaultListableBeanFactory();
*/
/**
* 初始化一个BeanDefinition读取器，Spring基础类
* 主要做了两件事：
* 1、初始化内置BeanPostProcess后置处理器
* 2、初始化内置相关BeanDefinition
*/
this.reader = new AnnotatedBeanDefinitionReader(this);
/**
* 初始化一个BeanDefinition扫描器，Spring基础类
* spring默认的扫描包不是这个scanner对象
* 而是自己new的一个ClassPathBeanDefinitionScanner
* spring在执行工程后置处理器ConfigurationClassPostProcessor时，去扫描包时会new一个ClassPathBeanDefinitionScanner
* 这里的scanner仅仅是为了程序员可以手动调用AnnotationConfigApplicationContext对象的scan方法
*/
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
}
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
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
# 三、实例化工厂DefaultListableBeanFactory
# DefaultListableBeanFactory的关系图
public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
private final DefaultListableBeanFactory beanFactory;
@Nullable
private ResourceLoader resourceLoader;
private boolean customClassLoader = false;
private final AtomicBoolean refreshed = new AtomicBoolean();
/**
* Create a new GenericApplicationContext.
* @see #registerBeanDefinition
* @see #refresh
*/
public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
DefaultListableBeanFactory是相当重要的，从字面意思就可以看出它是一个Bean的工厂，什么是Bean的工厂？当然就是用来生产和获得Bean的。它还继承和实现了很多接口实现了很多功能
# 四、初始化一个BeanDefinition读取器 new AnnotatedBeanDefinitionReader(this)
初始化一个BeanDefinition读取器，Spring基础类 * 主要做了两件事：
1、初始化内置BeanFactoryPostProcess后置处理器(ConfigurationClassPostProcessor.class BeanDefinition)
2、初始化内置相关BeanDefinition
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;
//处理条件注解 @Conditional os.name
this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
//注册一些内置Bean工厂后置处理器
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
注册内置后置处理器；调用AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);方法
主要代码片段如下：
☎️AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry)代码片段
//注册实现了@Order接口的排序器
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
/**
* 注册@Autowired的候选解析器ContextAnnotationAutowireCandidateResolver以便在决定一个bean定义是否应该被视为自动装配的候选时使用。
* getLazyResolutionProxyIfNecessary 如果字段上带有@Lazy注解，表示需要进行懒加载，Spring不会立即创建注入属性的实例，而是生成代理对象，来代替实例
* 等到真正使用该属性的时候再去创建该实例对象
*/
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
/**
* 注册解析配置类的后置处理器ConfigurationClassPostProcessor
* beanName：org.springframework.context.annotation.internalConfigurationAnnotationProcessor
*/
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
/**
* 注册处理@Autowired注解的处理器AutowiredAnnotationBeanPostProcessor
* beanName：org.springframework.context.annotation.internalAutowiredAnnotationProcessor
*/
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
/**
* 注册处理@Required注解的处理器CommonAnnotationBeanPostProcessor
* beanName：org.springframework.context.annotation.internalCommonAnnotationProcessor
*/
RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
/**
* 注册处理监听方法注解@EnentListener解析器EventListenerMethodProcessor
* beanName：org.springframework.context.event.internalEventListenerProcessor
*/
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));
}
/**
* 注册事件监听器工厂 DefaultEventListenerFactory
* beanName：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));
}
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
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
调用registerPostProcessor（）,实际跳转到DefaultListableBeanFactory.registerBeanDefinition()方法
//beanDefinitionMap是Map<String, BeanDefinition>，
//这里就是把beanName作为key，ScopedProxyMode作为value，推到map里面
this.beanDefinitionMap.put(beanName, beanDefinition);
//beanDefinitionNames就是一个List<String>,这里就是把beanName放到List中去
this.beanDefinitionNames.add(beanName);
1
2
3
4
5
6
2
3
4
5
6
# 什么是BeanDefinition?
它是用来描述Bean的，里面存放着关于Bean的一系列信息，比如Bean的作用域，Bean所对应的Class，是否懒加载，是否Primary等等.
注册这些内置处理器BeanDefinition会调用registerPostProcessor（）方法注册BeanDefinition，默认会调用工厂类DefaultListableBeanFactory.registerBeanDefinition()方法进行注册最终会将注册好的BeanDefinition放入两个map中，这两个Map集合属于DefaultListableBeanFactory 工厂，这里仅仅是将class注册为BeanDefinition，还没有真正生产Bean，这其中最重要的一个Bean就是BeanDefinitionRegistryPostProcessor它是一个接口，当前注册的是它的实现类**ConfigurationClassPostProcessor**
BeanDefinitionRegistryPostProcessor接口又扩展了BeanFactoryPostProcessor接口，BeanFactoryPostProcessor是Spring的扩展点之一，ConfigurationClassPostProcessor是Spring极为重要的一个类，里面执行了扫描Bean，Import，ImportResouce等各种操作；用来处理配置类（有两种情况 一种是传统意义上的配置类，一种是普通的bean）的各种逻辑；它实现了BeanDefinitionRegistryPostProcessor接口；BeanDefinitionRegistryPostProcessor接口又实现了BeanFactoryPostProcessor接口
# ConfigurationClassPostProcessor类关系图
除了注册了ConfigurationClassPostProcessor，还注册了其他Bean，其他Bean也都实现了其他接口，比如BeanPostProcessor等。
BeanPostProcessor接口也是Spring的扩展点之一。
至此，实例化AnnotatedBeanDefinitionReader reader分析完毕。
# 五、创建BeanDefinition扫描器：ClassPathBeanDefinitionScanner
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
Environment environment, @Nullable ResourceLoader resourceLoader) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
this.registry = registry;
/**
* 设置默认扫描规则为true，默认扫描所有的，若使用includeFilters来表示只包含需要设置为false
*/
if (useDefaultFilters) {
registerDefaultFilters();
}
//设置环境对象
setEnvironment(environment);
//设置资源加载器
setResourceLoader(resourceLoader);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
调用ClassPathBeanDefinitionScanner父类 ClassPathScanningCandidateComponentProvider.registerDefaultFilters（）方法
//添加扫描@Component的
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
1
2
3
2
3
- spring默认的扫描包不是这个
scanner对象而是自己new的一个ClassPathBeanDefinitionScanner；spring在执行工程后置处理器ConfigurationClassPostProcessor时，去扫描包时会new一个ClassPathBeanDefinitionScanner这里的scanner仅仅是为了程序员可以手动调用AnnotationConfigApplicationContext对象的scan方法 - 会加载系统环境变量和资源读取器并且里面定义了扫描包的核心方法doScan().但是这里的scanner只用于applicationContext调用调度扫描包注册beanDefinition
- 这里主要设置了环境对象
setEnvironment(environment);和设置了资源加载器setResourceLoader(resourceLoader);还有个非常重要的地方，new ClassPathBeanDefinitionScanner的时候会调用registerDefaultFilters();在里面注册扫描时过滤候选component的includeFilters
# 六、注册配置类（KevinConfig.class）为BeanDefinition：register(componentClasses)
# AnnotatedBeanDefinitionReader.doRegisterBean()
1、判断当前配置类是否有@Condition注解，当不满足条件，这个bean就不会被解析
2、解析bean的作用域，如果没有设置的话，默认为单例（singleton）
3、获取BeanName（注解value值为空取beanClass类名）
4、AnnotationConfigUtils.processCommonDefinitionAnnotations(abd)解析通用注解，填充到AnnotatedGenericBeanDefinition，解析的注解为Lazy，Primary，DependsOn，Role，Description
5、注册BeanDefinition，最终会调用DefaultListableBeanFactory.registerBeanDefinition()方法去注册
代码片段如下：
private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
@Nullable BeanDefinitionCustomizer[] customizers) {
//创建一个BeanDefinition
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
//判断是否需要跳过注解，spring中有一个@Condition注解，当不满足条件，这个bean就不会被解析
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
abd.setInstanceSupplier(supplier);
//解析bean的作用域，如果没有设置的话，默认为单例
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());
//获取BeanName（注解value值为空取beanClass类名）
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
//解析通用注解，填充到AnnotatedGenericBeanDefinition，解析的注解为Lazy，Primary，DependsOn，Role，Description
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
/**
* 注册BeanDefinition，最终会调用DefaultListableBeanFactory中的registerBeanDefinition方法去注册，
* DefaultListableBeanFactory维护着一系列信息，比如beanDefinitionNames，beanDefinitionMap
* beanDefinitionNames是一个List<String>,用来保存beanName
* beanDefinitionMap是一个Map,用来保存beanName和beanDefinition
*/
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
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
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
最终调用链条来到DefaultListableBeanFactory.registerBeanDefinition()这里和new AnnotatedBeanDefinitionReader时初始化内置相关BeanDefinition调用的是同一个方法
# DefaultListableBeanFactory.registerBeanDefinition()
DefaultListableBeanFactory维护着一系列信息，比如beanDefinitionNames，beanDefinitionMap
beanDefinitionNames是一个List<String>,用来保存beanName
beanDefinitionMap是一个Map,用来保存beanName和beanDefinition
6、判断当前BeanDefinition是否已经创建过Bean（如果已经创建过Bean则更新BeanDefinition）
7、判断当前BeanDefinition已存在或者该bean已经在创建中则重置当前Bean定义
此方法会将componentClasses传进来的配置类注册为BeanDefinition
# 七、refresh()方法
大家可以看到其实到这里，Spring还没有进行扫描，只是实例化了一个工厂，注册了一些内置的BeanDefinition和我们传进去的配置类注册为BeanDefinition，真正的大头是在第三行代码：refresh()
☎️refresh()代码
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
// Prepare this context for refreshing.
/**
* 1、准备刷新上下文环境（与主流程关系不大，保存了容器驱动时间和启动标识）
*/
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
/**
* 2、获取告诉子类初始化Bean工厂 不同工厂不同实现
*/
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
/**
* 3、对bean工厂进行填充属性
添加了两个后置处理器：ApplicationContextAwareProcessor，ApplicationListenerDetector
还设置了 忽略自动装配 和 允许自动装配 的接口,如果不存在某个bean的时候，spring就自动注册singleton bean
还设置了bean表达式解析器 等
*/
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
/**
* 4、bean工厂后置处理器（空方法留给子类去实现该接口设置一下BeanFactory）
*/
postProcessBeanFactory(beanFactory);
StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
// Invoke factory processors registered as beans in the context.
/**
* 5、调用我们的bean工厂的后置处理器.
* BeanFactory准备好了之后，执行BeanFactoryPostProcessor，开始对BeanFactory进行处理
* 默认情况下:
* 此时beanFactory的beanDefinitionMap中有6个BeanDefinition，5个基础BeanDefinition+AppConfig的BeanDefinition
* 而这6个中只有一个BeanFactoryPostProcessor：ConfigurationClassPostProcessor
* 这里会执行ConfigurationClassPostProcessor进行@Component的扫描，扫描得到BeanDefinition，并注册到beanFactory中
* 注意：扫描的过程中可能又会扫描出其他的BeanFactoryPostProcessor，那么这些BeanFactoryPostProcessor也是在这一步执行
*/
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
/**
* 6、注册Bean后置处理器（注册BeanPostProcessor）
将扫描到的BeanPostProcessors实例化并排序，并添加到BeanFactory的beanPostProcessors属性中去
*/
registerBeanPostProcessors(beanFactory);
beanPostProcess.end();
// Initialize message source for this context.
/**
* 7、初始化国际化资源处理器
设置ApplicationContext的MessageSource，要么是用户设置的，要么是DelegatingMessageSource
*/
initMessageSource();
// Initialize event multicaster for this context.
/**
* 8、初始化时间多播器
设置ApplicationContext的applicationEventMulticaster，要么是用户设置的，要么是SimpleApplicationEventMulticaster
*/
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
/**
* 9、这个方法同样也是留给子类实现的
* springboot也是从这个方法进行启动tomcat的.
*/
onRefresh();
// Check for listener beans and register them.
/**
* 10、把我们的事件监听器注册到多播器上
把定义的ApplicationListener的Bean对象，设置到ApplicationContext中去，并执行在此之前所发布的事件
*/
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
/**
* 11、实例化我们剩余的单实例bean.（将BeanDefinition实例化为Bean）
*/
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
/**
* 12、最后容器刷新 发布刷新事件(Spring cloud也是从这里启动的)
*/
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
/**
* 出现异常：销毁已经创建的单例以免浪费资源
*/
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
contextRefresh.end();
}
}
}
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
分析前五个小方法：
# 7.1 prepareRefresh
从命名来看，就知道这个方法主要做了一些刷新前的准备工作，和主流程关系不大，主要是保存了容器的启动时间，启动标志等。
# 7.2 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()
这个方法和主流程关系也不是很大，可以简单的认为，就是把beanFactory取出来而已。XML模式下会在这里读取BeanDefinition
# 7.3 prepareBeanFactory
//还是一些准备工作，添加了两个后置处理器：ApplicationContextAwareProcessor，ApplicationListenerDetector
//还设置了 忽略自动装配 和 允许自动装配 的接口,如果不存在某个bean的时候，spring就自动注册singleton bean
//还设置了bean表达式解析器 等
prepareBeanFactory(beanFactory);
1
2
3
4
2
3
4
未完待续....
# 7.4 postProcessBeanFactory(beanFactory)
//这是一个空方法
postProcessBeanFactory(beanFactory);
1
2
2
# 7.5 invokeBeanFactoryPostProcessors(beanFactory)（重点方法）
这个方法会调用我们的bean工厂的后置处理器：
BeanDefinitionRegistryPostProcessor(带注册BeanDefinition功能的Bean工厂后置处理器)后置处理器和BeanFactoryPostProcessor后置处理器
- 会在此将class扫描成beanDefinition
- bean工厂的后置处理器调用（调用前面注册的ConfigurationClassPostProcessor Bean工厂后置处理器）
- 自定义的BeanFactoryProcessor和内置的BeanFactoryProcessor
/**
* 实例化和调用所有已注册的BeanFactoryPostProcessor bean
*/
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
/**
* 获取两处存储BeanFactoryPostProcessor的对象 传入供接下来的调用
* 1.当前Bean工厂
* 2.和我们自己调用addBeanFactoryPostProcessor的自定义BeanFactoryPostProcessor
* spring允许我们手动添加BeanFactoryPostProcessor
* 即：annotationConfigApplicationContext.addBeanFactoryPostProcessor(XXX);
*/
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
getBeanFactoryPostProcessors()这里获得的是BeanFactoryPostProcessor，正常情况下，beanFactoryPostProcessors肯定没有数据；因为这里beanFactoryPostProcessors是获得手动添加的，而不是spring扫描的；只有手动调用annotationConfigApplicationContext.addBeanFactoryPostProcessor(XXX)才会有数据AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(AppConfig.class); annotationConfigApplicationContext.addBeanFactoryPostProcessor(XXX);1
2
🌽接下来看到重点PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()方法片段
☎️invokeBeanFactoryPostProcessors()代码
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
/** ========第一步Begin：调用BeanDefinitionRegistryPostProcessor的后置处理器 Begin ==========*/
/**
* 定义存放已经调用处理过的后置处理器集合
*/
Set<String> processedBeans = new HashSet<>();
/**
* 判断我们的beanFactory是否实现了BeanDefinitionRegistry(实现了该结构就有注册和获取Bean定义的能力）
* beanFactory是DefaultListableBeanFactory，是BeanDefinitionRegistry的实现类，所以肯定满足if
* 并且强行把我们的bean工厂转为BeanDefinitionRegistry，因为待会需要注册Bean定义
* BeanDefinitionRegistry registry = beanFactory
*/
if (beanFactory instanceof BeanDefinitionRegistry registry) {
/**
* 定义保存实现了BeanFactoryPostProcessor类型的后置处理器集合
*/
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
/**
* 定义保存实现了BeanDefinitionRegistryPostProcessor类型的后置处理器集合
* BeanDefinitionRegistryPostProcessor扩展了BeanFactoryPostProcessor
*/
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
//----------------第①步：循环我们传递进来的beanFactoryPostProcessors开始-- 优先级No1- begin-------------*/
/**
* 循环传进来的beanFactoryPostProcessors，正常情况下，beanFactoryPostProcessors肯定没有数据
* 因为beanFactoryPostProcessors是获得手动添加的，而不是spring扫描的
* 只有手动调用annotationConfigApplicationContext.addBeanFactoryPostProcessor(XXX)才会有数据
*/
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
/**
* 判断postProcessor是不是BeanDefinitionRegistryPostProcessor，因为BeanDefinitionRegistryPostProcessor
* 扩展了BeanFactoryPostProcessor，所以这里先要判断是不是BeanDefinitionRegistryPostProcessor
* 是的话，直接执行postProcessBeanDefinitionRegistry方法，然后把对象装到registryProcessors里面去
*
* 如果类型匹配则进行类型转换 BeanDefinitionRegistryPostProcessor registryProcessor = postProcessor
*/
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor registryProcessor) {
//调用它作为BeanDefinitionRegistryPostProcessor的处理器的后置方法
registryProcessor.postProcessBeanDefinitionRegistry(registry);
//添加到我们用于保存的BeanDefinitionRegistryPostProcessor的集合中
registryProcessors.add(registryProcessor);
}
else {
//若没有实现BeanDefinitionRegistryPostProcessor 接口，那么他就是BeanFactoryPostProcessor
//把当前的后置处理器加入到regularPostProcessors中
regularPostProcessors.add(postProcessor);
}
}
//----------------第①步：循环我们传递进来的beanFactoryPostProcessors结束-- 优先级No1- end----------------*/
//定义一个集合用于保存临时准备创建的BeanDefinitionRegistryPostProcessor
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
//----------------第②步：调用内置实现PriorityOrdered接口BeanDefinitionRegistryPostProcessor开始--优先级No2-Begin--------------/
/**
* 去容器中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称
* 获取BeanDefinition注册后置处理器
* 获得实现BeanDefinitionRegistryPostProcessor接口的类的BeanName:org.springframework.context.annotation.internalConfigurationAnnotationProcessor
* 并且装入数组postProcessorNames，我理解一般情况下，只会找到一个(ConfigurationClassPostProcessor.class)
* 这里需要注意，为什么我自己创建了一个实现BeanDefinitionRegistryPostProcessor接口的类，也打上了@Component注解
* 配置类也加上了@Component注解，但是这里却没有拿到
* 因为直到这一步，Spring还没有去扫描，扫描是在ConfigurationClassPostProcessor类中完成的，也就是下面的第一个
* invokeBeanDefinitionRegistryPostProcessors方法
*/
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
//循环筛选出来的匹配BeanDefinitionRegistryPostProcessor的类型名称
for (String ppName : postProcessorNames) {
//判断是否实现了PriorityOrdered接口（ConfigurationClassPostProcessor实现了PriorityOrdered接口）
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
/**
* 显示的调用getBean()的方式获得ConfigurationClassPostProcessor类，并且放到currentRegistryProcessors
*/
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
//把name放到processedBeans，后续会根据这个集合来判断处理器是否已经被执行过了
processedBeans.add(ppName);
}
}
/**
* 对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序
*/
sortPostProcessors(currentRegistryProcessors, beanFactory);
/**
* 合并Processors，为什么要合并，因为registryProcessors是装载BeanDefinitionRegistryPostProcessor的集合
* 一开始的时候，spring只会执行BeanDefinitionRegistryPostProcessor独有的方法
* 而不会执行BeanDefinitionRegistryPostProcessor父类的方法，即BeanFactoryPostProcessor的方法
* 所以这里需要把处理器放入一个集合中，后续统一执行父类的postProcessBeanFactory()方法
*/
registryProcessors.addAll(currentRegistryProcessors);
/**
* 可以理解为执行ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry()方法
* 用于进行bean定义的加载 比如我们的包扫描，@Component @import 等等。。。。。。。。。
* 调用此方法就完成了扫描@Component的Bean的操作
* Spring热插播的体现，像ConfigurationClassPostProcessor就相当于一个组件，Spring很多事情就是交给组件去管理
* 如果不想用这个组件，直接把注册组件的那一步去掉就可以
*/
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
//调用完之后，马上clea掉，后边还需要处理其他类型的BeanDefinitionRegistryPostProcessor
currentRegistryProcessors.clear();
//----------------第②步：调用内置实现PriorityOrdered接口BeanDefinitionRegistryPostProcessor完毕--优先级No2-End-----------------/
//----------------第③步：调用内置实现Ordered接口BeanDefinitionRegistryPostProcessor开始--优先级No3-Begin--------------/
/**
* 再次根据BeanDefinitionRegistryPostProcessor获得BeanName，看这个BeanName是否已经被执行过了，有没有实现Ordered接口
* 在这里才可以获取到我们自己定义的实现了BeanDefinitionRegistryPostProcessor的Bean
*/
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
/**
* processedBeans.contains(ppName) 这句代码判断当前BeanDefinitionRegistryPostProcessor是否已经执行过
* beanFactory.isTypeMatch(ppName, Ordered.class) 这句代码判断当前BeanDefinitionRegistryPostProcessor是否实现了Ordered即接口
*/
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
/**
* 如果没有被执行过，也实现了Ordered接口的话，把对象放到临时集合currentRegistryProcessors中，名称添加到processedBeans集合中
*/
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
/**
* 对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序
*/
sortPostProcessors(currentRegistryProcessors, beanFactory);
/**
* 同上进行合并Processors进行后续统一执行BeanDefinitionRegistryPostProcessor父类的方法
* 即postProcessBeanFactory()方法
*/
registryProcessors.addAll(currentRegistryProcessors);
/**
* 可以理解为执行BeanDefinitionRegistryPostProcessor实现类（并且实现了Ordered接口）的postProcessBeanDefinitionRegistry()方法
* 用于进行bean定义的加载 比如我们的包扫描，@import 等等。。。。。。。。。
*/
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
/**
* 清除postProcessBeanDefinitionRegistry临时集合
*/
currentRegistryProcessors.clear();
//--------------第③步：调用内置实现Ordered接口BeanDefinitionRegistryPostProcessor开始--优先级No3-End----------------/
//--------------第④步：调用内置其他BeanDefinitionRegistryPostProcessor开始--优先级No4-Begin----------------/
//死循环调用所有其他BeanDefinitionRegistryPostProcessors函数，直到不再出现其他BeanDefinitionRegistryPostProcessors函数
boolean reiterate = true;
while (reiterate) {
reiterate = false;
//再次根据BeanDefinitionRegistryPostProcessor获得BeanName
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
//processedBeans.contains(ppName) 这句代码判断当前BeanDefinitionRegistryPostProcessor是否已经执行过
if (!processedBeans.contains(ppName)) {
//如果没有执行过把对象放到临时集合currentRegistryProcessors中，名称添加到processedBeans集合中
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
/**
* 对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序
*/
sortPostProcessors(currentRegistryProcessors, beanFactory);
/**
* 同上进行合并Processors进行后续统一执行BeanDefinitionRegistryPostProcessor父类BeanFactoryPostProcessor()的方法
* 即postProcessBeanFactory()方法
*/
registryProcessors.addAll(currentRegistryProcessors);
/**
* 可以理解为执行BeanDefinitionRegistryPostProcessor其他实现类的postProcessBeanDefinitionRegistry()方法
* 用于进行bean定义的加载 比如我们的包扫描，@import 等等。。。。。。。。。
*/
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
//执行完毕清理postProcessBeanDefinitionRegistry集合
currentRegistryProcessors.clear();
}
//--------------第④步：调用内置其他BeanDefinitionRegistryPostProcessor开始--优先级No4-End--------------/
//--------------第⑤步：调用BeanDefinitionRegistryPostProcessor父类BeanFactoryPostProcessor的方法开始--优先级No5-End--------------/
/**
* registryProcessors集合装载BeanDefinitionRegistryPostProcessor
* 上面的代码是执行BeanDefinitionRegistryPostProcessor类独有的方法
* 这里需要再把父类BeanFactoryPostProcessor的方法也执行一次
* 即：调用 BeanDefinitionRegistryPostProcessor.postProcessBeanFactory方法
*/
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
/**
* 执行自定义BeanFactoryPostProcessor方法
* regularPostProcessors装载BeanFactoryPostProcessor，执行BeanFactoryPostProcessor的方法
* 但是regularPostProcessors一般情况下，是不会有数据的，只有在外面手动添加BeanFactoryPostProcessor，才会有数据
*/
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
//--------------第⑤步：调用内置其他BeanDefinitionRegistryPostProcessor开始--优先级No3-End--------------/
}
else {
/**
* 若当前的beanFactory没有实现了BeanDefinitionRegistry 说明没有注册Bean定义的能力
* 那么就直接调用BeanDefinitionRegistryPostProcessor.postProcessBeanFactory()方法
*/
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
/**========第一步END：至此所有调用BeanDefinitionRegistryPostProcessor的后置处理器执行完毕 End ==========*/
/** ========第二步Begin：调用BeanFactoryPostProcessor的后置处理器 Begin ==========*/
//根据BeanFactoryPostProcessor获得BeanName
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// 定义保存实现了priorityOrdered的BeanFactoryPostProcessor接口集合
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 定义保存实现了Ordered的BeanFactoryPostProcessor接口的BeanName集合
List<String> orderedPostProcessorNames = new ArrayList<>();
//定义保存其他实现了BeanFactoryPostProcessor接口集合
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
//判断的当前BeanFactoryPostProcessor是否已经在上面调用过
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
//如果当前BeanFactoryPostProcessor实现了PriorityOrdered接口则添加到priorityOrderedPostProcessors集合
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
//如果当前BeanFactoryPostProcessor实现了Ordered接口则将BeanName添加到orderedPostProcessorNames集合
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
//否则添加到nonOrderedPostProcessorNames集合中
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
//--------------第①步：调用实现了PriorityOrdered接口的BeanFactoryPostProcessor开始--优先级No1-Begin--------------/
// 排序处理priorityOrderedPostProcessors，即实现了PriorityOrdered接口的BeanFactoryPostProcessor
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
//执行实现了PriorityOrdered接口BeanFactoryPostProcessor.postProcessBeanFactory()方法
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
//--------------第①步：调用实现了PriorityOrdered接口的BeanFactoryPostProcessor开始--优先级No1-End--------------/
//--------------第②步：调用实现了Ordered接口的BeanFactoryPostProcessor开始--优先级No2-Begin--------------/
// 定义保存实现了Ordered的BeanFactoryPostProcessor接口集合
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
/**
* 获取实现了Ordered的BeanFactoryPostProcessor的实例
* 并添加到orderedPostProcessors集合
*/
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
//排序
sortPostProcessors(orderedPostProcessors, beanFactory);
//执行实现了Ordered接口BeanFactoryPostProcessor.postProcessBeanFactory()方法
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
//--------------第②步：调用实现了PriorityOrdered接口的BeanFactoryPostProcessor开始--优先级No2-end--------------/
//--------------第③步：调用其他BeanFactoryPostProcessor开始--优先级No3-Begin--------------/
// 最后，调用所有其他BeanFactoryPostProcessors函数
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
//执行其他所有BeanFactoryPostProcessor.postProcessBeanFactory()方法
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
//--------------第③步：调用其他BeanFactoryPostProcessor开始--优先级No3-end--------------/
// 清除缓存的合并bean定义，因为后处理程序可能修改了原始元数据，例如替换值中的占位符……
beanFactory.clearMetadataCache();
//==============第二步End：至此所有BeanFactoryPostProcessor调用完毕 --End==============
//==============至此所有BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor调用完毕 --End==============
}
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
# 第一步：执行BeanDefinitionRegistryPostProcessor
# 一、准备工作
首先定义了一个
Set<String> processedBeans = new HashSet<>()集合，主要是用来存放已经执行过的后置处理器的beanName，用于后面判断改后置处理器是否被执行过判断我们的
beanFactory是否实现了BeanDefinitionRegistry(实现了该结构就有注册和获取Bean定义的能力）beanFactory是DefaultListableBeanFactory，是BeanDefinitionRegistry的实现类，所以肯定满足if条件；若当前的beanFactory没有实现BeanDefinitionRegistry说明没有注册Bean定义的能力;那么就直接调用BeanDefinitionRegistryPostProcessor.postProcessBeanFactory()方法- 并且强行把我们的bean工厂转为
BeanDefinitionRegistry，因为待会需要注册Bean定义 BeanDefinitionRegistry registry = beanFactory
定义了两个List
一个是
regularPostProcessors，用来装载BeanFactoryPostProcessorList<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>()1一个是
registryProcessors用来装载BeanDefinitionRegistryPostProcessorList<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();1🍇这个集合的意义：
合并Processors，我已经执行了
BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()方法了，为什么要合并？因为
registryProcessors是装载BeanDefinitionRegistryPostProcessor的集合- 一开始的时候只会执行
BeanDefinitionRegistryPostProcessor独有的方法postProcessBeanDefinitionRegistry() - 而不会执行
BeanDefinitionRegistryPostProcessor父类的方法，即BeanFactoryPostProcessor()的方法 - 所以这里需要把处理器放入一个集合中，后续统一执行父类的
postProcessBeanFactory()方法；在下面第六小节：调用BeanDefinitionRegistryPostProcessor父类BeanFactoryPostProcessor中有讲解
- 一开始的时候只会执行
其中BeanDefinitionRegistryPostProcessor扩展了BeanFactoryPostProcessor。BeanDefinitionRegistryPostProcessor有两个方法，一个是独有的postProcessBeanDefinitionRegistry()方法，一个是父类 的postProcessBeanFactory()方法。
# 二、循环我们传递进来的beanFactoryPostProcessors
- 遍历传进来的
beanFactoryPostProcessors，上面已经解释过了，一般情况下，这里永远都是空的，只有手动add beanFactoryPostProcessor，这里才会有数据。我们假设beanFactoryPostProcessors有数据，进入循环，判断postProcessor是不是BeanDefinitionRegistryPostProcessor，因为BeanDefinitionRegistryPostProcessor扩展了BeanFactoryPostProcessor，所以这里先要判断是不是BeanDefinitionRegistryPostProcessor，是的话，执行**postProcessBeanDefinitionRegistry方法，然后把对象装到registryProcessors集合里面去，不是的话，就添加到regularPostProcessors集合等待第二步：执行BeanFactoryPostProcessor**执行BeanFactoryPostProcessor后置处理器时一并调用执行postProcessBeanFactory()方法。
定义了一个集合：currentRegistryProcessors，用来装载BeanDefinitionRegistryPostProcessor，后面多种类型的BeanDefinitionRegistryPostProcessor后置处理器会复用这个集合
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>()
1
# 三、调用内置实现PriorityOrdered接口BeanDefinitionRegistryPostProcessor
getBeanNamesForType，顾名思义，是根据类型查到BeanNames，这里有一点需要注意，是循环beanDefinitionNames去找，这里传了BeanDefinitionRegistryPostProcessor.class，就是找到类型为BeanDefinitionRegistryPostProcessor的后置处理器，并且赋值给postProcessorNames。一般情况下，只会找到一个，就是BeanName为org.springframework.context.annotation.internalConfigurationAnnotationProcessor，也就是ConfigurationAnnotationProcessor。这个后置处理器Bean定义是在上面[第四大节：初始化BeanDefinition读取器](#四、初始化一个BeanDefinition读取器 new AnnotatedBeanDefinitionReader(this)) 中new AnnotatedBeanDefinitionReader(this)定义的❓这里有一个问题，为什么我自己写了个类，实现了
BeanDefinitionRegistryPostProcessor接口，也加上了@Component注解，但是这里没有获得，因为直到这一步，Spring还没有完成扫描，扫描是在ConfigurationClassPostProcessor类中完成的，也就是下面第⑤步中执行的第一个invokeBeanDefinitionRegistryPostProcessors()方法。循环
postProcessorNames，其实也就是org.springframework.context.annotation.internalConfigurationAnnotationProcessor，判断此后置处理器是否实现了PriorityOrdered接口（ConfigurationAnnotationProcessor也实现了PriorityOrdered接口），如果实现了，把它添加到currentRegistryProcessors这个集合中，再放入processedBeans，代表这个后置处理已经被处理过了。当然现在还没有处理，但是马上就要处理了。。。进行排序，PriorityOrdered是一个排序接口，如果实现了它，就说明此后置处理器是有顺序的，所以需要排序。当然目前这里只有一个后置处理器，就是
ConfigurationClassPostProcessor。把
currentRegistryProcessors合并到registryProcessors，为什么需要合并上面已经解释过；🍉 PS：在后续调用
ConfigurationClassPostProcessor.postProcessBeanFactory()的意图主要是为了给配置类生成动态代理类，为何生成代理类？ 因为在配置类中可能会有@Bean修饰的方法，使用cglib对配置类进行代理生成代理类给配置类做增强，为@Bean修饰的方法进行创建Bean的实例，在调用这类方法的时先回去Spring-IOC容器中查找是否有这个Bean，如果有则返回（这个代理类只会在添加了@Configuration修饰的配置类才会产生）,在没有@Configuration修饰的类中的@Bean方法不会去Spring-IOC容器中查找是否存在，会直接执行方法创建一个新的实例开始调用执行BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry()核心方法；可以理解为执行
currentRegistryProcessors中的ConfigurationClassPostProcessor中的postProcessBeanDefinitionRegistry（）方法，这就是Spring设计思想的体现了，在这里体现的就是其中的热插拔，插件化开发的思想。Spring中很多东西都是交给插件去处理的，这个后置处理器就相当于一个插件，如果不想用了，直接不添加就是了。这个方法特别重要，篇幅下会做解析。清空
currentRegistryProcessors集合；至此内置实现PriorityOrdered接口BeanDefinitionRegistryPostProcessor已经处理完毕
# 四、调用内置实现Ordered接口BeanDefinitionRegistryPostProcessor
- 再次根据
BeanDefinitionRegistryPostProcessor获得BeanName，然后进行循环，根据processedBeans集合 判断这个后置处理器是否被执行过了，如果没有被执行过，也实现了Ordered接口的话，把此后置处理器添加到到currentRegistryProcessors和processedBeans中。
执行到这一步就可以获得我们定义的，并且打上@Component注解的后置处理器了，因为Spring已经完成了扫描，但是这里需要注意的是，由于ConfigurationClassPostProcessor在上面已经被执行过了，所以虽然可以通过 getBeanNamesForType获得，但是并不会加入到currentRegistryProcessors和processedBeans因为它已经执行过放入到processedBeans集合中了。
- 后续的步骤与处理实现PriorityOrdered接口BeanDefinitionRegistryPostProcessor大体一致
- 处理排序。
- 合并Processors，合并的理由和上面是一样的。
- 执行我们自定义的BeanDefinitionRegistryPostProcessor。
- 清空
currentRegistryProcessors集合
# 五、调用内置其他BeanDefinitionRegistryPostProcessor
🌈 在上面的方法中，仅仅是执行了实现了Ordered接口的BeanDefinitionRegistryPostProcessor，这里是执行没有实现Ordered接口和PriorityOrdered接口的所有其他BeanDefinitionRegistryPostProcessor。
步骤与上三、四类似，有点区别的是这里根据BeanDefinitionRegistryPostProcessor获得BeanName，然后进行死循环判断当前后置处理器是否在上面执行过，如果没有执行则添加到currentRegistryProcessors和processedBeans中；直到找出所有未执行的BeanDefinitionRegistryPostProcessor,后续依旧是
- 处理排序。
- 合并Processors
- 执行我们自定义的BeanDefinitionRegistryPostProcessor。
- 清空
currentRegistryProcessors集合
# 六、调用BeanDefinitionRegistryPostProcessor父类BeanFactoryPostProcessor（）方法
这一步真正处理上面
registryProcessors集合合并的BeanDefinitionRegistryPostProcessor.BeanFactoryPostProcessor()方法1、registryProcessors集合存放BeanDefinitionRegistryPostProcessor
- 上面的代码是执行
BeanDefinitionRegistryPostProcessor类独有的方法postProcessBeanDefinitionRegistry- 这里需要再把父类BeanFactoryPostProcessor的方法也执行一次；即：调用
BeanDefinitionRegistryPostProcessor.postProcessBeanFactory()方法- ConfigurationClassPostProcess.postProcessBeanFactory方法主要是对@Configuration做代理增强
2、执行自定义BeanFactoryPostProcessor方法
- regularPostProcessors装载BeanFactoryPostProcessor，执行
BeanFactoryPostProcessor.postProcessBeanFactory()的方法- 但是regularPostProcessors一般情况下，是不会有数据的，只有在外面手动添加BeanFactoryPostProcessor，才会有数据
在完成上述六个步骤之后至此所有调用BeanDefinitionRegistryPostProcessor的后置处理器执行完毕
# 第二步：执行BeanFactoryPostProcessor
🍓上面最后一步执行了自定义的BeanFactoryPostProcessor方法
根据
BeanFactoryPostProcessor获得BeanName数组postProcessorNames定义了三个集合
// 定义保存实现了priorityOrdered的BeanFactoryPostProcessor实例集合 List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>(); // 定义保存实现了Ordered的BeanFactoryPostProcessor接口的BeanName集合 List<String> orderedPostProcessorNames = new ArrayList<>(); //定义保存其他实现了BeanFactoryPostProcessor实例集合 List<String> nonOrderedPostProcessorNames = new ArrayList<>();1
2
3
4
5
6
7
8遍历
postProcessorNames数组，根据processedBeans集合 判断这个后置处理器是否被执行过了，如果执行过不做任何处理，如果没有被执行过：- 实现了
PriorityOrdered接口的话，把此后置处理器添加到到priorityOrderedPostProcessors集合中。 - 实现了
Ordered接口的话，把此后置处理器名称添加到到orderedPostProcessorNames集合中。 - 否则就添加到
nonOrderedPostProcessorNames集合中
- 实现了
调用实现了
PriorityOrdered接口的BeanFactoryPostProcessor- 处理排序。
- 调用
BeanFactoryPostProcessor.postProcessBeanFactory()方法
调用实现了
Ordered接口的BeanFactoryPostProcessor定义保存实现了
Ordered的BeanFactoryPostProcessor实例集合List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());1getBean()获取BeanFactoryPostProcessor实例对象
处理排序
调用
BeanFactoryPostProcessor.postProcessBeanFactory()方法
调用其他
BeanFactoryPostProcessor- 调用
BeanFactoryPostProcessor.postProcessBeanFactory()方法
- 调用
清除缓存的合并bean定义，因为后处理程序可能修改了原始元数据，例如替换值中的占位符
上次更新: 2022/10/22, 18:16:01