一、前言

Springboot源码解析是一件大工程，逐行逐句的去研究代码，会很枯燥，也不容易坚持下去。
我们不追求大而全，而是试着每次去研究一个小知识点，最终聚沙成塔，这就是我们的springboot源码管中窥豹系列。

二、ApplicationContextAware

假设我们想使用某个bean, 如果是在@Component类下面，直接用@Autowired引用就行了
假设我们想在某个静态方法里面用，就不能用上面的方法了
你可能想用new Bean()的方式，new一个，但是这个bean里面的@Autowired引用用不了
如果有一个静态的全局ApplicationContext就好了，用spring的能力获取bean: ApplicationContext.getBean(clazz)
ApplicationContextAware就是这个用处

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

我们写一个实现类：



import org.springframework.beans.BeansException;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;

import org.springframework.stereotype.Component;
@Component

public class SpringContextUtil implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override

public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

SpringContextUtil.applicationContext = applicationContext;

}
private static ApplicationContext getApplicationContext() {

return applicationContext;

}
public static <T> T getBean(Class<T> clazz){

return getApplicationContext().getBean(clazz);

}
}

通过setApplicationContext，把applicationContext赋值到本地静态变量
通过ApplicationContext的getBean就可以在静态方法中使用任何bean的能力了

三、源码分析

我们进入SpringApplication的run方法：

public ConfigurableApplicationContext run(String... args) {
...
try {
...
refreshContext(context);
...

}

catch (Throwable ex) {
...
}
...
return context;

}

我们进入refreshContext(context)内部：

public void refresh() throws BeansException, IllegalStateException {

synchronized (this.startupShutdownMonitor) {

// Prepare this context for refreshing.

prepareRefresh();
// Tell the subclass to refresh the internal bean factory.

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.

prepareBeanFactory(beanFactory);
try {

// Allows post-processing of the bean factory in context subclasses.

postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.

invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.

registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.

initMessageSource();
// Initialize event multicaster for this context.

initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.

onRefresh();
// Check for listener beans and register them.

registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.

finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.

finishRefresh();

}
catch (BeansException ex) {

if (logger.isWarnEnabled()) {

logger.warn("Exception encountered during context initialization - " +

"cancelling refresh attempt: " + ex);

}
destroyBeans();
cancelRefresh(ex);
throw ex;

}
finally {

resetCommonCaches();

}

}

}

这个refresh是spring的核心方法，以后会多次用到，内容太多，我们这次只关注一个方法：

prepareBeanFactory(beanFactory);

public void refresh() throws BeansException, IllegalStateException {

synchronized (this.startupShutdownMonitor) {

...
// Prepare the bean factory for use in this context.

prepareBeanFactory(beanFactory);
...

}

}

我们先看prepareBeanFactory(beanFactory)：

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
...
// Configure the bean factory with context callbacks.

beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
...
}

我们看一下这个addBeanPostProcessor方法



private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();
@Override

public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {

Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");

// Remove from old position, if any

this.beanPostProcessors.remove(beanPostProcessor);

// Track whether it is instantiation/destruction aware

if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {

this.hasInstantiationAwareBeanPostProcessors = true;

}

if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {

this.hasDestructionAwareBeanPostProcessors = true;

}

// Add to end of list

this.beanPostProcessors.add(beanPostProcessor);

}

先remove,再add
beanPostProcessors是一个线程安全的list: CopyOnWriteArrayList
我们往下看看new ApplicationContextAwareProcessor(this)，注意：this是ApplicationContext

class ApplicationContextAwareProcessor implements BeanPostProcessor {
private final ConfigurableApplicationContext applicationContext;
private final StringValueResolver embeddedValueResolver;
/**

* Create a new ApplicationContextAwareProcessor for the given context.

*/

public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {

this.applicationContext = applicationContext;

this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());

}
@Override

@Nullable

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||

bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||

bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){

return bean;

}
AccessControlContext acc = null;
if (System.getSecurityManager() != null) {

acc = this.applicationContext.getBeanFactory().getAccessControlContext();

}
if (acc != null) {

AccessController.doPrivileged((PrivilegedAction<Object>) () -> {

invokeAwareInterfaces(bean);

return null;

}, acc);

}

else {

invokeAwareInterfaces(bean);

}
return bean;

}
private void invokeAwareInterfaces(Object bean) {

if (bean instanceof EnvironmentAware) {

((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());

}

if (bean instanceof EmbeddedValueResolverAware) {

((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);

}

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);

}

}
}

构造方法，把applicationContext设到本地变量上
实现接口的方法：postProcessBeforeInitialization，回调的时候会用，主要是校验权限
最下面的invokeAwareInterfaces是个私有的核心回调方法，根据不同类型，有不同回调

我们看到除了ApplicationContextAware，还有其它的aware, 总共6个

EnvironmentAware：环境变量
EmbeddedValueResolverAware：值解析器
ResourceLoaderAware：资源加载器
ApplicationEventPublisherAware：事件发布器
MessageSourceAware：信息处理器
ApplicationContextAware：spring容器

比如我们想用全局的环境变量，就有EnvironmentAware，想用spring的事件就用ApplicationEventPublisherAware，等等

来源找到了，ApplicationContextAwareProcessor什么时候执行的呢？
这个比较麻烦，我们后面单开一节再详细的去看。

