spring源码解读：aware接口

package org.springframework.beans.factory;/** * Marker superinterface indicating that a bean is eligible to be * notified by the Spring container of a particular framework object * through a callback-style method.  Actual method signature is * determined by individual subinterfaces, but should typically * consist of just one void-returning method that accepts a single * argument. * <p>Note that merely implementing {@link Aware} provides no default * functionality. Rather, processing must be done explicitly, for example * in a {@link org.springframework.beans.factory.config.BeanPostProcessor BeanPostProcessor}. * Refer to {@link org.springframework.context.support.ApplicationContextAwareProcessor} * and {@link org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory} * for examples of processing {@code *Aware} interface callbacks. * * @author Chris Beams * @since 3.1 */public interface Aware {}

作用是标记超类接口表名改bean 是一个有资格被spring容器通过回调通知的特定框架对象，实际方法签名由单个子接口确定，但通常应为只包含一个接受单个参数的void返回方法。如BeanNameAware；

package org.springframework.beans.factory;/** * Interface to be implemented by beans that want to be aware of their * bean name in a bean factory. Note that it is not usually recommended * that an object depend on its bean name, as this represents a potentially * brittle dependence on external configuration, as well as a possibly * unnecessary dependence on a Spring API. * * <p>For a list of all bean lifecycle methods, see the * {@link BeanFactory BeanFactory javadocs}. * * @author Juergen Hoeller * @author Chris Beams * @since 01.11.2003 * @see BeanClassLoaderAware * @see BeanFactoryAware * @see InitializingBean */public interface BeanNameAware extends Aware {/** * Set the name of the bean in the bean factory that created this bean. * <p>Invoked after population of normal bean properties but before an * init callback such as {@link InitializingBean#afterPropertiesSet()} * or a custom init-method. * @param name the name of the bean in the factory. * Note that this name is the actual bean name used in the factory, which may * differ from the originally specified name: in particular for inner bean * names, the actual bean name might have been made unique through appending * "#..." suffixes. Use the {@link BeanFactoryUtils#originalBeanName(String)} * method to extract the original bean name (without suffix), if desired. */void setBeanName(String name);

需要注意的是仅仅实现aware接口是不提供任何默认功能的。相反，处理必须明确地完成，如在一个BeanPostProcessor接口中，可以参考ApplicationContextAwareProcessor和AbstractAutowireCapableBeanFactory，对于接口处理回调的例子。

package org.springframework.beans.factory.config;import org.springframework.beans.BeansException;/** * Factory hook that allows for custom modification of new bean instances, * e.g. checking for marker interfaces or wrapping them with proxies. * * <p>ApplicationContexts can autodetect BeanPostProcessor beans in their * bean definitions and apply them to any beans subsequently created. * Plain bean factories allow for programmatic registration of post-processors, * applying to all beans created through this factory. * * <p>Typically, post-processors that populate beans via marker interfaces * or the like will implement {@link #postProcessBeforeInitialization}, * while post-processors that wrap beans with proxies will normally * implement {@link #postProcessAfterInitialization}. * * @author Juergen Hoeller * @since 10.10.2003 * @see InstantiationAwareBeanPostProcessor * @see DestructionAwareBeanPostProcessor * @see ConfigurableBeanFactory#addBeanPostProcessor * @see BeanFactoryPostProcessor */public interface BeanPostProcessor {/** * Apply this BeanPostProcessor to the given new bean instance <i>before</i> any bean * initialization callbacks (like InitializingBean's <code>afterPropertiesSet</code> * or a custom init-method). The bean will already be populated with property values. * The returned bean instance may be a wrapper around the original. * @param bean the new bean instance * @param beanName the name of the bean * @return the bean instance to use, either the original or a wrapped one; if * <code>null</code>, no subsequent BeanPostProcessors will be invoked * @throws org.springframework.beans.BeansException in case of errors * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet */Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;/** * Apply this BeanPostProcessor to the given new bean instance <i>after</i> any bean * initialization callbacks (like InitializingBean's <code>afterPropertiesSet</code> * or a custom init-method). The bean will already be populated with property values. * The returned bean instance may be a wrapper around the original. * <p>In case of a FactoryBean, this callback will be invoked for both the FactoryBean * instance and the objects created by the FactoryBean (as of Spring 2.0). The * post-processor can decide whether to apply to either the FactoryBean or created * objects or both through corresponding <code>bean instanceof FactoryBean</code> checks. * <p>This callback will also be invoked after a short-circuiting triggered by a * {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation} method, * in contrast to all other BeanPostProcessor callbacks. * @param bean the new bean instance * @param beanName the name of the bean * @return the bean instance to use, either the original or a wrapped one; if * <code>null</code>, no subsequent BeanPostProcessors will be invoked * @throws org.springframework.beans.BeansException in case of errors * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet * @see org.springframework.beans.factory.FactoryBean */Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;}

其继承关系

容器管理的Bean一般不需要了解容器的状态和直接使用容器，但是在某些情况下，是需要在Bean中直接对IOC容器进行操作的，这时候，就需要在Bean中设定对容器的感知。spring IOC容器也提供了该功能，它是通过特定的Aware接口来完成的。aware接口有以下这些：

BeanNameAware，可以在Bean中得到它在IOC容器中的Bean的实例的名字。

BeanFactoryAware，可以在Bean中得到Bean所在的IOC容器，从而直接在Bean中使用IOC容器的服务。

ApplicationContextAware，可以在Bean中得到Bean所在的应用上下文，从而直接在Bean中使用上下文的服务。

MessageSourceAware，在Bean中可以得到消息源。

ApplicationEventPublisherAware，在bean中可以得到应用上下文的事件发布器，从而可以在Bean中发布应用上下文的事件。

ResourceLoaderAware，在Bean中可以得到ResourceLoader，从而在bean中使用ResourceLoader加载外部对应的Resource资源。

在设置Bean的属性之后，调用初始化回调方法之前，Spring会调用aware接口中的setter方法。

下面给出一个例子：

定义一个实现BeanNameAware接口的类：

    package com.spring.aware;            import org.springframework.beans.factory.BeanNameAware;            /**       * <p>Class:LoggingBean</p>       * <p>Description:</p>       * @author Liam       * @Date [2012-9-7 上午9:23:12]       */      public class LoggingBean implements BeanNameAware {                private String name;                public void setBeanName(String name) {              this.name = name;          }                public void run() {              System.out.println("容器被感知--BeanNameAware:Bean name is'" + this.name + "'.>>"+name);          }      }  

在定义个实现BeanFactoryAware接口的类：

    package com.spring.aware;            import org.springframework.beans.BeansException;      import org.springframework.beans.factory.BeanFactory;      import org.springframework.beans.factory.BeanFactoryAware;      import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;      import org.springframework.beans.factory.support.DefaultListableBeanFactory;            /**       * <p>Class:ShutdownHookBean</p>       * <p>Description:</p>       * @author Liam       * @Date [2012-9-7 上午9:24:13]       */      public class BeanDestried implements BeanFactoryAware{                private ConfigurableListableBeanFactory beanFactory;                public void setBeanFactory(BeanFactory beanFactory) throws BeansException {              if (beanFactory instanceof DefaultListableBeanFactory) {                  this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;              }          }                public void run() {              if (this.beanFactory != null) {                  System.out.println("容器被感知--BeanFactory-Destroying singletons.>>"+beanFactory);                  this.beanFactory.destroySingletons();              }          }            }  

在applicationContext中配置好：

    <bean id="logging" class="com.spring.aware.LoggingBean"/>      <bean id="beanDestried" class="com.spring.aware.BeanDestried"/>  

测试类如下：

    package com.spring.aware;            import org.springframework.context.ApplicationContext;      import org.springframework.context.support.ClassPathXmlApplicationContext;            /**       * <p>Class:App</p>       * <p>Description:</p>       * @author Liam       * @Date [2012-9-7 上午9:13:36]       */      public class App {          public static void main(String[] args) throws Exception {              ApplicationContext factory = new ClassPathXmlApplicationContext("classpath:beans.xml");              LoggingBean lb = (LoggingBean) factory.getBean("logging");              lb.run();              BeanDestried sd = (BeanDestried)factory.getBean("beanDestried");              sd.run();          }      }  

测试结果如下：

容器被感知--BeanNameAware:Bean name is'logging'.>>logging容器被感知--BeanFactory-Destroying singletons.>>org.springframework.beans.factory.support.DefaultListableBeanFactory@a6cdf5: defining beans [logging,beanDestried]; root of factory hierarchy