Spring源码初探-IOC(5)-ApplicationContext功能扩展及其扩展点

亦凉 2021-06-11 15:14 430阅读 0赞

[https://www.jianshu.com/p/2692bf784976][https_www.jianshu.com_p_2692bf784976]

## 前言 ##

前面几篇关于Spring的文章简单阐述了使用BeanFactory作为容器时bean的初始化过程。然而在实际使用中，我们并不会直接接触和编码BeanFactory，我们通常会使用另外一个功能更强、更完善的容器ApplicationContext。本文粗略讲述了ApplicationContext对于BeanFactory的功能扩展，并将重点放在了Spring在容器启动和初始化过程中提供的扩展点和事件发布上。扩展点让我们能够“插手和干预”Bean的初始化，通过容器发布的事件得以了解容器的一些内部过程。

## ApplicationContext的功能扩展 ##

ApplicationContext是“事实上”的容器标准，它基于BeanFactory并对其做了一些功能上的扩展。例如：

*  通过MessageResource支持国际化
 *  提供了容器内部的消息发布机制
 *  自动添加BeanFactoryPostProcessor、BeanPostProcessor到容器中  
    等。  
    由于ApplicationContext对于BeanFactory的扩展不是本文阐述的重点，所以略过。

## Spring容器初始化中的扩展点 ##

Spring容器初始化中的扩展点不仅包括了Beanfactory提供的也包含了ApplictionContext增强的。

从前面几篇关于容器初始化的文章可以得出，从xml到实例化并初始化完bean大体上经历了两个过程：

*  容器启动过程：这个过程包括了读取xml文件，并替换一些系统或者自定义变量，将xml标签解析成BeanDefinitionwrapper。
 *  容器初始化过程：这个过程包括了解析BeanDefinition中包含的Bean信息，完成Bean的实例化(Instantiation)和初始化(Initialization)过程。

而ApplicationContext将容器启动和初始化过程细化成了一些模板函数，构成以下步骤。

public void refresh() throws BeansException, IllegalStateException {
            synchronized (this.startupShutdownMonitor) {
                // Prepare this context for refreshing.
                prepareRefresh();
    
                // Tell the subclass to refresh the internal bean factory.
                ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
                // Prepare the bean factory for use in this context.
                prepareBeanFactory(beanFactory);
    
                try {
                    // Allows post-processing of the bean factory in context subclasses.
                    postProcessBeanFactory(beanFactory);
    
                    // Invoke factory processors registered as beans in the context.
                    invokeBeanFactoryPostProcessors(beanFactory);
    
                    // Register bean processors that intercept bean creation.
                    registerBeanPostProcessors(beanFactory);
    
                    // Initialize message source for this context.
                    initMessageSource();
    
                    // Initialize event multicaster for this context.
                    initApplicationEventMulticaster();
    
                    // Initialize other special beans in specific context subclasses.
                    onRefresh();
    
                    // Check for listener beans and register them.
                    registerListeners();
    
                    // Instantiate all remaining (non-lazy-init) singletons.
                    finishBeanFactoryInitialization(beanFactory);
    
                    // Last step: publish corresponding event.
                    finishRefresh();
                }
    
                catch (BeansException ex) {
                    // Destroy already created singletons to avoid dangling resources.
                    destroyBeans();
    
                    // Reset 'active' flag.
                    cancelRefresh(ex);
    
                    // Propagate exception to caller.
                    throw ex;
                }
            }
        }

整个过程及其中的扩展点可以表示成下图：

![format_png][]

容器启动及初始化过程.jpg

图中表示出了Spring容器中设计到的很多扩展点，主要可以分为以下几类：

*  BeanFactoryPostProcessor
 *  各种Aware
 *  BeanPostProcessor
 *  隐藏的一些特殊功能  
    下文将一项一项地进行梳理

### BeanFactoryPostProcessor ###

简介

BeanFactoryPostProcessor是一个很重要的接口，其中只有一个方法

void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

它起作用的时机发生在解析成BeanDefinition后，实例化之前。从名字可以看出来，BeanFactoryPostProcessor针对的应该是容器级别的扩展，名为“BeanFactory PostProcessor”即对容器中所有的BeanDefinition都起普遍作用。BeanFactoryPostProcessor有几个我们比较常用的子类PropertyPlaceholderConfigurer、CustomEditorConfigurer，前者用于配置文件中的$\{var\}变量替换，后者用于自定义编辑BeanDefinition中的属性值，合理利用CustomEditorConfigurer会有一些意想不到的效果（例如可以通过修改某些属性实现类似aop的功能）。

使用

如果是在BeanFactory中使用，我们需要

PropertyPlaceholderConfigurer  configurer = new PropertyPlaceholderConfigurer();
    configurer.setLaction("xxx");
    configurer.postProcessBeanFactory(beanFactory);

很繁琐，很麻烦，而且通常我们并不喜欢硬编码直接使用BeanFactory。在ApplicationContext中得到了改善，使用BeanFactoryPostProcessor只需要在xml文件中进行相应的配置就行，因为ApplicationContext在初始化过程中会调用invokeBeanFactoryPostProcessors(beanFactory)，该函数会找出所有BeanFactoryPostProcessor类型的bean，调用postProcessBeanFactory方法。

### BeanPostProcessor ###

简介

BeanPostProcessor很容易和BeanFactoryPostProcessor混淆，但从名字上来说，BeanPostProcessor是“Bean PostProcessor”，主要针对于Bean这一级别，关注的主要是Bean实例化后，初始化前后的。为什么说主要呢？因为存在特例，有一个BeanPostProcessor的调用并不是发生在实例化后，初始化前后。BeanPostProcessor接口存在两个方法，从名字可以看粗一个调用在初始化之前，一个调用在初始化之后。

Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
        Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

BeanPostProcessor在BeanFactory的初始化bean的函数initializeBean中，主要代码为，基本就是取出所有的BeanPostProcessor，然后遍历调用其postProcessBeforeInitialization或者postProcessAfterInitialization方法。

if (mbd == null || !mbd.isSynthetic()) {
                wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
            }
         try {
                invokeInitMethods(beanName, wrappedBean, mbd);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(
                        (mbd != null ? mbd.getResourceDescription() : null),
                        beanName, "Invocation of init method failed", ex);
            }
          if (mbd == null || !mbd.isSynthetic()) {
                wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
            }
    
      public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
                throws BeansException {
           Object result = existingBean;
            for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
                result = beanProcessor.postProcessBeforeInitialization(result, beanName);
                if (result == null) {
                    return result;
                }
            }
            return result;
        }