欢迎关注微信公众号：丰极，更多技术学习分享。

springboot源码解析-管中窥豹系列之aware（六）的更多相关文章

SpringBoot源码解析系列文章汇总
相信我,你会收藏这篇文章的本篇文章是这段时间撸出来的SpringBoot源码解析系列文章的汇总,当你使用SpringBoot不仅仅满足于基本使用时.或者出去面试被面试官虐了时.或者说想要深入了解一下 ...
【spring-boot 源码解析】spring-boot 依赖管理梳理图
在文章 [spring-boot 源码解析]spring-boot 依赖管理中,我梳理了 spring-boot-build.spring-boot-parent.spring-boot-depen ...
SpringBoot 源码解析（九）----- Spring Boot的核心能力 - 整合Mybatis
本篇我们在SpringBoot中整合Mybatis这个orm框架,毕竟分析一下其自动配置的源码,我们先来回顾一下以前Spring中是如何整合Mybatis的,大家可以看看我这篇文章Mybaits 源码 ...
SpringBoot 源码解析（二）----- Spring Boot精髓：启动流程源码分析
本文从源代码的角度来看看Spring Boot的启动过程到底是怎么样的,为何以往纷繁复杂的配置到如今可以这么简便. 入口类 @SpringBootApplication public class He ...
SpringBoot 源码解析（三）----- Spring Boot 精髓：启动时初始化数据
在我们用 springboot 搭建项目的时候,有时候会碰到在项目启动时初始化一些操作的需求 ,针对这种需求 spring boot为我们提供了以下几种方案供我们选择: ApplicationRunn ...
SpringBoot 源码解析（五）----- Spring Boot的核心能力 - 自动配置源码解析
在上一篇博客中分析了springBoot启动流程,大体的轮廓只是冰山一角.今天就来看一下springBoot的亮点功能:自动化装配功能. 先从@SpringBootApplication开始.在启动流 ...
SpringBoot 源码解析（八）----- Spring Boot 精髓：事务源码解析
本篇来讲一下SpringBoot是怎么自动开启事务的,我们先来回顾一下以前SSM中是如何使用事务的 SSM使用事务导入JDBC依赖包众所周知,凡是需要跟数据库打交道的,基本上都要添加jdbc的依赖 ...
SpringBoot 源码解析（十）----- Spring Boot的核心能力 - 集成AOP
本篇主要集成Sping一个重要功能AOP 我们还是先回顾一下以前Spring中是如何使用AOP的,大家可以看看我这篇文章spring5 源码深度解析----- AOP的使用及AOP自定义标签 Spri ...
【spring-boot 源码解析】spring-boot 依赖管理
关键词:spring-boot 依赖管理.spring-boot-dependencies.spring-boot-parent 问题 maven 工程,依赖管理是非常基本又非常重要的功能,现在的工程 ...
SpringBoot 源码解析（六）----- Spring Boot的核心能力 - 内置Servlet容器源码分析（Tomcat）
Spring Boot默认使用Tomcat作为嵌入式的Servlet容器,只要引入了spring-boot-start-web依赖,则默认是用Tomcat作为Servlet容器: <depend ...

随机推荐

Github上传自己的工程
1.注册并新建项目 2.配置github for windows 前题:安装相应的github for windows 2.1 获取密钥可以用命令的模式(Git bash),参考资料中有相应的用法: ...
tengine-2.1.0 + GraphicsMagick-1.3.20
export LUAJIT_LIB=/usr/local/libexport LUAJIT_INC=/usr/local/include/luajit-2.0/./configure --prefix ...
Codeforces 235C
题目大意: 给定一个字符串,接下来再给n个字符串,求原字符串中含有多少个当前给定字符串的循环同构体的字符串的个数以初始字符串构建后缀自动机,在自动机上前进的时候,比如当前需要匹配的字符串为aba,到 ...
java.util.zip.ZipOutputStream压缩无乱码（原创）
package io; import java.io.BufferedOutputStream; import java.io.BufferedReader; import java.io.FileI ...
手把手教你Windows下Go语言的环境搭建
1.想写GO语言首先得下载go语言的开发包官方下载地址:https://code.google.com/p/go/downloads/list 我用的是Win7 64位的操作系统,截图如下: 2.把 ...
IDL 实现PCA算法
在多元统计分析中,主成分分析(Principal components analysis,PCA)是一种分析.简化数据集的技术.主成分分析经常用于减少数据集的维数,同时保持数据集中的对方差贡献最大的特 ...
C++——Vector
#include "opencv2/objdetect.hpp" #include "opencv2/videoio.hpp" #include "o ...
adb shell 命令之----pm
常用的用法: 查看已经安装的包: pm list packages 查看已经安装的包以及apk路径(-3:只看第三方应用: -s:只看系统应用) -f: see their associated fi ...
(网页)Java程序员们最常犯的10个错误(转)
转自CSDN: 1.将数组转化为列表将数组转化为一个列表时,程序员们经常这样做: List<String> list = Arrays.asList(arr); Arrays.asLis ...
Codeforces 781D Axel and Marston in Bitland
题目链接:http://codeforces.com/contest/781/problem/D ${F[i][j][k][0,1]}$表示是否存在从${i-->j}$的路径走了${2^{k}} ...