[关闭]
@survivorZzz 2019-07-05T01:08:10.000000Z 字数 20278 阅读 807

Spring 容器中的Bean

Spring

单例和多例

Spring 容器中 Bean的单例和多例大家应该都知道, 默认的, 注册到容器中的Bean是单例的,每一次从容器中获取这个Bean实例, 内存地址都是同一个 举证(亲测):

代码块1:
有这样一个类:

  1. public class MyClass implements InitializingBean, DisposableBean, BeanNameAware {
  2.     private String beanName;
  4.     public String getBeanName() {
  5.         return beanName;
  6.     }
  8.     static {
  9.         System.err.println(">>>>>>>>> static block");
  10.     }
  11.     {
  12.         System.err.println(">>>>>>>>> non-static block");
  13.     }
  14.     @Override
  15.     public void afterPropertiesSet() throws Exception {
  16.         System.err.println(">>>>>>>>> afterPropertiesSet method!");
  17.     }
  19.     @PostConstruct
  20.     void method() {
  21.         System.err.println(">>>>>>>>> postConstruct method!");
  22.     }
  24.     @PreDestroy
  25.     void preDestroy() {
  26.         System.err.println(">>>>>>>>> preDestroy method!");
  27.     }
  29.     public void init() {
  30.         System.err.println(">>>>>>>>> init method!");
  31.     }
  33.     public void destroyMethod() {
  34.         System.err.println(">>>>>>>>> destroyMethod method!");
  35.     } 
  37.     @Override
  38.     public void destroy() {
  39.         System.err.println(">>>>>>>>> override destroy method!");
  40.     }
  42.     @Override
  43.     public void setBeanName(String s) {
  44.         this.beanName = s;
  45.     }
  46. }

代码块2:

  1. @SpringBootApplication
  2. //@ImportResource("springmvc.xml")
  3. public class DemoApplication implements ApplicationContextAware{
  5.     static ApplicationContext applicationContext;
  7.     public static void main(String[] args) {
  8.         SpringApplication.run(DemoApplication.class, args);
  9.         Object                 myClass1               = applicationContext.getBean(MyClass.class);
  10.         Object                 myClass2               = applicationContext.getBean(MyClass.class);
  11.         System.out.println(">>>>>>> 相等吗? " + (myClass1 == myClass2));
  12.     }
  14.     @Bean
  15.     public MyClass myClass() {
  16.         return new MyClass();
  17.     }
  18.     @Override
  19.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  20.         if(this.applicationContext == null) {
  21.             this.applicationContext = applicationContext;
  22.         }
  23.     }
  24. }

输出:

  1. >>>>>>>>> static block
  2. >>>>>>>>> non-static block
  3. >>>>>>>>> postConstruct method!
  4. >>>>>>>>> afterPropertiesSet method!
  5. >>>>>>>>> init method!
  6. >>>>>>> 相等吗? true

亲测, 默认的单例是容器一起来之后就立即实例化(lazy = false)的, 也就是说, 我把断点打在代码块2的第9行, 程序还没有跑到第9行的时候就已经打印出了前5行.

单例的Bean可以延迟实例化, 在@Bean注释下使用@Lazy(关于@Lazy的详细用法可以参考该注解的doc)后, 同样还是在代码块2的第9行断点, 当执行第9行的时候才会打印出以上输出的前5行.

测一测多例, 我们在@Bean注解下标注@Scope("prototype"), 代码块2变成:
代码块3:

  1. @SpringBootApplication
  2. //@ImportResource("springmvc.xml")
  3. public class DemoApplication implements ApplicationContextAware{
  5.     static ApplicationContext applicationContext;
  7.     public static void main(String[] args) {
  8.         SpringApplication.run(DemoApplication.class, args);
  9.         MyClass                 myClass1               = applicationContext.getBean(MyClass.class);
  10.         MyClass                 myClass2               = applicationContext.getBean(MyClass.class);
  11.         System.out.println(">>>>>>> 相等吗? " + (myClass1 == myClass2));
  12.     }
  14.     @Bean(initMethod = "init", destroyMethod = "destroyMethod")
  15.     @Scope("prototype")
  16.     public MyClass myClass() {
  17.         return new MyClass();
  18.     }
  19.     @Override
  20.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  21.         if(this.applicationContext == null) {
  22.             this.applicationContext = applicationContext;
  23.         }
  24.     }
  25. }

