Spring 后置处理器源码

在《几种自定义Spring生命周期的初始化和销毁方法》最后一段描述了启动 Spring 容器过程中,初始化和销毁方法的执行时机,那么在 Spring 中是如何做到的呢?

注册主配置类

Spring 使用AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Main.class);指定主配置类,将其注册到 BeanFactory。除了主配置类,还会将一些基础的后置处理器类注册到 BeanFactory,如下所示:

  1. 初始化AnnotatedBeanDefinitionReader,内部后置处理器注册到BeanFactory

    • internalConfigurationAnnotationProcessor->ConfigurationClassPostProcessor
    • internalAutowiredAnnotationProcessor->AutowiredAnnotationBeanPostProcessor
    • internalCommonAnnotationProcessor->CommonAnnotationBeanPostProcessor
    • internalPersistenceAnnotationProcessor->PersistenceAnnotationBeanPostProcessor
    • internalEventListenerProcessor->EventListenerMethodProcessor
    • internalEventListenerFactory->DefaultEventListenerFactory
  2. 初始化ClassPathBeanDefinitionScanner,加载环境和资源配置

    • Environment
    • ResourceLoader

注册基础BeanFactory

refresh()

Spring 中非常核心的源码 AbstractApplicationContext.refresh(),顾名思义,这是用来更新 Spring 应用上下文的方法,对 Spring 容器进行初始化、更新等操作。

// 部分源码
public void refresh() {
    // 取出注册的 BeanFactory
    ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    // 配置 BeanFactory
    prepareBeanFactory(beanFactory);
    // 初始化执行 BeanFactory 后置处理器
    invokeBeanFactoryPostProcessors(beanFactory);
    // 注册 Bean 后置处理器
    registerBeanPostProcessors(beanFactory);
    // 执行 Bean 后置处理器
    finishBeanFactoryInitialization(beanFactory);
}

1、初始化执行 BeanFactory 后置处理器

整体顺序


首先会按照顺序执行 BeanDefinitionRegistryPostProcessor 的实现类

  1. 执行实现了 PriorityOrdered 的 BeanDefinitionRegistryPostProcessor。
  2. 执行实现了 Ordered 的 BeanDefinitionRegistryPostProcessor。
  3. 执行所有剩下的 BeanDefinitionRegistryPostProcessor。

上面的每一步都会先在容器中==初始化 Bean==,然后去执行 BeanDefinitionRegistryPostProcessor 的 postProcessBeanDefinitionRegistry() 方法。因为 BeanDefinitionRegistryPostProcessor 继承了 BeanFactoryPostProcessor,所以也会执行 postProcessBeanFactory() 方法。


然后按顺序执行 BeanFactoryPostProcessor 的实现类

  1. 执行实现了 PriorityOrdered 的 BeanFactoryPostProcessor。
  2. 执行实现了 Ordered 的 BeanFactoryPostProcessor。
  3. 执行所有剩下的 BeanFactoryPostProcessor。

上面的每一步都会先在容器中==初始化 Bean==,然后去执行 BeanFactoryPostProcessor 的 postProcessBeanFactory() 方法。


执行细节

以 ConfigurationClassPostProcessor 为例,这个类是 BeanDefinitionRegistryPostProcessor 的实现类,是 @Configuration 注解配置类的启动引导类,在注册主配置类时,已经注册到 BeanFactory,此外,此类还实现了 PriorityOrdered,从执行顺序可知,它会被优先执行。

1、ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry()

  1. 首先会找到主配置类,即标注 @Configuration 的类。
  2. 创建配置类解析器 ConfigurationClassParser ,以主配置类为入口,其方法 doProcessConfigurationClass() 会根据主配置类上标注的注解,按照下面的顺序依次找到所有的 Spring 组件。
    • @PropertySource 将配置数据加载到缓存
    • @ComponentScan 扫描类路径下的所有类,过滤出 @Component 注解类
    • @Import 加载 @Import 导入的类。如果该类是 ImportSelector,则会去执行其方法 selectImports();如果是 ImportBeanDefinitionRegistrar,则只是将其加入缓存,还不会执行他的方法;否则,直接当作 @Configuration 注解类处理。
    • @ImportResource
    • @Bean 加载 @Bean 标注的方法。
    • 接口默认方法
    • 父类
  3. ConfigurationClassBeanDefinitionReader 遍历找到的所有组件,并将 @Import 导入的类注册到 BeanFactory。此时,会执行 ImportBeanDefinitionRegistrar.registerBeanDefinitions() 方法

