1.后置处理器是什么?

后置处理器就像组件,Spring很多事情就是交给组件去管理,使用就添加,不使用就不添加,非常符合开闭原则。
以GenericApplicationContext为例:

public static void main(String[] args) {
        GenericApplicationContext context=new GenericApplicationContext();
        context.registerBean("myConfig1",MyConfig1.class);//配置类
        context.registerBean(ConfigurationClassPostProcessor.class);//让Configuration注解生效的后置处理器
        context.registerBean(AutowiredAnnotationBeanPostProcessor.class);//让autowried生效的后置处理器
        context.registerBean(CommonAnnotationBeanPostProcessor.class);//让psotConstruct生效的后置处理器

        context.refresh();
        context.close();
        
          //如果是AnnotationConfigApplicationContext容器,不用手动添加配置类和执行refresh方法
//        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);
//        context.close();        
    }

2.后置处理器分类

一、BeanFactory后置处理器

  1. ConfigurationClassPostProcessor
    扫描到@ComponentScan @Bean @Impoer @ImportResource并让其生效

二、Bean后置处理器

  1. AutowiredAnnotationBeanPostProcessor:处理被@Autowired注解修饰的bean并注入
  2. RequiredAnnotationBeanPostProcessor:处理被@Required注解修饰的方法
  3. CommonAnnotationBeanPostProcessor:处理@PreDestroy、@PostConstruct、@Resource等多个注解的作用

三、spring内置后置处理器

以上两种都是扩展功能,spring内部有自带的两个接口,这两个接口属于内置功能。扩展功能可能会失效,内置功能一定会执行。

  1. Aware接口:实现类可以注入bean的名字、注入BeanFactory 容器、注入 ApplicationContext 容器、注入${}解析器
  2. InitializingBean接口:提供了一种内置的初始化手段

3.后置处理器的执行时机

  1. BeanFactory后置处理器:BeanFactory初始化之后,所有beanDefinition(其他工具类和后置处理器们)已经加载到beanFactory,但是实例未创建的时候
  2. Bean后置处理器:Bean整个生命周期各阶段(实例化-依赖注入-初始化-销毁),有不同的处理器生效
  3. Spring内置后置处理器:在Bean后置处理器执行结束后执行

spring 前置 后置处理器 spring的后置处理器_spring 前置 后置处理器

refresh()之前:只是实例化了一个工厂,注册了一些内置的Bean和我们传进去的配置类。

refresh()内的逻辑如下:

  1. prepareRefresh:刷新前的准备工作,主要是保存了容器的启动时间,启动标志等
  2. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory():把beanFactory取出来而已。XML模式下会在这里读取BeanDefinition
  3. prepareBeanFactory:添加BeanFactory后置处理器、设置了忽略自动装配、指定自动装配对象的接口,设置了bean表达式解析器(${}),把环境变量注册成Singleton的Bean定义到工厂,然后调用
    AbstractAutowireCapableBeanFactory的createBean方法实例化这些bean
  4. postProcessBeanFactory:空方法,可能以后Spring会进行扩展
  5. invokeBeanFactoryPostProcessors(beanFactory):执行已有的BeanFactory后置处理器,先执行排序的,最后执行没有排序的,先执行非Registry的后置处理器,后执行Registry的添加额外的bean定义的方法,Registry后置处理器也先执行排序的
  6. registerBeanPostProcessors(beanFactory):实例化和注册Bean后置处理器
  7. initMessageSource():初始化国际化资源处理器,通过读取特定配置文件,能实现不同语言的切换
  8. initApplicationEventMulticaster():创建事件多播器,发出一个事件,任何一个配置类都可以作为监听器
  9. onRefresh():模板方法,在容器刷新的时候可以自定义逻辑,不同的Spring容器做不同的事情
  10. registerListeners():注册监听器,带有@EventListener注解的配置类可以监听到播放的事件
  11. finishBeanFactoryInitialization(beanFactory):实例化所有剩余的(非懒加载)单例,实例化的过程各种BeanPostProcessor开始起作用
  12. finishRefresh():清除上下文资源缓存、初始化上下文的生命周期处理器,并刷新、发布ContextRefreshedEvent事件告知对应的ApplicationListener进行响应的操作

补充

配置类:

//MainConfig.class是配置类
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);

①带上@Configuration注解的类,称为Full配置类,该类会被cgilb代理
②带有@Component,@Service 等注解的类,称为Lite配置类

Spring Bean的生命周期

  1. 实例化Bean对象,这个时候Bean的对象是非常低级的,基本不能够被我们使用,因为连最基本的属性都没有设置,可以理解为连Autowired注解都是没有解析的;
  2. 填充属性,当做完这一步,Bean对象基本是完整的了,可以理解为Autowired注解已经解析完毕,依赖注入完成了;
  3. 如果Bean实现了BeanNameAware接口,则调用setBeanName方法;
  4. 如果Bean实现了BeanClassLoaderAware接口,则调用setBeanClassLoader方法;
  5. 如果Bean实现了BeanFactoryAware接口,则调用setBeanFactory方法;
  6. 调用BeanPostProcessor的postProcessBeforeInitialization方法;
  7. 如果Bean实现了InitializingBean接口,调用afterPropertiesSet方法;
  8. 如果Bean定义了init-method方法,则调用Bean的init-method方法;
  9. 调用BeanPostProcessor的postProcessAfterInitialization方法;当进行到这一步,Bean已经被准备就绪了,一直停留在应用的上下文中,直到被销毁;
  10. 如果应用的上下文被销毁了,如果Bean实现了DisposableBean接口,则调用destroy方法,如果Bean定义了destory-method声明了销毁方法也会被调用。

什么时候进行依赖注入

  1. 设置了懒加载,在调用getBean()时触发依赖注入
  2. 没有设置懒加载,在容器解析BeanDefiniton时触发依赖注入