输出:

  1. >>>>>>>>> static block
  2. >>>>>>>>> non-static block
  3. >>>>>>>>> postConstruct method!
  4. >>>>>>>>> afterPropertiesSet method!
  5. >>>>>>>>> init method!
  6. >>>>>>>>> non-static block
  7. >>>>>>>>> postConstruct method!
  8. >>>>>>>>> afterPropertiesSet method!
  9. >>>>>>>>> init method!
  10. >>>>>>> 相等吗? false

可以看到多例模式的Bean, 每次去容器中取到的都是一个新对象, 他们的内存地址不一样! 并且, 从输出的1-9行看出, 实例化了两次!
再来测一测多例的延迟实例化问题, 当我把断点打在代码块3的第9行, 程序跑完第8行准备跑第9行的时候, 控制台均没有输出, 当跑完第9行后, 控制台打印:

  1. >>>>>>>>> static block
  2. >>>>>>>>> non-static block
  3. >>>>>>>>> postConstruct method!
  4. >>>>>>>>> afterPropertiesSet method!
  5. >>>>>>>>> init method!

接着执行完第10行后打印:

  1. >>>>>>>>> non-static block
  2. >>>>>>>>> postConstruct method!
  3. >>>>>>>>> afterPropertiesSet method!
  4. >>>>>>>>> init method!

可以看出, 多例模式的Bean是延迟实例化的, 只有从容器中取Bean实例并引用它时才会去实例化它, 并且是每取一次, 就实例化一个对象出来.

那么问题来了, 如果我在多例的Bean上加上@Lazy(false)之后, 会不会在容器一起来之后就去实例化一次呢?
加了@Lazy(false)之后,在代码块3的第9行打断点, 当即将跑第9行时, 查看控制台, 并没有任何输出, 跑完第九行才打印出:

  1. >>>>>>>>> static block
  2. >>>>>>>>> non-static block
  3. >>>>>>>>> postConstruct method!
  4. >>>>>>>>> afterPropertiesSet method!
  5. >>>>>>>>> init method!

说明对于多例的Bean来说, 延迟实例化策略对多例Bean无意义. 多例Bean 都是延迟实例化的!

Spring 容器中Bean的生命周期

接着, 来探讨一下Spring容器中的Bean的生命周期.
直接上我自己的测试代码:
代码块1:
有这样一个Class定义:

  1. public class MyClass implements InitializingBean, DisposableBean, BeanNameAware {
  2.     private String beanName;
  3.     private int age;
  4.     private String address;
  6.     public MyClass() {
  7.         System.err.println(">>>>>>>>>>> MyClass 无参数的构造方法执行!");
  8.     }
  9.     public MyClass(int age, String address) {
  10.         System.err.println(">>>>>>>>>>> MyClass 带参数的构造方法执行!");
  11.         this.age = age;
  12.         this.address = address;
  13.     }
  14.     static {
  15.         System.err.println(">>>>>>>>> 静态代码块执行");
  16.     }
  17.     {
  18.         System.err.println(">>>>>>>>> 非静态代码块执行");
  19.     }
  20.     @Override
  21.     public void afterPropertiesSet() throws Exception {
  22.         System.err.println(">>>>>>>>> 重写InitializingBean的afterPropertiesSet执行!");
  23.     }
  25.     @PostConstruct
  26.     void method() {
  27.         System.err.println(">>>>>>>>> @PostConstruct标注的方法执行!");
  28.     }
  30.     @PreDestroy
  31.     void preDestroy() {
  32.         System.err.println(">>>>>>>>> @PreDestroy标注的方法执行!");
  33.     }
  35.     public void init() {
  36.         System.err.println(">>>>>>>>> 自定义的init方法执行!");
  37.     }
  39.     public void destroyMethod() {
  40.         System.err.println(">>>>>>>>> 自定义的destroy方法执行!");
  41.     }
  43.     @Override
  44.     public void destroy() {
  45.         System.err.println(">>>>>>>>> 重写DisposableBean的destroy方法执行!");
  46.     }
  48.     @Override
  49.     public void setBeanName(String s) {
  50.         System.err.println(">>>>>>>>> 重写BeanNameAware的setBeanName方法执行!");
  51.         this.beanName = s;
  52.     }
  54.     public int getAge() {
  55.         return age;
  56.     }
  58.     public void setAge(int age) {
  59.         this.age = age;
  60.         System.err.println(">>>>>>>>> MyClass 的setAge方法执行 set age = "+age+"!");
  61.     }
  63.     public String getAddress() {
  64.         return address;
  65.     }
  67.     public void setAddress(String address) {
  68.         this.address = address;
  69.         System.err.println(">>>>>>>>> MyClass 的setAddress方法执行 set address = "+address+"!");
  70.     }
  72.     public String getBeanName() {
  73.         return beanName;
  74.     }
  75. }

