Springboot扩展点之ApplicationContextAwareProcessor

阳光穿透心脏的1/2处 2024-03-27 15:59 69阅读 0赞

Springboot扩展点系列实现方式、工作原理集合：

[Springboot扩展点之ApplicationContextInitializer][Springboot_ApplicationContextInitializer]

[Springboot扩展点之BeanFactoryPostProcessor][Springboot_BeanFactoryPostProcessor]

[Springboot扩展点之BeanDefinitionRegistryPostProcessor][Springboot_BeanDefinitionRegistryPostProcessor]

[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扩展点之CommandLineRunner和ApplicationRunner][Springboot_CommandLineRunner_ApplicationRunner]

[Springboot扩展点之FactoryBean][Springboot_FactoryBean]

[Springboot扩展点之DisposableBean][Springboot_DisposableBean]

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

## **前言** ##

这篇文章主要来分享Springboot的扩展点之ApplicationContextAwareProcessor，而ApplicationContextAwareProcessor本身并不是扩展点，而是BeanPostProcessor扩展接口的具体实现，关于BeanPostProcessor扩展接口的功能特性、实现方式和工作原理可以移步[Springboot扩展点之BeanPostProcessor][Springboot_BeanPostProcessor]，但是还是要当作Springboot的扩展点来分析，是因为其内部有6个扩展点可供实现，分别是EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware，这几个接口都是Spring预留的重点扩展实现，与Spring的Bean的生命周期密切相关。

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

ApplicationContextAwareProcessor本身并不是扩展点，而是实现了BeanPostProcessor，并实现postProcessBeforeInitialization()，所以并不需要去实现它，但是其内部包含了以下6个接口实现的执行时机，这几个接口的功能作用分别是：

1、EnvironmentAware：用于获取Enviroment，Enviroment可以获得系统内的所有参数；另外也可以通过注入的方式来获得Environment，用哪种方式需要以实现场景而决定。

2、EmbeddedValueResolverAware：用于获取StringValueResolver，StringValueResolver可以获取基于String类型的properties的变量；另外还可以使用@Value的方式来获取properties的变量，用哪种方式需要以实现场景而决定。

3、ResourceLoaderAware：用于获取ResourceLoader，ResourceLoader可以用于获取classpath内所有的资源对象。

4、ApplicationEventPublisherAware：用于获取ApplicationEventPublisher，ApplicationEventPublisher可以用来发布事件，当然这个对象也可以通过spring注入的方式来获得，具体的实现方式可以参考[Springboot事件监听机制的实战应用][Springboot]。

5、MessageSourceAware：用于获取MessageSource，MessageSource主要用来做国际化。

6、ApplicationContextAware：用来获取ApplicationContext，ApplicationContext就是Spring上下文管理器。

下面定义一个Bird类，实现ApplicationContextAware接口，以Bird为例分享ApplicationContextAwareProcessor的功能特性。

@Component
    @Slf4j
    public class Bird implements ApplicationContextAware {
        private String name="xiao niao";
        private ApplicationContext applicationContext;
    
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            this.applicationContext=applicationContext;
            log.info("----Spring的上下文环境application被注入");
        }
    }

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

单元测执行结果

![8d28b5a1590542c893142b2da5af7dc8.png][]

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

### **注册时机** ###

ApplicationContextAwareProcessor的注册时机，即准备BeanFactory的时候，注册的入口在AbstractApplicationContext\#refresh----->AbstractApplicationContext\#prepareBeanFactory方法中。

![d5e2deabfe8a466eb34ce42875b30b15.png][]

### **执行逻辑** ###

ApplicationContextAwareProcessor\#postProcessBeforeInitialization的扩展逻辑很简单：即当前Bean是否实现了EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware，如果不是，则直拉返回，如果是，则执行XxxAware接口的扩展逻辑；

class ApplicationContextAwareProcessor implements BeanPostProcessor {
       private final ConfigurableApplicationContext applicationContext;
       private final StringValueResolver embeddedValueResolver;
       
       public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
          this.applicationContext = applicationContext;
          this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
       }
       @Override
       @Nullable
       public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
           //如果非实现EnvironmentAware、EmbeddedValueResolverAware、
           //ResourceLoaderAware、ApplicationEventPublisherAware、
           //MessageSourceAware、ApplicationContextAware，则直拉返回；
          if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
                bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
                bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
             return bean;
          }
          AccessControlContext acc = null;
          if (System.getSecurityManager() != null) {
             acc = this.applicationContext.getBeanFactory().getAccessControlContext();
          }
          if (acc != null) {
             AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                invokeAwareInterfaces(bean);
                return null;
             }, acc);
          }
          else {
              //如果实现XXXAware接口，则执行相关Aware接口的扩展方法；
             invokeAwareInterfaces(bean);
          }
          return bean;
       }
       private void invokeAwareInterfaces(Object bean) {
          if (bean instanceof EnvironmentAware) {
             ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
          }
          if (bean instanceof EmbeddedValueResolverAware) {
             ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
          }
          if (bean instanceof ResourceLoaderAware) {
             ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
          }
          if (bean instanceof ApplicationEventPublisherAware) {
             ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
          }
          if (bean instanceof MessageSourceAware) {
             ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
          }
          if (bean instanceof ApplicationContextAware) {
             ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
          }
       }
    }

### **执行时机** ###

因为ApplicationContextAwareProcessor实现了BeanPostProcessor接口，并重写了postProcessBeforeInitialization()。关于BeanPostProcessor接口的执行时机可移步[Springboot扩展点之BeanPostProcessor][Springboot_BeanPostProcessor]，这里就不再反复赘述了。

![35b1d51085db4a6a85ed43a826116ead.png][]

## **总结** ##

通过以上的分析，可以了解到：

1、ApplicationContextAwareProcessor实现BeanPostProcessor接口，是Spring扩展点之BeanPostProcessor的内部经典实现。

2、ApplicationContextAwareProcessor\#postProcessBeforeInitialization内部逻辑很简单，主要是执行了XxxAware相关扩展接口具体实现；

3、ApplicationContextAwareProcessor注册时机相对比较早，即BeanFactory实例化后，相关属性初始化时；

4、ApplicationContextAwareProcessor\#postProcessBeforeInitialization的执行时机，是在Spring管理的Bean实例化、属性注入完成后，InitializingBean\#afterPropertiesSet方法以及自定义的初始化方法之前；

[Springboot_ApplicationContextInitializer]: https://blog.csdn.net/fox9916/article/details/128522598
[Springboot_BeanFactoryPostProcessor]: https://blog.csdn.net/fox9916/article/details/128823328
[Springboot_BeanDefinitionRegistryPostProcessor]: https://blog.csdn.net/fox9916/article/details/128538625
[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_CommandLineRunner_ApplicationRunner]: https://blog.csdn.net/fox9916/article/details/129086542?spm=1001.2014.3001.5502
[Springboot_FactoryBean]: https://blog.csdn.net/fox9916/article/details/129070764?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
[Springboot]: https://blog.csdn.net/fox9916/article/details/128210647
[8d28b5a1590542c893142b2da5af7dc8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/38d88995a5f4456584e868825306dc6b.png
[d5e2deabfe8a466eb34ce42875b30b15.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/8008770e983c48fc9623e76af7219279.png
[35b1d51085db4a6a85ed43a826116ead.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/cfbdb40e69c7494fa803fe3060f284ec.png