ApplicationContextAware接口

一、ApplicationContextAware接口的基本介绍

public interface ApplicationContextAware extends Aware {
	void setApplicationContext(ApplicationContext applicationContext) throws BeansException;

}

在Spring/SpringMVC中，我们拿到IOC容器无非有三种方式，那就是使用ApplicationContext接口下的三个实现类：ClassPathXmlApplicationContext、FileSystemXmlApplicationContext、AnnotationConfigApplicationContext。
但是SpringBoot的强大让我们无需再配置xml文件，也因此我们无法通过上述方式拿到ApplicationContext对象，所以当在项目需要用到spring中的bean对象时，一般做法就是实现ApplicationContextAware接口，通过这个接口就可以获取到ApplicationContext对象，进入从ApplicationContext中获取所需要bean对象。

二、 场景

举一个简单地例子，qq和微信登录。
简单写个枚举类：

public enum LoginTypeEnum {
    WX_LOGIN("微信登录"),
    QQ_LOGIN("QQ登录");
    private final String  description;
    LoginTypeEnum(String description) {
        this.description = description;
    }
}

这里用了一个工厂模式，写一个

public interface LoginService {
    /**
     * 获取登录类型
     * @return
     */
    LoginTypeEnum getLoginType();

    /**
     * 真正登录的逻辑
     * @return
     */
    Response login();
}


//-----------------这里是使用实现类的实现方法返回的枚举类型来判断该实现类
@Service
public class QQLoginServiceImpl implements LoginService {
    @Override
    public LoginTypeEnum getLoginType() {
        return LoginTypeEnum.QQ_LOGIN;
    }

    @Override
    public Response login() {
        
        return Response.success("QQ登录成功");
    }
}

@Service
public class WxLoginServiceImpl  implements LoginService{
    @Override
    public LoginTypeEnum getLoginType() {
        return LoginTypeEnum.WX_LOGIN;
    }

    @Override
    public Response login() {
         return Response.success("微信登录成功");
    }
}
//------------------------------

下面代码就是我们就创建了这个login类的工厂，实现ApplicationContextAware接口，然后通过setApplicationContext获取到的容器把所有的登录实现类取出来放进map里

/**
 * 登录工厂
 */
@Component
public class LoginFactory implements ApplicationContextAware {
    private static final Map<LoginTypeEnum,LoginService> LOGIN_SERVICE_MAP = new EnumMap<LoginTypeEnum,LoginService>(LoginTypeEnum.class);

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        //获取bean
        Map<String, LoginService> loginService = applicationContext.getBeansOfType(LoginService.class);
        //将实现LoginService接口的bean放进map中
        loginService.values().forEach(login -> LOGIN_SERVICE_MAP.putIfAbsent(login.getLoginType(), login));
    }

    /**
     * 用户登录
     * @param loginTypeEnum
     * @return
     */
    public LoginService login(LoginTypeEnum loginTypeEnum){
        return LOGIN_SERVICE_MAP.get(loginTypeEnum);
    }
}

@RestController
public class LoginController {

    @Resource
    private LoginFactory loginFactory;
    @RequestMapping(
            path = "/{loginType}/login",
            method = {RequestMethod.POST, RequestMethod.GET}
    )
    public Response login(HttpServletRequest httpRequest, HttpServletResponse httpServletResponse, @PathVariable String loginType){
        
       if(loginType.equals("wx")){
           return loginFactory.login(LoginTypeEnum.WX_LOGIN).login();
       }else if(loginType.equals("qq")){
           return loginFactory.login(LoginTypeEnum.QQ_LOGIN).login();
       }
        return Response.failed();
    }
}

三、源码分析

不论是spring，还是springboot， AbstractApplicationContext#refresh 方法都是 IOC 容器启动时最核心的方法。
bean初始化时各个扩展点的执行顺序。
在bean初始化方法AbstractAutowireCapableBeanFactory#initializeBean()中，可以看出执行顺序是：

• 先调用bean的构造函数
• 再调用set方法
• 再调用beanPostProcessorsBeforeInitialization
• 调用init-method
• 调用beanPostProcessorsAfterInitialization

	@Override
public void refresh() throws BeansException, IllegalStateException {
   // 来个锁，不然 refresh() 还没结束，你又来个启动或销毁容器的操作，那不就乱套了嘛
   synchronized (this.startupShutdownMonitor) {

      // 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
      prepareRefresh();

      // 这步比较关键，这步完成后，配置文件就会解析成一个个 Bean 定义，注册到 BeanFactory 中，
      // 当然，这里说的 Bean 还没有初始化，只是配置信息都提取出来了，
      // 注册也只是将这些信息都保存到了注册中心(说到底核心是一个 beanName-> beanDefinition 的 map)
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
      // 这块待会会展开说
      prepareBeanFactory(beanFactory);

      try {
         // 【这里需要知道 BeanFactoryPostProcessor 这个知识点，Bean 如果实现了此接口，
         // 那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。】

         // 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化
         // 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
         postProcessBeanFactory(beanFactory);
         // 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法
         invokeBeanFactoryPostProcessors(beanFactory);

         // 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
         // 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
         // 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化
         registerBeanPostProcessors(beanFactory);

         // 初始化当前 ApplicationContext 的 MessageSource，国际化这里就不展开说了，不然没完没了了
         initMessageSource();

         // 初始化当前 ApplicationContext 的事件广播器，这里也不展开了
         initApplicationEventMulticaster();

         // 从方法名就可以知道，典型的模板方法(钩子方法)，
         // 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
         onRefresh();

         // 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过
         registerListeners();

         // 重点，重点，重点
         // 初始化所有的 singleton beans
         //（lazy-init 的除外）
         finishBeanFactoryInitialization(beanFactory);

         // 最后，广播事件，ApplicationContext 初始化完成
         finishRefresh();
      }

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }

         // Destroy already created singletons to avoid dangling resources.
         // 销毁已经初始化的 singleton 的 Beans，以免有些 bean 会一直占用资源
         destroyBeans();

         // Reset 'active' flag.
         cancelRefresh(ex);

         // 把异常往外抛
         throw ex;
      }

      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}

其中，prepareBeanFactory()方法中，可以看到，将ApplicationContextAwareProcessor加到BeanPostProcessor中了。

再看一下ApplicationContextAwareProcessor，它实现了BeanPostProcessor接口，覆写了postProcessBeforeInitialization()方法，在方法里面，如果发现bean是ApplicationContextAware类型，就调用setApplicationContext()方法。