Springboot扩展点之SmartInitializingSingleton

一时失言乱红尘 2024-03-27 17:26 19阅读 0赞

Springboot扩展点系列：

[Springboot扩展点之ApplicationContextInitializer][Springboot_ApplicationContextInitializer]

[Springboot扩展点之BeanDefinitionRegistryPostProcessor][Springboot_BeanDefinitionRegistryPostProcessor]

[Springboot扩展点之BeanFactoryPostProcessor][Springboot_BeanFactoryPostProcessor]

[Springboot扩展点之BeanPostProcessor][Springboot_BeanPostProcessor]

[Springboot扩展点之InstantiationAwareBeanPostProcessor][Springboot_InstantiationAwareBeanPostProcessor]

[Springboot扩展点之SmartInstantiationAwareBeanPostProcessor][Springboot_SmartInstantiationAwareBeanPostProcessor]

[Springboot扩展点之ApplicationContextAwareProcessor][Springboot_ApplicationContextAwareProcessor]

[Springboot扩展点之@PostConstruct][Springboot_PostConstruct]

[Springboot扩展点之InitializingBean][Springboot_InitializingBean]

[Springboot扩展点之SmartInitializingSingleton][Springboot_SmartInitializingSingleton]

[Springboot扩展点之FactoryBean][Springboot_FactoryBean]

[Springboot扩展点之CommandLineRunner和ApplicationRunner][Springboot_CommandLineRunner_ApplicationRunner]

[Springboot扩展点之DisposableBean][Springboot_DisposableBean]

[Springboot扩展点系列之终结篇：Bean的生命周期][Springboot_Bean]

--------------------

## **前言** ##

这篇文章会重点分析一下SmartInitializingSingleton扩展点的功能 特性、实现方式 、工作原理。SmartInitializingSingleton扩展点内只有一个扩展方法，且执行时机在Spring Bean的生命周期里比较靠后，很重要，但是也很简单。

## **功能特性** ##

1、SmartInitializingSingleton主要用于在Spring容器启动完成时进行扩展操作，即afterSingletonsInstantiated()；

2、实现SmartInitializingSingleton接口的bean的作用域必须是单例，afterSingletonsInstantiated()才会触发；

3、afterSingletonsInstantiated()触发执行时，非懒加载的单例bean已经完成实现化、属性注入以及相关的初始化操作；

3、afterSingletonsInstantiated()的执行时机是在DefaultListableBeanFactory\#preInstantiateSingletons()；

关于Spring bean有七种作用域：默认singleton(单例)、prototype、request、session、globalSession、application、websocket；

1、singleton(单例)：Spring容器只会创建一个bean对象；

2、prototype：每次获取bean都会重新创建一个bean对象；

3、request：对于每一个http请求，在同一个请求内Spring容器只会创建一个bean对象，若请求结束，bean也随之销毁；

4、session：在同一个http会话里，Spring容器只会创建一个bean对象，若传话结束，也随之销毁；

5、globalSession：globalSession作用域的效果与session作用域类似，但是只适用于基于portlet的web应用程序中

6、application：在servlet程序中，该作用域的bean将会作为ServletContext对象的属性，被全局访问，与singleton的区别就是，singleton作用域的bean在Spring容器中只一；application作用域的bean在ServletContex中唯一；

7、websocket：为每个websocket对象创建一个实例。仅在Web相关的ApplicationContext中生效。

## **实现方式**  ##

这里用一个示例验证SmartInitializingSingleton的功能特性，并且通过debug分析其工作过程：

1、定义Dog类，以setter注入方式进行属性注入，同时Dog类实现SmartInitializingSingleton接口，重写afterSingletonsInstantiated()，并在方法内部打印日志，如果在实际业务开发过程中用到了这个扩展点，相关的扩展操作逻辑就是在这个方法内实现；

@Slf4j
    public class Dog implements InitializingBean, DisposableBean, SmartInitializingSingleton {
        private String name = "wang cai";
    
        private Food food;
    
        public Dog() {
            log.info("----Dog的无参构造方法被执行");
        }
        @Autowired
        public void setFood(Food food) {
            this.food = food;
            log.info("----dog的food属性被注入");
        }
        @Override
        public void afterPropertiesSet() throws Exception {
            log.info("----com.fanfu.entity.Dog.afterPropertiesSet触发执行");
        }
    
        public void myInitMethod() {
            log.info("----com.fanfu.entity.Dog.myInitMethod触发执行");
        }
    
        @Override
        public void destroy() throws Exception {
            log.info("----com.fanfu.entity.Dog.destroy触发执行");
        }
    
        @Override
        public void afterSingletonsInstantiated() {
            log.info("----com.fanfu.entity.Dog.afterSingletonsInstantiated触发执行");
        }
    }

2、定义Food类，作为Dog类的一个属性；

@Slf4j
    public class Food {
        private String name = "大骨头";
    
        public Food() {
            log.info("----Food的无参数构造方法被执行");
        }
    }

3、使用Configuration配置类的方式注册Dog、Food到Spring容器里；默认是单例对象；

@Configuration
    public class SpringConfig {
        @Bean(initMethod = "myInitMethod")
        public Dog dog(){
            Dog dog = new Dog();
            return dog;
        }
        @Bean
        public Food food(){
            Food food = new Food();
            return food;
        }
    }

