一、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()方法。