使用

Spring利用BeanPostProcessor给了我们在bean初始化前后“doSomething”的机会。  
在BeanFactory中使用需要编码

beanFactory.addBeanPostProcessor(new SomeBeanPostProcessor);

但是在ApplicationContext中，我们只需要将自定义的BeanPostProcessor配置到xml文件中即可。ApplicationContext在初始化过程中会识别所有的BeanPostProcessors并添加到BeanFactory中。

### 各种Aware ###

简介

这种类型的扩展点是我们比较熟悉的了，例如ApplicationContextAware、BeanFactoryAware等，Aware的接口用于标识“我需要这个对象”，例如ApplicationContextAware通知容器我需要“当前的ApplicationContext对象”。这个Spring给我们提供的一种用于获取有用对象的一种好的方式。

### 使用 ###

需要注意的是，Aware起作用的时机是在Bean已经完成实例化之后，初始化Bean的同时。而且需要注意的是BeanFactory对于Aware的处理和ApplicationContext是不同的。

先看BeanFactory中的处理方式，各种Aware被调用的地方是在初始化bean的函数  
initializeBean中

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    public Object run() {
                        invokeAwareMethods(beanName, bean);
                        return null;
                    }
                }, getAccessControlContext());
            }
            else {
                invokeAwareMethods(beanName, bean);
            }
    
            Object wrappedBean = bean;
            if (mbd == null || !mbd.isSynthetic()) {
                wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
            }
    
            try {
                invokeInitMethods(beanName, wrappedBean, mbd);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(
                        (mbd != null ? mbd.getResourceDescription() : null),
                        beanName, "Invocation of init method failed", ex);
            }
    
            if (mbd == null || !mbd.isSynthetic()) {
                wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
            }
            return wrappedBean;
        }
    
        private void invokeAwareMethods(final String beanName, final Object bean) {
            if (bean instanceof Aware) {
                if (bean instanceof BeanNameAware) {
                    ((BeanNameAware) bean).setBeanName(beanName);
                }
                if (bean instanceof BeanClassLoaderAware) {
                    ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
                }
                if (bean instanceof BeanFactoryAware) {
                    ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
                }
            }
        }

