如果你正打算深入学习Spring,但是不知从何学起,那么我强烈推荐你可以按照这个系列做一遍。本系列将Spring框架的各个部分从它庞杂的代码体系中抽取出来,然后对每一个部分进行讲解,并最终搭建成简易版Spring。我以人格保证:如果你可以坚持做下来,那么你对Spring这块的知识就基本都掌握清楚了! 附上该系列地址:https://blog.csdn.net/zhang_qing_yun/article/details/120084497
这里以注解版启动AnnotationConfigApplicationContext为例
一句话总结
Spring的启动主要包括初始化和refresh()两个步骤!
初始化
源码
// 初始化容器
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
// 注册 Spring 内置后置处理器的 BeanDefinition 到容器
this();
// 注册配置类 BeanDefinition 到容器
register(annotatedClasses);
// 加载或者刷新容器中的Bean
refresh();
}
public AnnotationConfigApplicationContext() {
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
- AnnotatedBeanDefinitionReader的创建请移步到这篇文章:https://blog.csdn.net/yu_kang/article/details/88068619
- ClassPathBeanDefinitionScanner的创建请移步到这篇文章:https://blog.csdn.net/yu_kang/article/details/88075447
流程总结
- 调用父类构造器,创建了DefaultListableBeanFactory。
- 调用自己的this()方法,创建了两个对象AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner:
- AnnotatedBeanDefinitionReader是注解配置读取器。在进行该对象创建时,会向容器中添加6个BeanDefinition,其中有两个比较重要:ConfigurationClassPostProcessor(一个BeanFactoryPostProcessor,用于将配置类中的Bean的BeanDefinition注册到容器中,同时@Import、@ComponentScan等注解也是在这里做的处理)、AutowiredAnnotationBeanPostProcessor(一个BeanPostProcessor,用于处理@Autowired的自动注入,例如当creatBean时调用构造器通过反射实例化对象时,如果使用了@Autowired就会进行自动注入)。
- ClassPathBeanDefinitionScanner是路径扫描器,用于对指定的包目录进行扫描查找 bean 对象,然后为其创建BeanDefinition对象并进行注册。在创建这个对象时,会创建默认的过滤器(如:添加了注解类型的过滤器AnnotationTypeFilter(Component.class)),使得在进行包扫描的时候将指定条件的类的BeanDefinition添加到容器中,而对其它的类不这么干。
- 调用AnnotatedBeanDefinitionReader的register方法将用户传入的 Spring 配置类解析成一个 BeanDefinition 然后注册到容器中。
refresh函数
源码
AbstractApplicationContext#refresh:
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 1. 刷新前的预处理
prepareRefresh();
// 2. 获取 beanFactory,即前面创建的【DefaultListableBeanFactory】
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 3. 预处理 beanFactory,向容器中添加一些组件
prepareBeanFactory(beanFactory);
try {
// 4. 子类通过重写这个方法可以在 BeanFactory 创建并与准备完成以后做进一步的设置
postProcessBeanFactory(beanFactory);
// 5. 执行 BeanFactoryPostProcessor 方法,beanFactory 后置处理器
invokeBeanFactoryPostProcessors(beanFactory);
// 6. 注册 BeanPostProcessors,bean 后置处理器
registerBeanPostProcessors(beanFactory);
// 7. 初始化 MessageSource 组件(做国际化功能;消息绑定,消息解析)
initMessageSource();
// 8. 初始化事件派发器,在注册监听器时会用到
initApplicationEventMulticaster();
// 9. 留给子容器(子类),子类重写这个方法,在容器刷新的时候可以自定义逻辑,web 场景下会使用
onRefresh();
// 10. 注册监听器,派发之前步骤产生的一些事件(可能没有)
registerListeners();
// 11. 初始化所有的非单实例 bean
finishBeanFactoryInitialization(beanFactory);
// 12. 发布容器刷新完成事件
finishRefresh();
}
...
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
流程总结
refresh()主要用于容器的刷新,Spring 中的每一个容器都会调用 refresh() 方法进行刷新,完成初始化,包括父子容器。refresh()函数主要有13个步骤:
prepareRefresh
刷新前的准备工作,设置了容器的启动时间,将容器的标识符设置为启动状态active等工作。
obtainFreshBeanFactory
刷新BeanFactory,并为容器设置了序列化ID;然后返回初始化过程中创建的DefaultListableBeanFactory对象。
(注意:如果是XML版本,则DefaultListableBeanFactory、XmlBeanDefinitionReader并不是在初始化过程中创建的,而是在这里创建的,初始化过程中只是设置了一下配置文件的路径。然后会在这里去解析XML配置文件,将里面的Bean信息转换成BeanDefinition添加到容器中,然后返回创建的DefaultListableBeanFactory。)
prepareBeanFactory
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// Tell the internal bean factory to use the context's class loader etc.
/**
* 设置上下文类加载器
*/
beanFactory.setBeanClassLoader(getClassLoader());
/**
* 添加bean表达式解释器,为了能够让我们的beanFactory去解析bean表达式
* 模板默认以前缀“#{”开头,以后缀“}”结尾
* 可以修改默认额前缀后缀
* 通过beanFactory.getBeanExpressionResolver()获得BeanExpressionResolver
* 然后resolver.setExpressionPrefix("%{");resolver.setExpressionSuffix("}");
*
* 那么什么时候用到这个解析器?
* 就是在Bean进行初始化后会有属性填充的一步,方法如下:
* protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
* //属性填充
* applyPropertyValues(beanName, mbd, bw, pvs);
* }
* 最终会通过AbstractBeanFactory中的evaluateBeanDefinitionString方法进行解析
* 然后这时候就进到StandardBeanExpressionResolver中的evaluate方法中进行解析了
*/
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
/**
* spring内部的属性编辑器
* 添加PropertyEditor属性编辑器(可以将我们的property动态设置为bean里面对应的属性类型)
* 比如:property赋值的是路径名(classpath/spring.xml),而对应bean属性设置的是Resource,则有spring的ResourceEditor完成转换
* springframework-bean下的propertyEditors包下有很多spring自带的属性编辑器
* 其中刚才提到的ResourceEditor在springframework-core下的io包里面
*
* 可以自定义属性编辑器,通过实现PropertyEditorSupport接口,spring中自带的属性编辑器也是这么做的
* 使用ApplicationContext,只需要在配置文件中通过CustomEditorConfigurer注册即可。
* CustomEditorConfigurer实现了BeanFactoryPostProcessor接口,因而是一个Bean工厂后置处理器
* 在Spring容器中加载配置文件并生成BeanDefinition后会被执行。CustomEditorConfigurer在容器启动时有机会注册自定义的属性编辑器
*/
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
/**
* 添加一个BPP
* ApplicationContextAwareProcessor:能够在bean中获得各种*Aware
*/
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
/**
* 跳过以下6个属性的自动注入
* 因为在ApplicationContextAwareProcessor中已经完成了手动注入
*/
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// BeanFactory interface not registered as resolvable type in a plain factory.
// MessageSource registered (and found for autowiring) as a bean.
/**
* 注册几个自动装配相关的类和实例
* 在应用代码就可以通过类型自动装配把工厂实例和ApplicationContext实例设置到自定义bean的属性中
*
* 例如:这几个属性都会被自动设置,虽然没有在显示的在bean定义xml中注入它们
* private BeanFactory beanFactory;
* private ResourceLoader resourceLoader;
* private ApplicationEventPublisher appEventPublisher;
* private ApplicationContext appContext;
*/
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// Register early post-processor for detecting inner beans as ApplicationListeners.
/**
* 添加一个BPP,处理时间监听器
*/
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found.
/**
* 当容器检查到定义了名称为loadTimeWeaver的bean时
* 会注册一个LoadTimeWeaverAwareProcessor到容器中
*
* 这个BPP用来处理LoadTimeWeaverAware接口的
* 把LTW实例设置到实现了LoadTimeWeaverAware接口的bean中
*/
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// Register default environment beans.
/**
* 就是一些系统配置和系统环境信息
* 如果发现没有这些bean则spring自己注册
*/
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
向BeanFactory中设置一些内容,比如说设置了类加载器、默认以"#{“开头以”}"结尾的表达式解析器等内容。然后还向容器中注册了一个ApplicationContextAwareProcessor,它是一个BeanPostProcessor,作用就是如果该Bean实现了ApplicationContextAware等6个Aware类型接口中的一个,就向该Bean注入对应的内容。所以,该函数接下来就设置了忽略这6种类型的自动注入,因为它们会通过ApplicationContextAwareProcessor进行注入。然后注册了几个可以解析的自动装配类(BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext),即这几个类虽然没有显式的定义,但是它们可以在任意组件中通过注解自动完成注入。然后向容器中添加了一个ApplicationListenerDetector,这是一个BeanPostProcessor(重写了初始化后的后置处理器),作用就是当一个Bean初始化完了以后进行判断,如果它是一个监听器就把它注册起来。最后,如果Spring发现一些必要的系统配置和系统环境信息并没有配置,就会自己创建这些Bean并注册。
postProcessBeanFactory
空方法,留待子类去实现,作用是在BeanFactory准备工作完成后做一些定制化的处理。
invokeBeanFactoryPostProcessors
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// beanFactoryPostProcessors 这个参数是指用户通过 AnnotationConfigApplicationContext.addBeanFactoryPostProcessor() 方法手动传入的 BeanFactoryPostProcessor,没有交给 spring 管理
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
// 代表执行过的 BeanDefinitionRegistryPostProcessor
Set<String> processedBeans = new HashSet<>();
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 常规后置处理器集合,即实现了 BeanFactoryPostProcessor 接口
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
// 注册后置处理器集合,即实现了 BeanDefinitionRegistryPostProcessor 接口
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
// 处理自定义的 beanFactoryPostProcessors(指调用 context.addBeanFactoryPostProcessor() 方法),一般这里都没有
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
// 调用 postProcessBeanDefinitionRegistry 方法
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// Separate between BeanDefinitionRegistryPostProcessors that implement
// PriorityOrdered, Ordered, and the rest.
// 定义一个变量 currentRegistryProcessors,表示当前要处理的 BeanFactoryPostProcessors
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
// 首先,从容器中查找实现了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor 类型,这里只会查找出一个【ConfigurationClassPostProcessor】
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 判断是否实现了 PriorityOrdered 接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 添加到 currentRegistryProcessors
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 添加到 processedBeans,表示已经处理过这个类了
processedBeans.add(ppName);
}
}
// 设置排列顺序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 添加到 registry 中
registryProcessors.addAll(currentRegistryProcessors);
// 执行 [postProcessBeanDefinitionRegistry] 回调方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 将 currentRegistryProcessors 变量清空,下面会继续用到
currentRegistryProcessors.clear();
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
// 接下来,从容器中查找实现了 Ordered 接口的 BeanDefinitionRegistryPostProcessors 类型,这里可能会查找出多个
// 因为【ConfigurationClassPostProcessor】已经完成了 postProcessBeanDefinitionRegistry() 方法,已经向容器中完成扫描工作,所以容器会有很多个组件
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 判断 processedBeans 是否处理过这个类,且是否实现 Ordered 接口
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
// 设置排列顺序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 添加到 registry 中
registryProcessors.addAll(currentRegistryProcessors);
// 执行 [postProcessBeanDefinitionRegistry] 回调方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 将 currentRegistryProcessors 变量清空,下面会继续用到
currentRegistryProcessors.clear();
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
// 最后,从容器中查找剩余所有常规的 BeanDefinitionRegistryPostProcessors 类型
boolean reiterate = true;
while (reiterate) {
reiterate = false;
// 根据类型从容器中查找
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
// 判断 processedBeans 是否处理过这个类
if (!processedBeans.contains(ppName)) {
// 添加到 currentRegistryProcessors
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 添加到 processedBeans,表示已经处理过这个类了
processedBeans.add(ppName);
// 将标识设置为 true,继续循环查找,可能随时因为防止下面调用了 invokeBeanDefinitionRegistryPostProcessors() 方法引入新的后置处理器
reiterate = true;
}
}
// 设置排列顺序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 添加到 registry 中
registryProcessors.addAll(currentRegistryProcessors);
// 执行 [postProcessBeanDefinitionRegistry] 回调方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 将 currentRegistryProcessors 变量清空,因为下一次循环可能会用到
currentRegistryProcessors.clear();
}
// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
// 现在执行 registryProcessors 的 [postProcessBeanFactory] 回调方法
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
// 执行 regularPostProcessors 的 [postProcessBeanFactory] 回调方法,也包含用户手动调用 addBeanFactoryPostProcessor() 方法添加的 BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// 从容器中查找实现了 BeanFactoryPostProcessor 接口的类
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 表示实现了 PriorityOrdered 接口的 BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 表示实现了 Ordered 接口的 BeanFactoryPostProcessor
List<String> orderedPostProcessorNames = new ArrayList<>();
// 表示剩下来的常规的 BeanFactoryPostProcessors
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
// 判断是否已经处理过,因为 postProcessorNames 其实包含了上面步骤处理过的 BeanDefinitionRegistry 类型
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
// 判断是否实现了 PriorityOrdered 接口
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
// 判断是否实现了 Ordered 接口
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
// 剩下所有常规的
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
// 先将 priorityOrderedPostProcessors 集合排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 执行 priorityOrderedPostProcessors 的 [postProcessBeanFactory] 回调方法
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
// 接下来,把 orderedPostProcessorNames 转成 orderedPostProcessors 集合
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 将 orderedPostProcessors 集合排序
sortPostProcessors(orderedPostProcessors, beanFactory);
// 执行 orderedPostProcessors 的 [postProcessBeanFactory] 回调方法
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
// 最后把 nonOrderedPostProcessorNames 转成 nonOrderedPostProcessors 集合,这里只有一个,myBeanFactoryPostProcessor
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 执行 nonOrderedPostProcessors 的 [postProcessBeanFactory] 回调方法
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
// 清除缓存
beanFactory.clearMetadataCache();
}
在BeanFactory标准初始化之后执行每个BeanFactoryPostProcessor实现类的postProcessBeanFactory,但是存在执行顺序上的问题。先执行实现了BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法:自定义 > 实现了PriorityOrdered接口 > 实现了Ordered接口 > 剩余所有常规的BeanDefinitionRegistryPostProcessor。然后执行BeanFactoryPostProcessor接口的postProcessBeanFactory方法:上述实现了BeanDefinitionRegistryPostProcessor的对象按照上述顺序执行它们的postProcessBeanFactory方法,然后处理自定义BeanFactoryPostProcessor,然后是实现了PriorityOrdered接口 的,然后是实现了Ordered接口的,最后是剩下所有的普通的BeanFactoryPostProcessor。值得注意的是ConfigurationClassPostProcessor就是在这里执行的,它会去处理我们指定的配置类对应的BeanDefinition(在初始化阶段解析并向容器注入的),它会去处理配置类中的@Bean、@Import、@ComponentScan、@PropertySource等注解,将我们通过注解配置的Bean解析成BeanDefinition并注册到容器中。(值得注意的是,如果配置了PropertyPlaceholderConfigurer,则就是在此处发挥作用的,将属性值中的占位符替换为配置文件中的真正的属性值)
具体的执行顺序如下图:
registerBeanPostProcessors
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 从容器中获取 BeanPostProcessor 类型
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
// 向容器中添加【BeanPostProcessorChecker】,主要是用来检查是不是有 bean 已经初始化完成了,
// 如果没有执行所有的 beanPostProcessor(用数量来判断),如果有就会打印一行 info 日志
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 存放实现了 PriorityOrdered 接口的 BeanPostProcessor
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 存放 MergedBeanDefinitionPostProcessor 类型的 BeanPostProcessor
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
// 存放实现了 Ordered 接口的 BeanPostProcessor 的 name
List<String> orderedPostProcessorNames = new ArrayList<>();
// 存放剩下来普通的 BeanPostProcessor 的 name
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 从 beanFactory 中查找 postProcessorNames 里的 bean,然后放到对应的集合中
for (String ppName : postProcessorNames) {
// 判断有无实现 PriorityOrdered 接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
// 如果实现了 PriorityOrdered 接口,且属于 MergedBeanDefinitionPostProcessor
if (pp instanceof MergedBeanDefinitionPostProcessor) {
// 把 MergedBeanDefinitionPostProcessor 类型的添加到 internalPostProcessors 集合中
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
// 给 priorityOrderedPostProcessors 排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 先注册实现了 PriorityOrdered 接口的 beanPostProcessor
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
// 从 beanFactory 中查找 orderedPostProcessorNames 里的 bean,然后放到对应的集合中
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 给 orderedPostProcessors 排序
sortPostProcessors(orderedPostProcessors, beanFactory);
// 再注册实现了 Ordered 接口的 beanPostProcessor
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 再注册常规的 beanPostProcessor
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
// 排序 MergedBeanDefinitionPostProcessor 这种类型的 beanPostProcessor
sortPostProcessors(internalPostProcessors, beanFactory);
// 最后注册 MergedBeanDefinitionPostProcessor 类型的 beanPostProcessor
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
// 给容器中添加【ApplicationListenerDetector】 beanPostProcessor,判断是不是监听器,如果是就把 bean 放到容器中保存起来
// 此时容器中默认会有 6 个内置的 beanPostProcessor
// 0 = {ApplicationContextAwareProcessor@1632}
// 1 = {ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor@1633}
// 2 = {PostProcessorRegistrationDelegate$BeanPostProcessorChecker@1634}
// 3 = {CommonAnnotationBeanPostProcessor@1635}
// 4 = {AutowiredAnnotationBeanPostProcessor@1636}
// 5 = {ApplicationListenerDetector@1637}
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
这一步是向容器中注册BeanPostProcessor(会通过其BeanDefinition创建出Bean,然后让beanFactory统一进行管理),BeanPostProcessor会干预 Spring 初始化 bean 的流程,从而完成代理、自动注入等各种功能。同样也存在顺序上的问题:先注册实现了PriorityOrdered接口的BeanPostProcessor,然后是实现了Ordered接口的,然后是剩下所有的普通的BeanPostProcessor,最后还会将实现了MergedBeanDefinitionPostProcessor接口的BeanPostProcessor再注册一遍。
initMessageSource
初始化 MessageSource 组件,做国际化的处理。
initApplicationEventMulticaster
初始化事件广播器,如果用户配置了就用自定义的,如果没有就创建一个SimpleApplicationEventMulticaster。事件广播器管理了所有的事件监听器,当发布一个事件的时候,需要通过事件广播器来广播事件,即遍历所有的监听器,然后找到监听该事件的监听器(监听器需要提前注册在容器中),然后调用它们的回调函数。
onRefresh
空方法,留给子类去实现,在容器刷新的时候可以自定义逻辑,web 场景下会使用。
registerListeners
将容器中所有的ApplicationListener都注册到容器中,由容器统一管理。
然后通过事件广播器发布之前步骤产生的事件ApplicationEvent。
finishBeanFactoryInitialization
首先如果之前没有注册类似于PropertyPlaceholderConfigurer这样的解析Bean属性值的组件时,会向容器中添加默认的属性值解析器,具体的作用就是用于解析注解属性值,比如说我们通过@Value("#{jdbc.address}")注解为属性注入值,然后(在自动注入步骤处)该处理器就会将其解析为配置文件中的值,完成注入。
初始化剩下所有的非懒加载的单例Bean对象,具体来说就是遍历所有的beanName,然后调用getBean(beanName)方法来创建Bean对象。值得注意的是,如果该Bean是FactoryBean类型,会调用两次getBean方法,第一次是将其当作普通Bean来创建,第二次是将其当作工厂,通过它来创建对象。
getBean的流程请参考这篇文章:https://blog.csdn.net/zhang_qing_yun/article/details/120083309
finishRefresh
首先初始化生命周期处理器,如果用户没有配置则提供一个默认的DefaultLifecycleProcessor。然后发布容器刷新完毕的事件。
resetCommonCaches
清空启动过程中产生的一些缓存,例如:反射相关的信息、注解相关的信息、类加载器相关的信息等,因为不再需要单例Bean的元数据了。