代码块2
org.springframework.beans.factory.config.BeanPostProcessor的实现类:

  1. public class MyBeanPostPrecessor implements BeanPostProcessor {
  3.     public MyBeanPostPrecessor() {
  4.         super();
  5.         System.err.println(">>>>>>>> BeanPostProcessor 实现类的 构造 方法执行");
  6.     }
  8.     @Override
  9.     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  10.         if(!(bean instanceof MyClass)) {
  11.             return bean;
  12.         }
  13.         System.err.println(">>>>>>>> BeanPostProcessor 实现类的 postProcessBeforeInitialization 方法执行");
  14.         return bean;
  15.     }
  17.     @Override
  18.     public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  19.         if(!(bean instanceof MyClass)) {
  20.             return bean;
  21.         }
  22.         System.err.println(">>>>>>>> BeanPostProcessor 实现类的 postProcessAfterInitialization 方法执行");
  23.         return bean;
  24.     }
  25. }

代码块3
org.springframework.beans.factory.config.BeanFactoryPostProcessor实现类:

  1. public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
  3.     public MyBeanFactoryPostProcessor() {
  4.         super();
  5.         System.err.println(">>>>>>>> BeanFactoryPostProcessor 实现类的 构造 方法执行");
  6.     }
  8.     @Override
  9.     public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
  10.         System.err.println(">>>>>>>> BeanFactoryPostProcessor 实现类的 postProcessBeanFactory 方法执行");
  11. //      String[] beanDefinitionNames = configurableListableBeanFactory.getBeanDefinitionNames();
  12. //      for(String bd : beanDefinitionNames) {
  13. //          //一些获取bean 定义信息的方法...
  14. //          BeanDefinition beanDefinition = configurableListableBeanFactory.getBeanDefinition(bd);
  15. //          MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
  16. //          ConstructorArgumentValues constructorArgumentValues = beanDefinition.getConstructorArgumentValues();
  17. //          String scope = beanDefinition.getScope();
  18. //          // 一些修改Bean 定义信息的方法...
  19. //          beanDefinition.setLazyInit(true);
  20. //          beanDefinition.setScope("singleton");
  21. //      }
  22.     }
  23. }

代码块4
InstantiationAwareBeanPostProcessorAdapter适配器的子类:

  1. public class MyInstantiationAwareBeanPostProcessorAdapter extends InstantiationAwareBeanPostProcessorAdapter {
  3.     public MyInstantiationAwareBeanPostProcessorAdapter() {
  4.         super();
  5.         System.err.println(">>>>>>>> 自定义的InstantiationAwareBeanPostProcessorAdapter 子类的 构造 方法执行");
  6.     }
  7.     @Override
  8.     public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
  9.         if(beanClass.isAssignableFrom(MyClass.class) || "myClass".equals(beanName)) {
  10.             System.err.println(">>>>>>>> 自定义的InstantiationAwareBeanPostProcessorAdapter 子类的 postProcessBeforeInstantiation(Class<?> beanClass, String beanName) 方法执行");
  11.         }
  12.         return super.postProcessBeforeInstantiation(beanClass, beanName);
  13.     }
  15.     @Override
  16.     public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
  17.         if(bean instanceof MyClass || "myClass".equals(beanName)) {
  18.             System.err.println(">>>>>>>> 自定义的InstantiationAwareBeanPostProcessorAdapter 子类的 postProcessAfterInstantiation(Object bean, String beanName) 方法执行");
  19.         }
  20.         return super.postProcessAfterInstantiation(bean, beanName);
  21.     }
  23.     @Override
  24.     public PropertyValues postProcessPropertyValues(
  25.             PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
  26.         if(bean instanceof MyClass || "myClass".equals(beanName)) {
  27.             System.err.println(">>>>>>>> 自定义的InstantiationAwareBeanPostProcessorAdapter 子类的 postProcessPropertyValues 方法执行,PropertyValues: "+ pvs.toString()+"");
  28.         }
  29.         return pvs;
  30.     }
  31. }