可以看到其发生在invokeInitMethods之前。而ApplicationContext怎么处理呢？ApplicationContext本身是利用BeanFactory进行容器的初始化，而BeanFactory却硬编码了invokeAwareMethods中Aware的类型，那ApplicationContext究竟是怎么调用ApplicationContextAware的呢，答案就在函数prepareBeanFactory中，

beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

ApplicationContext为beanFactory增加了ApplicationContextAwareProcessor，ApplicationContextAwareProcessor是一种BeanPostProcessor。前文提到BeanPostProcessor发生在bean初始化前后，在bean初始化之前将调用postProcessBeforeInitialization方法，ApplicationContextAwareProcessor\#postProcessBeforeInitialization如下：

public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
            AccessControlContext acc = null;
    
            if (System.getSecurityManager() != null &&
                    (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
                            bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
                            bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
                acc = this.applicationContext.getBeanFactory().getAccessControlContext();
            }
    
            if (acc != null) {
                AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    public Object run() {
                        invokeAwareInterfaces(bean);
                        return null;
                    }
                }, acc);
            }
            else {
                invokeAwareInterfaces(bean);
            }
    
            return bean;
        }
    
        private void invokeAwareInterfaces(Object bean) {
            if (bean instanceof Aware) {
                if (bean instanceof EnvironmentAware) {
                    ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
                }
                if (bean instanceof EmbeddedValueResolverAware) {
                    ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(
                            new EmbeddedValueResolver(this.applicationContext.getBeanFactory()));
                }
                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);
                }
            }
        }

可以看出ApplicationContext利用ApplicationContextAwareProcessor完成了ApplicationContext中特有的一些Aware的调用，发生的时机在初bean始化之前。

### 一种特殊的BeanPostProcessor-InstantiationAwareBeanPostProcessor ###

前文提到BeanPostProcessor主要作用于Bean实例化后，初始化前后，但是存在特例，InstantiationAwareBeanPostProcessor就是特例，其发生在Bean实例化前，  
在真正调用doCreate()创建bean实例化之前，调用了resolveBeforeInstantiation进行了短路操作，如果此方法返回值不为空则直接返回bean。spring注释“Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. ”给BeanPostProcessors一个机会返回代理proxy对象。

try {   
    // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.  
     Object bean = resolveBeforeInstantiation(beanName, mbd); 
      if (bean != null) {
          return bean;
       }
    }
    
    
    
        protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
            Object bean = null;
            if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
                // Make sure bean class is actually resolved at this point.
                if (mbd.hasBeanClass() && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
                    bean = applyBeanPostProcessorsBeforeInstantiation(mbd.getBeanClass(), beanName);
                    if (bean != null) {
                        bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }
                }
                mbd.beforeInstantiationResolved = (bean != null);
            }
            return bean;
        }

我们熟知的AOP，对target对象进行代理就是实现了InstantiationAwareBeanPostProcessor接口，在Bean实例化之前短路操作返回代理Proxy对象。

### ApplicationContext的事件发布 ###

\--待续

### 总结 ###

本文总结了Spring容器中几种使用较多的扩展机制，Spring作为一个设计良好的框架，遵循了“对修改封闭，对扩展开放”的原则，我们可以根据自己的实际需要来自定义BeanFactoryPostProcessor,BeanPostProcessor来在bean的生命周期里doSomething,实现各种Aware接口拿到容器中提供的一些有用对象，通过自定义监听器监听容器的事件等。

[https_www.jianshu.com_p_2692bf784976]: https://www.jianshu.com/p/2692bf784976
[format_png]: /images/20210527/1409f57bd25045b2853c27eb0df3826d.png