2、ConfigurationClassPostProcessor.postProcessBeanFactory()

  1. 执行 BeanDefinitionRegistryPostProcessor 实现类的 postProcessBeanFactory(),利用CGLib增强配置类
  2. 注册后置处理器 ImportAwareBeanPostProcessor

3、ImportAwareBeanPostProcessor.postProcessBeanFactory()

  1. 回调ImportAware.setImportMetadata()

执行剩下的 BeanFactoryPostProcessor 实现类的 postProcessBeanFactory()


至此,BeanFactoryPostProcessor 和 BeanDefinitionRegistryPostProcessor 都已经执行完了, 但是一部分自定义的 Bean 还没开始初始化,需要执行 Bean 后置处理器。

invokeBeanFactoryPostProcessors

2、执行 Bean 后置处理器

这个方法会将所有单例、非懒加载对象进行实例化。

主要流程:

  1. ==初始化 Bean==
  2. 回调SmartInitializingSingleton.afterSingletonsInstantiated()

至此,容器中的 Bean 都已经创建好了,再来看下上面标黄的==初始化 Bean==的流程,《几种自定义Spring生命周期的初始化和销毁方法》中描述的一些过程都是在这个里面执行的。

finishBeanFactoryInitialization

3、==初始化 Bean==

AbstractBeanFactory 是 BeanFactory 的抽象实现类,创建 Bean 的入口是 doGetBean()。首先,它会检查缓存中是否存在该 Bean,如果存在,则直接获取,并返回;如果缓存中不存在,再看是创建 Bean 的流程。

AbstractAutowireCapableBeanFactory 实现了 AbstractBeanFactory 创建 Bean 的方法 createBean(),Spring 会调用它的方法 doCreateBean() 来创建 Bean 实例。

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {

    // 1.反射执行构造器方法
    BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
    
    // 属性赋值
    populateBean(beanName, mbd, instanceWrapper);
    // 初始化 Bean
    exposedObject = initializeBean(beanName, exposedObject, mbd);->4.afterPropertiesSet->5.invokeCustomInitMethod

    return exposedObject;
}

上述源码中 initializeBean() 方法中会顺序执行

  • BeanPostProcessor.postProcessBeforeInitialization()
  • @PostConstruct
  • InitializingBean.afterPropertiesSet()
  • initMethod()
  • BeanPostProcessor.postProcessAfterInitialization()

主要源码和注释如下

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
    // 执行 Aware 接口实现方法
    invokeAwareMethods(beanName, bean);

    // 2.执行 BeanPostProcessor.postProcessBeforeInitialization()
    // 3.上面的方法内部实际上回去执行 @PostConstruct 注解的方法
    applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

    // 4.执行 InitializingBean.afterPropertiesSet()
    // 5.然后执行自定义的 initMethod() 方法
    invokeInitMethods(beanName, wrappedBean, mbd);
    
    // 6.执行 BeanPostProcessor.postProcessAfterInitialization()
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

    return wrappedBean;
}

注意,initializeBean() 方法中的 invokeAwareMethods() 会去执行部分 Aware 接口实现类的方法,见Spring Aware源码

初始化 Bean


总结

  • Spring 启动时,首先会将主配置类和基础的后置处理器类注册到 BeanFactory
  • 调用 refresh() 方法,将上述 BeanFactory 中的后置处理器取出,并执行后置处理器的实现方法,扫描所有可用的 Bean 注册到 BeanFactory
  • 将 BeanFactory 中所有可用的 Bean 进行最终的初始化工作
posted @ 2019-08-06 01:30  O'Neal  阅读(...)  评论(...编辑  收藏