ApplicationContextAware详解

一、进入正题

Aware转义就是”主动的”，顾名思义spring给咱们主动做了些事件。spring有很多以Aware结尾的类，有EnvironmentAware、ApplicationContextAware、MessageSourceAware等。

这里我次要讲一下ApplicationContextAware。

如下文援用，ApplicationContextAware的文档能够浏览 Spring Core Technologies 1.4.6 Method Injection 、Spring Core Technologies 1.6.2. ApplicationContextAware and BeanNameAware、办法注入

概括一下，就是：

在大多数应用程序场景中，容器中的大多数bean都是单例的。当一个单例bean须要与另一个单例bean合作，或者一个非单例bean须要与另一个非单例bean合作时，通常通过将一个bean定义为另一个bean的属性来解决依赖关系。当bean的生命周期不同时，就会呈现问题。假如单例bean A须要应用非单例(原型)bean B，可能是在A的每个办法调用上。容器只创立单例bean A一次，因而只有一次机会设置属性。容器不能在每次须要bean A时都向bean A提供一个新的bean B实例。

一个解决方案是放弃一些管制反转。您能够通过实现ApplicationContextAware接口，以及在bean A每次须要bean B实例时对容器进行getBean(“B”)调用，从而使bean A aware(主动获取到) 容器。

二、应用

@Service("gatewayService")
public class GatewayServiceImpl implements IGatewayService，ApplicationContextAware {

    Map<ServiceBeanEnum，IGatewayBo> chargeHandlerMap=new HashMap<ServiceBeanEnum，IGatewayBo>();

    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext=applicationContext;
    }
}

在咱们须要应用ApplicationContext的服务中实现ApplicationContextAware接口，系统启动时就能够主动给咱们的服务注入applicationContext对象，咱们就能够获取到ApplicationContext里的所有信息了。

三、原理剖析

咱们都晓得spring的入口办法就在AbstractApplicationContext的refresh()办法，咱们先去看看refresh().prepareBeanFactory()办法。

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // Tell the internal bean factory to use the context's class loader etc.
        beanFactory.setBeanClassLoader(getClassLoader());
        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this， getEnvironment()));

        // 增加ApplicationContextAware的处理器
        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
        beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
        beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
        beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
        beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
                ...
    }

也就是说，spring在启动的时候给咱们增加了ApplicationContextAwareProcessor这样一个processor，进去看看它的实现:

@Override
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((PrivilegedAction)() -> {
            //外围办法，调用aware接口办法
            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(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);
        }
        //针对实现了ApplicationContextAware的接口，spring都将调用其setApplicationContext，将applicationContext注入到以后bean对象。
        if (bean instanceof ApplicationContextAware) {
            ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
        }
    }
}

那ApplicationContextAwareProcessor又是什么时候调用的呢？咱们接着往下看，原来refresh()办法中还有个beanFactory.preInstantiateSingletons()办法，外面有这样一段代码:

拿到所有的beanNames，而后顺次判断是否须要加载，如果是，则调用getBean(beanName)办法实例化进去。
// 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)) {
                final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                boolean isEagerInit;
                if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                    isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
                        @Override
                        public Boolean run() {
                            return ((SmartFactoryBean<?>) factory).isEagerInit();
                        }
                    }， getAccessControlContext());
                }
                else {
                    isEagerInit = (factory instanceof SmartFactoryBean &&
                                   ((SmartFactoryBean<?>) factory).isEagerInit());
                }
                if (isEagerInit) {
                    getBean(beanName);
                }
            }
            else {
                getBean(beanName);
            }
        }
    }

顺次查看getBean() ->doGetBean()->createBean()->doCreateBean()办法:

// Initialize the bean instance.
Object exposedObject = bean;
try {
    populateBean(beanName， mbd， instanceWrapper);
    if (exposedObject != null) {
        exposedObject = initializeBean(beanName， exposedObject， mbd);
    }
} catch (Throwable ex) {
    if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
        throw (BeanCreationException) ex;
    } else {
        throw new BeanCreationException(
            mbd.getResourceDescription()， beanName， "Initialization of bean failed"， ex);
    }
}

查看一下initializeBean办法:

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged(() -> {
            this.invokeAwareMethods(beanName, bean);
            return null;
        }, this.getAccessControlContext());
    } else {
        //调用setBeanName() 、setBeanClassLoaderAware、setBeanFactoryAware办法
        this.invokeAwareMethods(beanName, bean);
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
    }

    try {
        //调用afterPropertiesSet()办法
        this.invokeInitMethods(beanName, wrappedBean, mbd);
    } catch (Throwable var6) {
        throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
    }
    //这里才是ApplicationContextProcessor的postProcessAfterInitialization()执行入口:
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

原来AbstractAutowireCapableBeanFactory中的inititalBean()办法就是BeanPostProcessor的调用处。然而像BeanNameAware、BeanFactoryAware不同，是通过initialBean()中的invokeAwareMethods间接调用实现的

四、样例

import org.springframework.beans.factory.BeanFactoryUtils;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

import java.util.Map;

/**
 * 通过Spring上下文获取bean工具类
 *
 * @author moon
 */
public class SpringContextUtils implements ApplicationContextAware {

    /**
     * Spring利用上下文环境
     */
    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        SpringContextUtils.initSpringContext(applicationContext);
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) {
        return (T) applicationContext.getBean(name);
    }

    public static <T> T getBean(Class<T> clazz) {
        return applicationContext.getBean(clazz);
    }

    public static boolean isSingleton(String name) {
        return applicationContext.isSingleton(name);
    }

    /**
     * 依据class对象返回IOC容器中其对象和其子类的对象。
     * 未找到则返回空MAP。
     * KEY为BEAN ID或者NAME，VALUE为BEAN实例
     *
     * @param type 须要找的bean类型的CLASS对象
     * @return bean映射
     */
    public static <T> Map<String, T> getBeansByType(Class<T> type) {
        return BeanFactoryUtils.beansOfTypeIncludingAncestors(SpringContextUtils.getApplicationContext(), type);
    }

    /**
     * 初始化ApplicationContext
     *
     * @param applicationContext 上下文
     */
    public static void initSpringContext(ApplicationContext applicationContext) {
        SpringContextUtils.applicationContext = applicationContext;
    }

    /**
     * 获取业务线（业务线配置在配置文件中）
     *
     * @return 业务线
     */
    public static String getProjectBusinessLine() {
        if (applicationContext == null) {
            throw new RuntimeException("spring初始化失败");
        }
        return applicationContext.getEnvironment().getProperty("***.application.businessLine");
    }

    /**
     * 获取项目名称（项目名称配置在配置文件中）
     *
     * @return 项目名称
     */
    public static String getProjectName() {
        if (applicationContext == null) {
            throw new RuntimeException("spring初始化失败");
        }
        return applicationContext.getEnvironment().getProperty("***.application.name");
    }
}