代码块5
SpringBoot工程的启动类:

  1. @SpringBootApplication
  2. //@ImportResource("springmvc.xml")
  3. public class DemoApplication implements ApplicationContextAware, BeanFactoryAware {
  4.     static ApplicationContext applicationContext;
  5.     static BeanFactory beanFactory;
  7.     public static void main(String[] args) {
  8.         SpringApplication.run(DemoApplication.class, args);
  9.         MyClass myClass = applicationContext.getBean(MyClass.class);
  10.         BeanDefinitionRegistry beanDefinitionRegistry = (BeanDefinitionRegistry)DemoApplication.applicationContext;
  12.         DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory)DemoApplication.beanFactory;
  13.         BeanDefinition beanDefinition = defaultListableBeanFactory.getBeanDefinition(myClass.getBeanName());
  14.         //从容器中移除MyClass的bean
  15.         beanDefinitionRegistry.removeBeanDefinition(myClass.getBeanName());
  16.         //      MyClass myClass1 = applicationContext.getBean(MyClass.class);
  17.         //      System.err.println(myClass1.getBeanName());
  18. //      再次手动注册MyClass
  19.         beanDefinitionRegistry.registerBeanDefinition(myClass.getBeanName(), beanDefinition);
  20.         MyClass myClass2 = applicationContext.getBean(MyClass.class);
  21.         System.err.println(">>>>>>>>> " + myClass2.getBeanName());
  22.     }
  24.     @Bean(initMethod = "init", destroyMethod = "destroyMethod")
  25.     //  @Scope("prototype")
  26.     //  @Lazy(false)
  27.     public MyClass myClass() {
  28.         return new MyClass(100, "广东");
  29.     }
  31.     @Bean
  32.     public MyBeanFactoryPostProcessor myBeanFactoryPostProcessor() {
  33.         return new MyBeanFactoryPostProcessor();
  34.     }
  36.     @Bean
  37.     public MyBeanPostPrecessor myBeanPostPrecessor() {
  38.         return new MyBeanPostPrecessor();
  39.     }
  41.     @Bean
  42.     public MyInstantiationAwareBeanPostProcessorAdapter myInstantiationAwareBeanPostProcessorAdapter() {
  43.         return new MyInstantiationAwareBeanPostProcessorAdapter();
  44.     }
  47.     @Override
  48.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  49.         if(DemoApplication.applicationContext == null) {
  50.             DemoApplication.applicationContext = applicationContext;
  51.         }
  52.     }
  54.     @Override
  55.     public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
  56.         if(DemoApplication.beanFactory == null) {
  57.             DemoApplication.beanFactory = beanFactory;
  58.         }
  59.     }
  60. }

