Spring源码之bean的销毁registerDisposableBeanIfNecessary方法解读

1. 前言

这篇文章是 IOC 容器初始化启动时，抽象类 AbstractAutowireCapableBeanFactory 的 doCreateBean() 方法里面的 registerDisposableBeanIfNecessary() 方法，它是进行 bean 的销毁的方法

阅读本篇文章，同时可以参考阅读 spring源码之getBean（获取 bean）方法解读（二） 和 Spring Aop代理对象的产生（一） 这两篇文章的 doCreateBean() 方法

1.1. 回顾 doCreateBean() 方法

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {
   

	// BeanWrapper封装了具体的Bean实例，然后可以很方便地通过调用getPropertyValue和setPropertyValue等方法反射读写Bean的具体属性
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
   
		// 先尝试从缓存中取
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
   
		// 调用构造方法创建一个空实例对象，并用BeanWrapper进行包装
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	final Object bean = instanceWrapper.getWrappedInstance();
	Class<?> beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
   
		mbd.resolvedTargetType = beanType;
	}

	// 获取所有的后置处理器，如果后置处理器实现了MergedBeanDefinitionPostProcessor接口，则一次调用其postProcessMergedBeanDefinition方法
	synchronized (mbd.postProcessingLock) {
   
		if (!mbd.postProcessed) {
   
			try {
   
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}
			catch (Throwable ex) {
   
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Post-processing of merged bean definition failed", ex);
			}
			mbd.postProcessed = true;
		}
	}

	// 如果满足循环依赖缓存条件，先缓存具体对象
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
		isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
   
		if (logger.isDebugEnabled()) {
   
			logger.debug("Eagerly caching bean '" + beanName +
					"' to allow for resolving potential circular references");
		}
	
	   /**
		* 循环依赖处理逻辑：将已完成实例化，但是未完成属性赋值和相关的初始化的一个不完整的 bean 添加到三级缓存 singletonFactories 中
		* 具体内部会遍历后置处理器，判断是否有SmartInstantiationAwareBeanPostProcessor的实现类，然后调用里面getEarlyBeanReference覆盖当前Bean
		* 默认不做任何操作返回当前Bean，作为拓展，这里比如可以供AOP来创建代理类
		*/
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}

	// 开始对Bean实例进行初始化
	Object exposedObject = bean;
	try {
   
		// 对bean进行属性填充，在这里面完成依赖注入的相关内容
		populateBean(beanName, mbd, instanceWrapper);
		// 完成属性依赖注入后，进一步初始化Bean
		// 具体进行了以下操作：
		// 1.若实现了BeanNameAware， BeanClassLoaderAware，BeanFactoryAwareAware等接口，则注入相关对象
		// 2.遍历后置处理器，调用实现的postProcessBeforeInitialization方法，
		// 3.如果实现了initialzingBean，调用实现的 afterPropertiesSet()
		// 4.如果配置了init-mothod，调用相应的init方法
		// 5.遍历后置处理器，调用实现的postProcessAfterInitialization
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
	catch (Throwable ex) {
   
		if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
   
			throw (BeanCreationException) ex;
		}
		else {
   
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
		}
	}

	if (earlySingletonExposure) {
   
		Object earlySingletonReference = getSingleton(beanName, false);
		if (earlySingletonReference != null) {
   
			if (exposedObject == bean) {
   
				exposedObject = earlySingletonReference;
			}
			else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName))