spring源码：Aware接口（li）

一、spring容器中的aware接口介绍

　　Spring中提供了各种Aware接口，比较常见的如BeanFactoryAware,BeanNameAware,ApplicationContextAware,BeanClassLoaderAware等，方便从上下文中获取当前的运行环境。我们先从使用的角度来说明aware接口的使用方式，举例如我们想得到当前的BeanFactory，我们可以让我们的实现类继承BeanFactoryAware接口，然后通过接口注入的方式得到当前容器中的BeanFactory：

public class Fruit implements BeanFactoryAware {
    private BeanFactory beanFactory;
 
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }
}

我们的Fruit类实现了aware接口，如果我们直接在应用中new一个Fruit的对象，当然是拿不到beanFactory变量的，我们必须在spring的配置文件中声明我们的fruit对象才行，也就是说fruit对象必须交给容器进行管理，容器帮你把各种aware接口中想要注入的对象设置到bean中。具体看容器管理aware接口的代码实现，代码在AbstractAutowireCapableBeanFactory的initializeBean方法中：

protected Object initializeBean(String beanName, Object bean, RootBeanDefinition mbd) {
    // 判断对象实现的接口类型，处理特定的三种接口类型：BeanNameAware、BeanClassLoaderAware和BeanFactoryAware。
    if (bean instanceof BeanNameAware) {
        ((BeanNameAware) bean).setBeanName(beanName);
    }
 
    if (bean instanceof BeanClassLoaderAware) {
        ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
    }
 
    if (bean instanceof BeanFactoryAware) {
        ((BeanFactoryAware) bean).setBeanFactory(this);
    }
    // 开始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;
}

可以看出来，aware接口的各种处理是在属性设置完成之后、bean初始化之前完成的。显然的，如果我们直接new出来一个bean，这些框架性的特性是没有使用到的。除了BeanFactoryAware、BeanNameAware、BeanClassLoaderAware之外的那些aware接口，比如ApplicationContextAware，再比如Webx中的自定义aware接口，它们又是怎么做到接口注入的呢？原来在应用中创建上下文容器时会注册一个BeanPostProcessor------ApplicationContextAwareProcessor，在这个类里面进行了context的注入，这样我们就能能够拿到bean中的context对象：

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    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);
    }
    return bean;
}

那么容器是在什么时候把ApplicationContextAwareProcessor的对象注册到context的BeanPostProcessor列表中的呢，奥秘在org.springframework.context.support.AbstractApplicationContext.prepareBeanFactory(ConfigurableListableBeanFactory)方法中：

// Tell the internal bean factory to use the context's class loader.
beanFactory.setBeanClassLoader(getClassLoader());
 
// Populate the bean factory with context-specific resource editors.
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this));
 
// Configure the bean factory with context callbacks.
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); //在这里注册了我们想要的BeanPostProcessor
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

二、了解webx中实现的aware接口

　　我们了解了aware的实现原理，我们就可以自己来实现自己的aware接口了。Webx就是这么做的（webx本身作为一个容器，本身注册了各类aware接口的BeanPostProcessor），比如我们想要感知到当前环境是否是生产模式，我们只需要实现ProductionModeAware接口就能够获得生产模式的值了。我们使用aware接口感觉很神奇很简便，原因是很多工作框架已经帮我们做了。webx中使用ProductionModeAwarePostProcessor这个BeanPostProcessor来进行生产模式的注入。在postProcessBeforeInitialization方法中：

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    if (bean instanceof ProductionModeAware) {
        ((ProductionModeAware) bean).setProductionMode(configuration.isProductionMode());
    }
 
    return bean;
}

所以任何实现了ProductionModeAware接口的类，在webx容器中都能够获得生产模式的取值。

三、自定义aware接口实现

　　了解了个中原理，那么自定义aware接口实现起来并不复杂。我们只需要2步操作：1.实现我们aware接口的postprocessor，并在容器中注册；2.bean实体类集成我们自定义的aware接口并实现。代码如下：Aware接口比较简单，就做一件事情，把Apple对象注入。

public interface AppleAware {
    void setApple(Apple a);
}

我们的BeanPostProcessor会检查是否是AppleAware接口，因为注册到容器的BeanPostProcessor会对每一个bean都做一次扫描：

public class AppleAwarePostProcessor implements BeanPostProcessor {
 
    private Apple a;
 
    public AppleAwarePostProcessor(Apple a) {
        this.a = a;
    }
 
    /* (non-Javadoc)
     * @see org.springframework.beans.factory.config.BeanPostProcessor#postProcessBeforeInitialization(java.lang.Object, java.lang.String)
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if(bean instanceof AppleAware) {
            ((AppleAware) bean).setApple(a);
        }
        return bean;
    }
 
    /* (non-Javadoc)
     * @see org.springframework.beans.factory.config.BeanPostProcessor#postProcessAfterInitialization(java.lang.Object, java.lang.String)
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // TODO Auto-generated method stub
        return bean;
    }
 
}

实体类Market实现了AppleAware接口，能够得到Apple对象的注入：

public class Market implements AppleAware {
 
    private Apple a;
 
    @Override
    public void setApple(Apple a) {
         this.a = a;
    }
 
    public String getName() {
        return a.getName();
    }
 
}

最后是我们的测试类，一定要把我们的BeanPostProcessor加入到当前容器中，这一点非常重要：

public class TestAware {
    public static void main(String args[]) {
        ConfigurableBeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
        BeanPostProcessor bpp = new AppleAwarePostProcessor((Apple)beanFactory.getBean("apple"));
    // 工厂对象中加入我们自定义的BeanPostProcessor
        beanFactory.addBeanPostProcessor(bpp);
        Market market = (Market) beanFactory.getBean("market");
        System.out.println(market.getName());
    }
}

四、