启动代码块5后控制台输出:

  1. Connected to the target VM, address: '127.0.0.1:11931', transport: 'socket'
  3.   .   ____          _            __ _ _
  4.  /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
  5. ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
  6.  \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  7.   '  |____| .__|_| |_|_| |_\__, | / / / /
  8.  =========|_|==============|___/=/_/_/_/
  9.  :: Spring Boot ::        (v2.0.6.RELEASE)
  11. >>>>>>>> BeanFactoryPostProcessor 实现类的 构造 方法执行
  12. >>>>>>>> BeanFactoryPostProcessor 实现类的 postProcessBeanFactory 方法执行
  13. >>>>>>>> BeanPostProcessor 实现类的 构造 方法执行
  14. >>>>>>>> 自定义的InstantiationAwareBeanPostProcessorAdapter 子类的 构造 方法执行
  15. >>>>>>>> 自定义的InstantiationAwareBeanPostProcessorAdapter 子类的 postProcessBeforeInstantiation(Class<?> beanClass, String beanName) 方法执行
  16. >>>>>>>>> 静态代码块执行
  17. >>>>>>>>> 非静态代码块执行
  18. >>>>>>>>>>> MyClass 带参数的构造方法执行!
  19. >>>>>>>> 自定义的InstantiationAwareBeanPostProcessorAdapter 子类的 postProcessAfterInstantiation(Object bean, String beanName) 方法执行
  20. >>>>>>>> 自定义的InstantiationAwareBeanPostProcessorAdapter 子类的 postProcessPropertyValues 方法执行,PropertyValues: PropertyValues: length=0
  21. >>>>>>>>> 重写BeanNameAware的setBeanName方法执行!
  22. >>>>>>>> BeanPostProcessor 实现类的 postProcessBeforeInitialization 方法执行
  23. >>>>>>>>> @PostConstruct标注的方法执行!
  24. >>>>>>>>> 重写InitializingBean的afterPropertiesSet执行!
  25. >>>>>>>>> 自定义的init方法执行!
  26. >>>>>>>> BeanPostProcessor 实现类的 postProcessAfterInitialization 方法执行
  27. >>>>>>>>> @PreDestroy标注的方法执行!
  28. >>>>>>>>> 重写DisposableBean的destroy方法执行!
  29. >>>>>>>>> 自定义的destroy方法执行!
  30. >>>>>>>> 自定义的InstantiationAwareBeanPostProcessorAdapter 子类的 postProcessBeforeInstantiation(Class<?> beanClass, String beanName) 方法执行
  31. >>>>>>>>> 非静态代码块执行
  32. >>>>>>>>>>> MyClass 带参数的构造方法执行!
  33. >>>>>>>> 自定义的InstantiationAwareBeanPostProcessorAdapter 子类的 postProcessAfterInstantiation(Object bean, String beanName) 方法执行
  34. >>>>>>>> 自定义的InstantiationAwareBeanPostProcessorAdapter 子类的 postProcessPropertyValues 方法执行,PropertyValues: PropertyValues: length=0
  35. >>>>>>>>> 重写BeanNameAware的setBeanName方法执行!
  36. >>>>>>>> BeanPostProcessor 实现类的 postProcessBeforeInitialization 方法执行
  37. >>>>>>>>> @PostConstruct标注的方法执行!
  38. >>>>>>>>> 重写InitializingBean的afterPropertiesSet执行!
  39. >>>>>>>>> 自定义的init方法执行!
  40. >>>>>>>> BeanPostProcessor 实现类的 postProcessAfterInitialization 方法执行
  41. >>>>>>>>> myClass

这里说一下org.springframework.beans.factory.config.BeanPostProcessor接口, 它是一个顶层接口, 该接口定义如下:

  1. public interface BeanPostProcessor {
  2.     default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  3.         return bean;
  4.     }
  5.     default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  6.         return bean;
  7.     }
  8. }

该接口的许多Spring内置的实现类例如AutowiredAnnotationBeanPostProcessor,RequiredAnnotationBeanPostProcessor,ServletContextAwareProcessor是Spring 容器启动时, 容器自己实例化并调用的,例如AutowiredAnnotationBeanPostProcessor用于扫描一个Bean中被@AntoWired标注的成员属性或setter方法或构造器以在实例化Bean时进行依赖注入. 从以上的控制台输出顺序可以看到, 该接口的postProcessBeforeInitialization方法和postProcessAfterInitialization方法在Bean的生命周期的执行顺序为:

1. Bean的构造方法, 此时Bean的实例已经创建(亲测, 可以自己debug试试看)
2. `BeanPostProcessor`的`postProcessBeforeInitialization`方法
3. Bean类中`@PostConstruct`标注的方法(如果有)
4. Bean类中重写`InitializingBean`接口的`afterPropertiesSet()`方法(如果有)
5. Bean中自定义的`init`方法, 并在`@Bean(initMethod = 'init')`指定(如果有)
6. `BeanPostProcessor`的`postProcessAfterInitialization`方法

以上顺序, 对实例化在Spring容器中的Bean都适用, 也就是说, 以上代码块3中的两个方法在每一个Bean实例化之后都会执行, 所以, 可以通过自定义该接口的实现类来对实例化后的对象做一些操作. Spring本身已经提供很多实现类, 具体功能, 可自己源码探索.

再接着, 顺带再说一下另一个BeanPostProcessor的子接口InstantiationAwareBeanPostProcessor, 该子接口除了具备BeanPostProcessor的两个方法定义之外, 还有以下几个方法:

  1.     //该方法在构造方法执行之前(Bean实例化之前)执行
  2.     default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
  3.         return null;
  4.     }
  5.     //该方法在构造方法执行之后(Bean实例化后)执行
  6.     default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
  7.         return true;
  8.     }
  9.     //该方法在属性注入时可对注入的属性进行操作
  10.     default PropertyValues postProcessPropertyValues(
  11.             PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
  13.         return pvs;
  14.     }

以上代码中注释所说的意思, 从以上控制台输出中可以得到验证.该接口有一个适配器**InstantiationAwareBeanPostProcessorAdapter, 可以继承该适配器,重写里面的方法对Bean实例化前后的时间点做一些操作.

