前言
Spring为Java提供了强大的Bean管理，对于Bean的生命周期的了解还是有必要的。
以一个例子开始
我们以一个简单的例子，来分析一下Spring Bean的加载流程
public class AnnotationConfigContextDemo {
public static void main(String[] args) {
// 创建 BeanFactory 容器
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
// 注册 Configuration Class（配置类）
applicationContext.register(AnnotationConfigContextDemo.class);
// 启动 Spring 应用上下文
applicationContext.refresh();
// 依赖查找
InstanceA instanceA = (InstanceA) applicationContext.getBean("instanceA");
// 显示地关闭 Spring 应用上下文
applicationContext.close();
}
@Bean(initMethod = "init", destroyMethod = "instanceADestroy")
public InstanceA instanceA() {
return new InstanceA();
}
@Bean
public InstanceB instanceB() {
return new InstanceB();
}
@Bean
public MyBeanPostProcessor myBeanPostProcessor() {
return new MyBeanPostProcessor();
}
}
public class InstanceA implements BeanFactoryAware, BeanNameAware, InitializingBean, DisposableBean {
@Autowired
private InstanceB instanceB;
public InstanceB getInstanceB() {
return instanceB;
}
public void setInstanceB(InstanceB instanceB) {
System.out.println("set instance B");
this.instanceB = instanceB;
}
public void init() {
System.out.println("instance A init method");
}
public void instanceADestroy() {
System.out.println("instance A instanceADestroy method");
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("BeanFactoryAware#setBeanFactory()");
}
@Override
public void setBeanName(String name) {
System.out.println("BeanNameAware#setBeanName() - " + name);
}
@Override
public void destroy() throws Exception {
System.out.println("DisposableBean#destroy()");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("InitializingBean#afterPropertiesSet()");
}
}
public class InstanceB {
@Autowired
private InstanceA instanceA;
public InstanceA getInstanceA() {
return instanceA;
}
public void setInstanceA(InstanceA instanceA) {
this.instanceA = instanceA;
}
}
主要有3个类：InstanceA、InstanceB以及AnnotationConfigContextDemo，其中InstanceA和InstanceB互相依赖，AnnotationConfigContextDemo用于启动Spring容器测试。
执行AnnotationConfigContextDemo 的main()方法至applicationContext.refresh()开始启动Spring应用的上下文，经过一系列方法调用到达 org.springframework.beans.factory.support.AbstractBeanFactory#getBean() 方法：
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 1. 解析别名
final String beanName = transformedBeanName(name);
// 尝试依次从一二三级缓存中获取 bean，此处将与属性注入和循环依赖有关系，后面会做展开
Object sharedInstance = getSingleton(beanName);
// ...
// 2. 获取当前 Bean定义
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 3. 检查当前创建的 Bean定义是不是抽象的 Bean定义，是则抛出异常
checkMergedBeanDefinition(mbd, beanName, args);
// 4. 检查 depends-on属性
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
// ...
// 存在dependsOn属性，则转而先加载depends的 Bean
registerDependentBean(dep, beanName);
// ...
}
// ...
// 5. 创建单例 Bean
if (mbd.isSingleton()) {
// 把 beanName和 ObjectFactory作为参数传入
sharedInstance = getSingleton(beanName, () -> {
try {
// 创建 bean的逻辑
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
}
因为原方法过长，只保留了和创建 Bean关系较大的主流程代码。经过上面对org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean() 方法的分析得出目前已执行的步骤：
1）解析别名
2）获取当前的 BeanDefinition
3）检查当前创建的 Bean定义是不是抽象的 Bean定义，是则抛出异常
4）检查 depends-on属性
5）创建单例 Bean
到目前为止，是不是对Spring Bean的加载流程更清楚一点点，接下来我们将对第5个步骤，也就是单例Bean的创建展开。
image.png
// DefaultSingletonBeanRegistry#getSingleton()
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
synchronized (this.singletonObjects) {
// ...
try {
// 调用 singletonFactory 创建 bean
singletonObject = singletonFactory.getObject();
newSingleton = true;
} catch (IllegalStateException ex) {
// ...
}
// ...
}
可以看出，getSingleton()方法并没有创建 bean，而是通过调用 ObjectFactory.getObject()方法获得 bean实例。那么 singletonFactory对象从哪里来，回到上一个代码分析的第五个步骤，getSingleton()方法的第二个参数，一个包含 createBean()的lambda表达式。没错，绕了一圈又回来到 AbstractBeanFactory
image.png
// org.springframework.beans.factory.support.AbstractBeanFactory
protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException;
不过AbstractBeanFactory并没有实现该方法，而是交给了子类org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// ...
// 该步骤执行真正创建 Bean实例的过程
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
// ...
}
debug执行doCreateBean()这行，按照示例将返回一个InstanceA/InstanceB对象。接下来展开doCreateBean()方法：
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
BeanWrapper instanceWrapper = null;
// ...
if (instanceWrapper == null) {
// 1. 此处创建 Bean实例
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
// 2. 将包裹 Bean实例的 ObjectFactory对象加到 singletonFactories （三级缓存）
// 该缓存在解决循环依赖时会用到
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
// ...
// 3. 设置 Bean的属性值
populateBean(beanName, mbd, instanceWrapper);
// 4. 初始化 Bean
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
根据本文一开始的示例代码，InstanceA依赖于InstanceB，而InstanceB又依赖于InstanceA，是一个循环依赖的场景。
Spring是如何解决循环依赖的
在此之前先补充一下Spring Bean三级缓存：
// 一级缓存，Spring在创建完Bean，并且初始化完成时，会将Bean实例放到这里
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 二级缓存，存放Spring早期对象（一般由三级缓存升上来）
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
// 三级缓存，保存包裹这早期对象的 ObjectFactory
// 三级缓存的作用：从三级缓存获取对象时会执行 getEarlyBeanReference，里面涉及一些后置处理器，其中有对代理对象的处理
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
在执行到 populateBean()为 InstanceA实例的属性赋值的时候，因为是使用@Autowired注解注入，对应处理类AutowiredAnnotationBeanPostProcessor会为InstanceA对象注入InstanceB的实例，在调用 getBean() 方法获取 InstanceB实例时，发现 InstanceB实例不存在，则开始实例化InstanceB的流程，即将刚才InstanceA的创建流程走一遍，直到 InstanceB的populateBean()，因为InstanceB有属性InstanceA，这时又会调用getBean()方法获取 InstanceA的实例
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
/**
* 1. 尝试从一级缓存中获取 instanceA，但是此时instanceA实例还未放进该缓存中
* 此时 instanceA对象还卡在 populateBean()
*/
Object singletonObject = this.singletonObjects.get(beanName);
// 2. 以及缓存中没获取到对象，且 instanceA对象正在创建
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 3. 从二级缓存获取 instanceA，因为还未放入二级缓存，这时也为 null
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
// 4. 从三级缓存中获取对象，这时获取到了包裹 instanceA的 ObjectFactory对象
// instanceA的doCreateBean()方法调用了addSingletonFactory，将其放入三级缓存
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
// 5. 此时才放入二级缓存中，下次直接从二级缓存获取
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
经过上面的方法，InstanceB成功获取到了InstanceA的实例，完成populateBean()及其后面的初始化工作，此时终于可以衔接上一开始给instanceA实例的属性赋值的流程，instanceA从getBean("instanceB")获取到了instanceB的实例对象，解决了InstanceA和InstanceB的循环依赖问题。
循环依赖处理流程
initializeBean()方法
在populateBean()方法设置 bean 实例的属性后，将对 bean进行一些初始化操作，其中包括实现了Aware接口的方法，BeanPostProcessor接口方法，用户自定义init()方法等操作。
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
// ...
// 1. 执行 Bean实现的各种Aware接口方法
invokeAwareMethods(beanName, bean);
// ...
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 2. 调用BeanPostProcessors的 BeforeInitialization，从步骤在用户自定义的init方法执行之前
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
// ...
try {
// 3. 调用初始化方法，如 instanceA.init()方法
// InitializingBean.afterPropertiesSet()也在此调用，并且在instanceA.init()之前执行
invokeInitMethods(beanName, wrappedBean, mbd);
} catch (Throwable ex) {
// ...
}
// ...
// 4. 初始化完成后，执行BeanPostProcessor.postProcessAfterInitialization()
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
}
关闭Spring应用上下文
applicationContext.close();
执行close()方法后，将会调用 Bean的 DisposableBean.destroy()方法，以及用户自定义的destroy()方法，如InstanceA.instanceADestroy()，这里就不在展开讨论，有兴趣的可以自行研究相关代码。
下面附上Spring生命周期图
Spring生命周期
最后，附上程序的执行结果：
Spring生命周期执行结果
网友评论