一.生命周期图
二.参考回答
(一).四个阶段
Spring中Bean的生命周期主要包含四个阶段
- 实例化Bean
- Bean属性填充
- 初始化Bean
- 销毁Bean
(二).实例化Bean
首先是实例化Bean，当客户端向容器请求一个尚未初始化的Bean时，或初始化Bean的时候需要注入另一个尚未初始化的依赖时，容器会调用doCreateBean()方法进行实例化，实际上就是通过反射来创建一个Bean对象。
(三).Bean属性填充
Bean实例创建出来以后，接着就是给这个Bean对象进行属性填充，也就是注入这个Bean依赖的其他Bean对象。
(四).初始化Bean
属性填充完成后，进行初始化Bean操作。
1.Aware接口
首先执行Aware接口的方法，Spring会检测该对象是否实现了xxxAware接口。通过Aware类型的接口，可以让我们拿到Spring容器的一些资源。例如实现BeanNameAware接口可以获取到BeanName,实现BeanFactoryAware接口可以获取到工厂对象BeanFactory等。
2.BeanPostProcessor前置处理
执行BeanPostProcessor的前置处理方法postProcessBeforeInitialization()对Bean进行一些自定义的前置处理。
3.InitializingBean接口
判断Bean是否实现了InitializingBean接口，如果实现了，将会执行InitializingBean的afterPropertiesSet()初始化方法。
4.自定义的初始化方法
执行用户自定义的初始化方法，如init-method等。
5.BeanPostProcessor后置处理
执行BeanPostProcessor的后置处理方法postProcessAfterInitialization()方法
(五).销毁Bean
初始化完成后，Bean就成功创建了，之后可以使用这个Bean，当Bean不再使用时，会进行销毁操作。
1.DestructionAwareBeanPostProcessor接口
首先判断Bean是否实现了DestructionAwareBeanPostProcessor接口，如果实现了，则会执行DestructionAwareBeanPostProcessor后置处理器的销毁回调方法。
2.DisposableBean接口
其次会判断Bean是否实现了DisposableBean接口，如果实现了将会调用其实现的destory()方法。
3.destory-method
最后判断这个Bean是否配置了destory-method等自定义的销毁方法，如果有的话，则会自动调用其配置的销毁方法。
三.Spring源码分析
(一).doCreateBean
Bean生命周期主要是在doCreateBean这个方法开启的
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
//实例化Bean
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
/*
如果是单例bean,尝试从未完成创建的包装bean缓存(factoryBeanInstanceCache)中获取BeanWrapper(bean的包装类)
*/
instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
//如果缓存中不存在的话，调用createBeanInstance创建一个BeanWrapper
if (instanceWrapper == null) {
//完成Bean的实例化的方法，根据指定bean使用的策略创建Bean的实例，如工厂方法，构造方法自动注入、简单初始化。
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
//获取包装器里面刚创建好的Bean实例
Object bean = instanceWrapper.getWrappedInstance();
//获取实例化对象的类型
Class<?> beanType = instanceWrapper.getWrappedClass();
//如果不是NullBean，则将解析类型属性设置beanType
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
//允许后置处理器对其进行处理
synchronized(mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//应用合并后的BeanDefinition后置处理器，执行MergedBeanDefinitionPostProcessor后置处理器增强方法。
this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable var17) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
}
mbd.postProcessed = true;
}
}
/*
是否提前曝光，主要是处理循环依赖
如果当前bean的单例，且支持循环依赖，且当前bean正在创建的时候
主要是调用方法addSingletonFactory ，往缓存singletonFactories里面放入一个ObjectFactory
当其他的bean 对该bean 有依赖时，可以提前获取到
如果有其他bean依赖该bean，可以从singletonFactories获取到bean
*/
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
if (earlySingletonExposure) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
/*
为避免后期循环依赖，可以在bean初始化完成前创建实例的 objectFactory 加入缓存
对bean 再一次依赖引用，主要应用 SmartInstantiationAwareBeanPostProcessor
其中我们熟悉的AOP就是在这里将 advice 动态织入，若没有直接返回bean
*/
this.addSingletonFactory(beanName, () -> {
/*
getEarlyBeanReference可以对返回的bean进行修改
这边目前除了可能会返回动态代理对象 其他的都是直接返回bean
*/
return this.getEarlyBeanReference(beanName, mbd, bean);
});
}
Object exposedObject = bean;
//初始化实例
try {
//对bean进行填充，将各个属性值注入，其中可能存在依赖于其他bean的属性,会递归初始化
this.populateBean(beanName, mbd, instanceWrapper);
/*
进一步初始化bean
注入 Aware 相关的对象
调用后置处理器 BeanPostProcessor 里面的postProcessBeforeInitialization方法
调用 initialzingBean，调用实现的 afterPropertiesSet()
调用 init-mothod，调用相应的init方法
调用 后置处理器 BeanPostProcessor 里面的调用实现的postProcessAfterInitialization方法
*/
exposedObject = this.initializeBean(beanName, exposedObject, mbd);
} catch (Throwable var18) {
if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
throw (BeanCreationException)var18;
}
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
}
/*
如果提前曝光，尝试从缓存获取该bean
(一般存放在singletonFactories对象通过调用getObject 把对象存入earlySingletonObjects)，
分别从singletonObjects和earlySingletonObjects获取对象
*/
if (earlySingletonExposure) {
Object earlySingletonReference = this.getSingleton(beanName, false);
//arlySingletonReference只有在检测到有循环依赖的情况下才会不为空
if (earlySingletonReference != null) {
/*
当exposedObject等于bean时
(初始化之后的bean等于原始的bean，说明不是proxy)
(只有 exposedObject 没有在初始化方法中被改变，也就是没有被增强才会等于bean）
把缓存中的bean赋值给exposedObject
*/
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
//检测该bean的dependon的bean是否都已经初始化好了
else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
String[] dependentBeans = this.getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
String[] var12 = dependentBeans;
int var13 = dependentBeans.length;
//检查依赖
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)){
actualDependentBeans.add(dependentBean);
}
}
/*
因为bean创建后其所依赖的bean一定是已经创建，
actualDependentBeans不为空则表示
当前bean创建后其依赖的bean却没有全部创建
也就是说存在依赖。
*/
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
try {
//注册DisposableBean，以便在销毁bean的时候，可以运行指定的相关业务
this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
} catch (BeanDefinitionValidationException var16) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
}
}(二).initializeBean
initializeBean是进行bean初始化的，主要做了三件事
- 激活Aware方法
- 后置处理器的应用
- 激活自定义的init方法
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
//激活 Aware 方法，对特殊的 bean 处理：Aware、BeanClassLoaderAware、BeanFactoryAware
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean);
}
//后置处理器 before
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//执行BeanPostProcessor后置处理器方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
//激活用户自定义的init方法
try {
//先调用InitializingBean的afterPropertiesSet，在调用我们定义的init方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
//后置处理器 after，注意这边就是生成我们配置的动态代理对象的关键代码
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}(三).invokeAwareMethods
private void invokeAwareMethods(String beanName, Object bean) {
//如果bean实现了 Aware接口
if (bean instanceof Aware) {
//如果bean实现了 BeanNameAware 接口，则将 beanName 设值进去
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
//如果bean实现了 BeanClassLoaderAware 接口，则将 ClassLoader 设值进去
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
}
//如果bean实现了 BeanFactoryAware 接口，则将 beanFactory 设值进去
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}(四).invokeInitMethods
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
throws Throwable {
//检查bean是否实现了InitializingBean接口
//如果实现了则需要执行InitializingBean接口的afterPropertiesSet方法
boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
if (System.getSecurityManager() != null) {
try {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
((InitializingBean) bean).afterPropertiesSet();
return null;
}, getAccessControlContext());
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
((InitializingBean) bean).afterPropertiesSet();
}
}
//调用用户自定义的初始化方法，比如init-method
if (mbd != null && bean.getClass() != NullBean.class) {
String initMethodName = mbd.getInitMethodName();
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
//调用用户自定义的初始化方法
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}(五).destroy
public void destroy() {
if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
processor.postProcessBeforeDestruction(this.bean, this.beanName);
}
}
if (this.invokeDisposableBean) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking destroy() on bean with name '" + this.beanName + "'");
}
try {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
((DisposableBean) this.bean).destroy();
return null;
}, this.acc);
}
else {
((DisposableBean) this.bean).destroy();
}
}
catch (Throwable ex) {
String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'";
if (logger.isDebugEnabled()) {
logger.warn(msg, ex);
}
else {
logger.warn(msg + ": " + ex);
}
}
}
if (this.invokeAutoCloseable) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking close() on bean with name '" + this.beanName + "'");
}
try {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
((AutoCloseable) this.bean).close();
return null;
}, this.acc);
}
else {
((AutoCloseable) this.bean).close();
}
}
catch (Throwable ex) {
String msg = "Invocation of close method failed on bean with name '" + this.beanName + "'";
if (logger.isDebugEnabled()) {
logger.warn(msg, ex);
}
else {
logger.warn(msg + ": " + ex);
}
}
}
else if (this.destroyMethod != null) {
invokeCustomDestroyMethod(this.destroyMethod);
}
else if (this.destroyMethodName != null) {
Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
if (methodToInvoke != null) {
invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
}
}
}
Comments | NOTHING