Spring Bean生命周期

前言

Spring Bean生命周期是常见的面试题，也是日常开发中经常用到的技术点，在应用开发中，常常需要执行一些特殊的初始化工作，如建立数据库连接，打开网络连接，又比如在一些业务bean里，你想拿到Spring IOC容器，又或者是想拿到一些已经实例化的Bean。同时，在服务结束时，也有一些销毁销毁工作需要执行。为了便于工作的设计，Spring IOC提供相关接口，可以让应用定制Bean的初始化和销毁。
​

Spring Bean生命周期

先来看一下Spring Bean生命周期流程图，方便对照后续的源码分析。

Spring Bean生命周期从大的节点上分为4个过程：实例化、属性赋值、初始化、销毁。 日常业务开发过程中，我们应该涉及最多的两个点就是初始化和销毁，比如自定义Bean实现InitializingBean、DisposeableBean。
​

源码分析

Spring IOC容器初始化

初始化从AbstractAutowireCapableBeanFactory.doCreateBean方法开始说起，我在对应的代码位置标注了关键点

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
	}
    
	//1. Bean实例化
	if (instanceWrapper == null) {
	   instanceWrapper = this.createBeanInstance(beanName, mbd, args);
	}

	Object bean = instanceWrapper.getWrappedInstance();
	Class<?> beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType;
	}

	synchronized(mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
				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;
		}
	}

	boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
	if (earlySingletonExposure) {
		this.addSingletonFactory(beanName, () -> {
			return this.getEarlyBeanReference(beanName, mbd, bean);
		});
	}

	Object exposedObject = bean;

	try {
	    //2.属性赋值
       this.populateBean(beanName, mbd, instanceWrapper);
	    //3.初始化
	    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);
	}

	if (earlySingletonExposure) {
		Object earlySingletonReference = this.getSingleton(beanName, false);
		if (earlySingletonReference != null) {
			if (exposedObject == bean) {
				exposedObject = earlySingletonReference;
			} 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(int var14 = 0; var14 < var13; ++var14) {
					String dependentBean = var12[var14];
					if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
						actualDependentBeans.add(dependentBean);
					}
				}

				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 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
				}
			}
		}
	}

	try {
	    //4.销毁 - 注册回调接口
	    this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
	    return exposedObject;
	} catch (BeanDefinitionValidationException var16) {
	    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
	}
}

为了保持代码片段精简，我删掉了其中的logger代码。

​

从以上代码片段里可以看到我们上面总结的Spring生命后期4个关键点都有体现，我们着重分析初始化和销毁流程。
​

AbstractAutowireCapableBeanFactory.initializeBean

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
	//1.检查Aware相关接口并设置相关依赖
    //BeanNameAware, BeanClassLoaderAware, BeanFactoryAware
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged(() -> {
			this.invokeAwareMethods(beanName, bean);
			return null;
		}, this.getAccessControlContext());
	} else {
		this.invokeAwareMethods(beanName, bean);
	}

    //2.BeanPostProcessor前置处理
	Object wrappedBean = bean;
	if (mbd == null || !mbd.isSynthetic()) {
	    //BeanPostProcessor接口的postProcessBeforeInitialization回调
		wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
	}
    
	//3.若实现InitializingBean接口，则调用afterPropertiesSet()
	//4.若配置自定义的init-method(), 则执行。
	try {
		this.invokeInitMethods(beanName, wrappedBean, mbd);
	} catch (Throwable var6) {
		throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
	}

    //5.BeanPostProcessor后置处理
	if (mbd == null || !mbd.isSynthetic()) {
	    //BeanPostProcessor接口的postProcessAfterInitialization回调
		wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}

	return wrappedBean;
}

AbstractAutowireCapableBeanFactory.invokeAwareMethods
invokeAwareMethod就是调用一系列Aware结尾的接口，比如
BeanNameAware、ApplicationContextAware、BeanFactoryAware。

private void invokeAwareMethods(String beanName, Object bean) {
   if (bean instanceof Aware) {
      if (bean instanceof BeanNameAware) {
         ((BeanNameAware)bean).setBeanName(beanName);
      }

       if (bean instanceof BeanClassLoaderAware) {
           ClassLoader bcl = this.getBeanClassLoader();
           if (bcl != null) {
               ((BeanClassLoaderAware)bean).setBeanClassLoader(bcl);
           }
       }

       if (bean instanceof BeanFactoryAware) {
           ((BeanFactoryAware)bean).setBeanFactory(this);
       }
   }
 }

​

AbstractAutowireCapableBeanFactory.invokeInitMethods
invokeinitMethods就是调用InitializingBean接口的afterPropertiesSet，并且检查自定义init-method。

protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd) throws Throwable {
	boolean isInitializingBean = bean instanceof InitializingBean;
	if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
		if (System.getSecurityManager() != null) {
			try {
				AccessController.doPrivileged(() -> {
					((InitializingBean)bean).afterPropertiesSet();
					return null;
				}, this.getAccessControlContext());
			} catch (PrivilegedActionException var6) {
				throw var6.getException();
			}
		} else {
			((InitializingBean)bean).afterPropertiesSet();
		}
	}

	if (mbd != null && bean.getClass() != NullBean.class) {
		String initMethodName = mbd.getInitMethodName();
		if (StringUtils.hasLength(initMethodName) && (!isInitializingBean || !"afterPropertiesSet".equals(initMethodName)) && !mbd.isExternallyManagedInitMethod(initMethodName)) {
			this.invokeCustomInitMethod(beanName, bean, mbd);
		}
	}
}

从以上代码片段可以看出Spring IOC容器创建Bean的过程, 涉及的过程包括实例化，销毁，还包括BeanPostProcessor接口相关方法实现，以上代码片段我们分析了Spring容器初始化过程加载Bean的各种实现，下面我们看下Spring容器销毁阶段。
​

容器销毁

Spring容器销毁过程调用链

Spring在这里用了适配器模式，也就是说最终的销毁任务由DisposableBeanAdapter来完成，我们看下DisposeableBeanAdapter的结构。

从结构中可以看到bean属性类型为Object， 也就是要销毁的Bean，还有beanName属性。

public void destroy() {
    if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
        Iterator var1 = this.beanPostProcessors.iterator();

        while(var1.hasNext()) {
            DestructionAwareBeanPostProcessor processor = (DestructionAwareBeanPostProcessor)var1.next();
            processor.postProcessBeforeDestruction(this.bean, this.beanName);
        }
    }

	if (this.invokeDisposableBean) {
		try {
			if (System.getSecurityManager() != null) {
				AccessController.doPrivileged(() -> {
					((DisposableBean)this.bean).destroy();
					return null;
				}, this.acc);
			} else {
				((DisposableBean)this.bean).destroy();
			}
		} catch (Throwable var3) {
			
		}
	}

	if (this.destroyMethod != null) {
		this.invokeCustomDestroyMethod(this.destroyMethod);
	} else if (this.destroyMethodName != null) {
		Method methodToInvoke = this.determineDestroyMethod(this.destroyMethodName);
		if (methodToInvoke != null) {
			this.invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
		}
	}
}

​

总结

Spring Bean生命周期分为4个阶段和多个扩展点，扩展点又分为影响多个Bean和单个Bean。
4个阶段：实例化、属性赋值、初始化、销毁。
扩展点
影响多个Bean

• BeanPostProcessor
• InstantiationAwareBeanPostProcessor

​

影响单个Bean

• BeanNameAware
• BeanFactoryAware
• BeanClassLoaderAware
• ApplicationContextAware

​

Spring生命周期中两个关键的接口：InitializingBean, DisposableBean。
​