接着再说一下和Bean的生命周期无关, 但是和Spring 容器的生命周期有关的BeanFactoryPostProcessor接口.该接口定义如下:

  1. @FunctionalInterface
  2. public interface BeanFactoryPostProcessor {
  4.     /**
  5.      * Modify the application context's internal bean factory after its standard
  6.      * initialization. All bean definitions will have been loaded, but no beans
  7.      * will have been instantiated yet. This allows for overriding or adding
  8.      * properties even to eager-initializing beans.
  9.      * @param beanFactory the bean factory used by the application context
  10.      * @throws org.springframework.beans.BeansException in case of errors
  11.      */
  12.     void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
  13. }

从以上的控制台输出顺序可以看出, 该接口实现类的postProcessBeanFactory方法是在Bean初始化之前执行的, 查看该接口方法的注释可知该方法是在所有的Bean定义信息加载但还没有任何Bean被实例化时执行的.那问题就来了, 这个接口和BeanPostProcessor接口有什么区别?以及使用场景如何呢?

  1. BeanFactoryPostProcessor的实现类是作为我们常说的Spring Bean来实例化, 但是这些实现类的对象不作为其他Bean生命周期的一部分, 而是Spring 容器生命周期的一部分.

  2. 由于BeanFactoryPostProcessor的postProcessBeanFactory被回调的时机是在Bean定义信息被加载时, 在其他Bean被实例化前. 所以你可以在获取到所有的Bean定义, 并修改或重写一些某些Bean 定义,即使是"eager-initializing"的Bean 定义也可以在这个时候修改, 例如这个例子:

    1. public class CustomBeanFactory implements BeanFactoryPostProcessor {
    2.    @Override
    3.     public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
    4.         System.err.println(">>>>>>>> BeanFactoryPostProcessor 实现类的 postProcessBeanFactory 方法执行");
    5.         String[] beanDefinitionNames = configurableListableBeanFactory.getBeanDefinitionNames();
    6.         for(String bd : beanDefinitionNames) {
    7.             //一些获取bean 定义信息的方法...
    8.             BeanDefinition beanDefinition = configurableListableBeanFactory.getBeanDefinition(bd);
    9.             MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
    10.             ConstructorArgumentValues constructorArgumentValues = beanDefinition.getConstructorArgumentValues();
    11.             String scope = beanDefinition.getScope();
    12.             // 一些修改Bean 定义信息的方法...
    13.             beanDefinition.setLazyInit(true);
    14.             beanDefinition.setScope("singleton");
    15.         }
    16.     }
    17. }

  3. BeanPostProcessor中的两个方法是在Bean实例已经创建之后执行.

