SpringBean的生命周期

Bean 的生命周期概括起来就是 4 个阶段：

1. 实例化（Instantiation）：创建 Bean 的实例。
2. 属性赋值（Populate）：为 Bean 的属性赋值。
3. 初始化（Initialization）：调用 Bean 的初始化方法，如 @PostConstruct 注解的方法。
4. 使用中（Usage）：Bean 处于可用状态，供容器或应用程序使用。
5. 销毁（Destruction）：调用 Bean 的销毁方法，如 @PreDestroy 注解的方法。

详细流程：

graph TD A[容器启动] --> B[1.实例化 Bean 实例] B --> C[2.设置对象属性] C --> D[3.检查 Aware 接口并设置依赖] D --> E[4.BeanPostProcessor 前置处理] E --> F[5.调用 InitializingBean 的 afterPropertiesSet] F --> G[6.调用自定义 init-method] G --> H[7.BeanPostProcessor 后置处理] H --> I[Bean使用中] I --> J[8.注册 Destruction 回调接口] J --> K[9.调用 DisposableBean 的 destroy] K --> L[10.调用自定义 destroy-method] L --> M[结束]

1. 实例化（Instantiation）

• 容器启动后，根据配置或注解创建 Bean 的实例。
• 对应图中步骤：
  1. 实例化 Bean 实例

2. 属性赋值（Populate）

• Spring 进行依赖注入，设置 Bean 的属性。

• 包括通过 @Autowired、@Value 或 XML 中的 进行注入。

• 检查是否实现了 Aware 接口，如：

  • BeanNameAware
  • BeanFactoryAware
  • ApplicationContextAware
  • 并进行相应依赖注入。

• 对应图中步骤：
  2. 设置对象属性
  3. 检查 Aware 接口并注入

3. 初始化（Initialization）

• Spring 进行一系列初始化操作：

  1. 调用 BeanPostProcessor#postProcessBeforeInitialization 前置处理器方法。

  2. 如果实现了 InitializingBean 接口，调用其 afterPropertiesSet() 方法。

  3. 如果配置了 init-method，调用该初始化方法。

  4. 调用 BeanPostProcessor#postProcessAfterInitialization 后置处理器方法。

• 对应图中步骤：
  4. 前置处理器
  5. 调用 afterPropertiesSet()
  6. 调用 init-method
  7. 后置处理器

4. 使用中

   • Bean 处于可用状态，供容器或应用程序使用。

5. 销毁（Destruction）

• 容器关闭或 Bean 生命周期结束时执行：

  1. 注册销毁相关回调
  2. 如果实现了 DisposableBean 接口，调用其 destroy() 方法。
  3. 如果配置了 destroy-method，调用该方法。

• 对应图中步骤：
  8. 注册销毁回调接口
  9. 调用 destroy()
  10. 调用 destroy-method

源码入口：
AbstractAutowireCapableBeanFactory#doCreateBean

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

		// Instantiate the bean.
        // 实例化Bean
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		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.markAsPostProcessed();
			}
		}

		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
            // 填充Bean属性，包括依赖注入（如通过@Autowired、XML配置的<property>）。
			populateBean(beanName, mbd, instanceWrapper);
            // 执行初始化逻辑
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		catch (Throwable ex) {
			if (ex instanceof BeanCreationException bce && beanName.equals(bce.getBeanName())) {
				throw bce;
			}
			else {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName, ex.getMessage(), ex);
			}
		}

		if (earlySingletonExposure) {
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = CollectionUtils.newLinkedHashSet(dependentBeans.length);
					for (String dependentBean : dependentBeans) {
						if (!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 " +
								"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}

		// Register bean as disposable.
		try {
            // 注册Bean的销毁方法（如DisposableBean.destroy()或自定义的destroy-method）
			// 单例Bean的销毁逻辑会被注册到DisposableBeanAdapter，在容器关闭时调用。
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

	protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
        // BeanNameAware.setBeanName(beanName)
		// BeanClassLoaderAware.setBeanClassLoader(...)
		// BeanFactoryAware.setBeanFactory(...)
		invokeAwareMethods(beanName, bean);

		Object wrappedBean = bean;
        // 执行BeanPostProcessorsBeforeInitialization方法
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
            // 执行init方法
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null), beanName, ex.getMessage(), ex);
		}
		if (mbd == null || !mbd.isSynthetic()) {
            // 执行BeanPostProcessorsAfterInitialization方法
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

参考链接：

• https://juejin.cn/post/6844904065457979405
• https://juejin.cn/post/7075168883744718856