IOC之深入分析Aware接口

/**
 * 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 {

}

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) {
      ClassLoader bcl = getBeanClassLoader();
      if (bcl != null) {
        ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
      }
    }
    if (bean instanceof BeanFactoryAware) {
      ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
    }
  }
}

public interface BeanClassLoaderAware extends Aware {

 /**
  * 将 BeanClassLoader 提供给 bean 实例回调
  * 在 bean 属性填充之后、初始化回调之前回调，
  * 例如InitializingBean的InitializingBean.afterPropertiesSet（）方法或自定义init方法
  */
 void setBeanClassLoader(ClassLoader classLoader);
}

public interface BeanFactoryAware extends Aware {
    /**
  * 将 BeanFactory 提供给 bean 实例回调
  * 调用时机和 setBeanClassLoader 一样
  */
 void setBeanFactory(BeanFactory beanFactory) throws BeansException;
}

public interface BeanNameAware extends Aware {
 /**
  * 在创建此 bean 的 bean工厂中设置 beanName
  */
 void setBeanName(String name);
}

public interface ApplicationContextAware extends Aware {
 /**
  * 设置此 bean 对象的 ApplicationContext，通常，该方法用于初始化对象
  */
 void setApplicationContext(ApplicationContext applicationContext) throws BeansException;

}

public class MyApplicationAware implements BeanNameAware,BeanFactoryAware,BeanClassLoaderAware,ApplicationContextAware{

    private String beanName;

    private BeanFactory beanFactory;

    private ClassLoader classLoader;

    private ApplicationContext applicationContext;

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("调用了 BeanClassLoaderAware 的 setBeanClassLoader 方法");

        this.classLoader = classLoader;
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("调用了 BeanFactoryAware 的 setBeanFactory 方法");

        this.beanFactory = beanFactory;
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("调用了 BeanNameAware 的 setBeanName 方法");

        this.beanName = name;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) 
      throws BeansException {
        System.out.println("调用了 ApplicationContextAware 的 setApplicationContext 方法");

        this.applicationContext = applicationContext;
    }

    public void display(){
        System.out.println("beanName:" + beanName);

        System.out.println("是否为单例：" + beanFactory.isSingleton(beanName));

        System.out.println("系统环境为：" + applicationContext.getEnvironment());
    }
}

public static void main(String[] args) {
  ClassPathResource resource = new ClassPathResource("spring.xml");
  DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
  XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
  reader.loadBeanDefinitions(resource);

  MyApplicationAware applicationAware = (MyApplicationAware) factory.getBean("myApplicationAware");
  applicationAware.display();
}

public static void main(String[] args) {
  ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
  MyApplicationAware applicationAware = 
    (MyApplicationAware) applicationContext.getBean("myApplicationAware");
  applicationAware.display();
}