顺带再记录一下看源码过程中, SpringBoot启动的时候做的一些事情.
SpringBoot通过SpringApplication.run(DemoApplication.class, args);开始启动Spring, 经过若干操作之后调用了SpringApplication类中public ConfigurableApplicationContext run(String... args)方法,该方法如下:

  1. public ConfigurableApplicationContext run(String... args) {
  2.         StopWatch stopWatch = new StopWatch();
  3.         stopWatch.start();
  4.         ConfigurableApplicationContext context = null;
  5.         Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
  6.         this.configureHeadlessProperty();
  7.         SpringApplicationRunListeners listeners = this.getRunListeners(args);
  8.         listeners.starting();
  10.         Collection exceptionReporters;
  11.         try {
  12.             ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
  13.             ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
  14.             this.configureIgnoreBeanInfo(environment);
  15.             Banner printedBanner = this.printBanner(environment);
  16.             context = this.createApplicationContext();
  17.             exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
  18.             this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
  19.             this.refreshContext(context);
  20.             this.afterRefresh(context, applicationArguments);
  21.             stopWatch.stop();
  22.             if (this.logStartupInfo) {
  23.                 (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
  24.             }
  26.             listeners.started(context);
  27.             this.callRunners(context, applicationArguments);
  28.         } catch (Throwable var10) {
  29.             this.handleRunFailure(context, var10, exceptionReporters, listeners);
  30.             throw new IllegalStateException(var10);
  31.         }
  33.         try {
  34.             listeners.running(context);
  35.             return context;
  36.         } catch (Throwable var9) {
  37.             this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
  38.             throw new IllegalStateException(var9);
  39.         }
  40.     }

额外的, 注意这个方法的16行, 创建一个ApplicationContext接口的实现类org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext对象(看源码可知, 只要classpath路径中包含javax.servlet.Servlet和 org.springframework.web.context.ConfigurableWebApplicationContext 就会创建这个类型的ApplicationContext对象作为上下文).
19行this.refreshContext(context), 这段代码之后做的事情就是将生成的ApplicationContext对象强转成org.springframework.context.support.AbstractApplicationContext, 然后调用这个抽象类的org.springframework.context.support.AbstractApplicationContext#refresh方法, 该方法体部分代码如下(没有贴try-catch块):

  1. public void refresh() throws BeansException, IllegalStateException {
  2.                 // Allows post-processing of the bean factory in context subclasses.
  3.                 postProcessBeanFactory(beanFactory);
  5.                 // Invoke factory processors registered as beans in the context.
  6.                 invokeBeanFactoryPostProcessors(beanFactory);
  8.                 // Register bean processors that intercept bean creation.
  9.                 registerBeanPostProcessors(beanFactory);
  11.                 // Initialize message source for this context.
  12.                 initMessageSource();
  14.                 // Initialize event multicaster for this context.
  15.                 initApplicationEventMulticaster();
  17.                 // Initialize other special beans in specific context subclasses.
  18.                 onRefresh();
  20.                 // Check for listener beans and register them.
  21.                 registerListeners();
  23.                 // Instantiate all remaining (non-lazy-init) singletons.
  24.                 finishBeanFactoryInitialization(beanFactory);
  26.                 // Last step: publish corresponding event.
  27.                 finishRefresh();
  28. }

看第6行和第9行,第6行所做的事情就是依照顺序执行了注册在上下文中的所有BeanFactoryPostProcessor 接口的对象的void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) 方法以在BeanDefinition被容器加载时做一些操作,包括我自定义的'MyBeanFactoryPostProcessor'的postProcessBeanFactory方法, 这些BeanFactoryPostProcessor对象的执行有顺序, 如何排序, 可追踪以上代码块中invokeBeanFactoryPostProcessors(beanFactory);方法的执行, 不再多说.
第9行, 所做的事情就是将所有的BeanPostProcessor接口的实现类对象注册到beanFactory上, 以在接下来容器实例化Bean之后按照一定顺序执行实例化post和after方法, 至于我这里所谓的顺序,详情可追踪这段代码的执行.

总结
Spring 容器从启动到用户从容器中取一个Bean对象实例并引用它这个过程做个简单的总结, 顺序如下:
1. 注册到容器中的所有接口BeanFactoryPostProcessor(该接口的主要作用是可以在Bean实例化之前, 修改已经加载的BeanDefinition)的实现类被实例化.
2. 1中所指的实例化对象按照顺序执行postProcessBeanFactory方法.
3. 所有注册到容器中的BeanPostProcessor的实现类被实例化.
4. 在一个普通Bean被容器实例化之前, BeanPostProcessor接口的子接口InstantiationAwareBeanPostProcessor的实现类的实例化对象的postProcessBeforeInstantiation方法执行.
5. 一个普通Bean的静态代码块被执行(意味着类加载器开始加载这个类的.class文件)
6. 一个普通Bean被容器实例化, 先执行非静态代码块, 再执行构造方法.
7. InstantiationAwareBeanPostProcessor的实现类的实例化对象的postProcessAfterInstantiation方法执行.
8. InstantiationAwareBeanPostProcessor的实现类的实例化对象的postProcessPropertyValues方法执行.
9. 如果该普通Bean实现了Aware接口的子接口, 例如BeanNameAware, 则这些aware接口的方法执行.
10. 注册到容器中的各个接口BeanPostProcessor的的实现类的postProcessBeforeInitialization方法执行.
11. 普通Bean中@PostConstruct标注的方法执行(如果有).
12. 如果普通Bean实现了InitializingBean接口, 则afterPropertiesSet方法执行.
13. 自定义的init方法执行!
14. BeanPostProcessor 实现类的 postProcessAfterInitialization 方法执行.
15. 从容器中移除一个Bean
15. @PreDestroy标注的方法执行(如果有).
16. 如果普通Bean实现了DisposableBean接口则destroy方法执行.
17. 自定义的destroy方法执行!

欢迎各位大佬多多交流, 不正之处欢迎指正!
书写不易, 如想转载请 注明原文地址:
https://www.zybuluo.com/survivorZzz/note/1314637

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注