4、单元测试，用于验证结果；

@Test
        public void test5(){
            log.info("----单元测试执行开始");
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("com.fanfu");
            log.info("----单元测试执行完毕");
        }

![5d06e4120d7d494d864a60a7f884386d.png][]

## **工作原理**  ##

如果我分享的关于Springboot扩展点系统的文章，从头都一点一点自己debug看过的话，一定对AbstractApplicationContext\#refresh()不陌生，与Spring容器启动相关的核心逻辑都在这个方法中。

1、在AbstractApplicationContext\#refresh()中，会发现调用了finishBeanFactoryInitialization()，从上面的注释可以看出，这个方法昌要实例化所有非懒加载的单例bean；

![d8124da5014148b797a201195c626e0f.png][]

2、进入到finishBeanFactoryInitialization()方法内，做了一些beanFactory的准备工作后，调用preInstantiateSingletons()开始非懒加载的单例bean实例化；

![5f4686cf52504de3abff320106500490.png][]

3、继续往下实际上是调用 了DefaultListableBeanFactory\#preInstantiateSingletons()，单独看这个方法，逻辑相对简单，分为两部分：第一部分，bean的实例化、属性注入、相关初始化操作；第二部分，找出所有实现了SmartInitializingSingleton接口的实现类，遍历并执行afterSingletonsInstantiated()；

public void preInstantiateSingletons() throws BeansException {
        //----------start------------------实例化bean----------------------------------------
       if (logger.isTraceEnabled()) {
          logger.trace("Pre-instantiating singletons in " + this);
       }
       List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    
       // Trigger initialization of all non-lazy singleton beans...
       for (String beanName : beanNames) {
          RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
          if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
             if (isFactoryBean(beanName)) {
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                   FactoryBean<?> factory = (FactoryBean<?>) bean;
                   boolean isEagerInit;
                   if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                      isEagerInit = AccessController.doPrivileged(
                            (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
                            getAccessControlContext());
                   }
                   else {
                      isEagerInit = (factory instanceof SmartFactoryBean &&
                            ((SmartFactoryBean<?>) factory).isEagerInit());
                   }
                   if (isEagerInit) {
                      getBean(beanName);
                   }
                }
             }
             else {
                getBean(beanName);
             }
          }
       }
       //----------end------------------实例化bean----------------------------------------
       //----------start------------------SmartInitializingSingleton#afterSingletonsInstantiated----------------------------------------
       for (String beanName : beanNames) {
          Object singletonInstance = getSingleton(beanName);
          //判断单例bean是否实现了SmartInitializingSingleton接口
          if (singletonInstance instanceof SmartInitializingSingleton) {
             SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
             if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                   smartSingleton.afterSingletonsInstantiated();
                   return null;
                }, getAccessControlContext());
             }
             else {
                 //执行afterSingletonsInstantiated()
                smartSingleton.afterSingletonsInstantiated();
             }
          }
       }
       //----------start------------------SmartInitializingSingleton#afterSingletonsInstantiated----------------------------------------
    }

## **总结** ##

如果要在业务开发中使用SmartInitializingSingleton扩展点，需要特别注意实现这个接口的bean应该是非懒加载的单例bean，执行时机是在bean完成实例化、属性注入、相关初始化操作后，否则无法触发执行。

[Springboot_ApplicationContextInitializer]: https://blog.csdn.net/fox9916/article/details/128522598
[Springboot_BeanDefinitionRegistryPostProcessor]: https://blog.csdn.net/fox9916/article/details/128538625
[Springboot_BeanFactoryPostProcessor]: https://blog.csdn.net/fox9916/article/details/128823328
[Springboot_BeanPostProcessor]: https://blog.csdn.net/fox9916/article/details/128917992
[Springboot_InstantiationAwareBeanPostProcessor]: https://blog.csdn.net/fox9916/article/details/128941464
[Springboot_SmartInstantiationAwareBeanPostProcessor]: https://blog.csdn.net/fox9916/article/details/128976944
[Springboot_ApplicationContextAwareProcessor]: https://blog.csdn.net/fox9916/article/details/128990305
[Springboot_PostConstruct]: https://blog.csdn.net/fox9916/article/details/128998846
[Springboot_InitializingBean]: https://blog.csdn.net/fox9916/article/details/129016083
[Springboot_SmartInitializingSingleton]: https://blog.csdn.net/fox9916/article/details/129042652
[Springboot_FactoryBean]: https://blog.csdn.net/fox9916/article/details/129070764?spm=1001.2014.3001.5502
[Springboot_CommandLineRunner_ApplicationRunner]: https://blog.csdn.net/fox9916/article/details/129086542?spm=1001.2014.3001.5502
[Springboot_DisposableBean]: https://blog.csdn.net/fox9916/article/details/129026156?spm=1001.2014.3001.5501
[Springboot_Bean]: https://blog.csdn.net/fox9916/article/details/129101918
[5d06e4120d7d494d864a60a7f884386d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/dbda74f59ff149bab34d5c7190998a0f.png
[d8124da5014148b797a201195c626e0f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/bbef874e10214a24a746a0bdca74f092.png
[5f4686cf52504de3abff320106500490.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/99089f45a2234688bda1ec7adf03be35.png