解析Spring框架中Bean的生命周期不仅可以帮助我们更好地理解Spring的工作机制，还能让我们在实际开发中更加得心应手。Spring管理Bean的生命周期涉及多个步骤，从实例化到销毁，每一个步骤都有其独特的处理逻辑。本文将通过源码详细解析Spring中Bean的生命周期。
1. Bean的生命周期概述
Spring中Bean的生命周期包括以下几个主要阶段：
1. **实例化（Instantiation）**：创建Bean实例。
2. **属性填充（Populate properties）**：将依赖注入到Bean实例中。
3. **初始化（Initialization）**：调用初始化方法。
4. **使用（Usage）**：Bean处于就绪状态，供应用程序使用。
5. **销毁（Destruction）**：容器关闭时调用销毁方法。
这些阶段由不同的组件和机制来共同完成，如`BeanFactory`，`BeanPostProcessor`，以及各种回调接口等。
2. 实例化Bean
实例化过程由`AbstractAutowireCapableBeanFactory`类的`createBeanInstance`方法负责。它根据Bean定义信息选择合适的构造函数或工厂方法来创建Bean实例。
```java protected Object createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { // 如果设置了工厂方法，则通过工厂方法创建Bean if (mbd.getFactoryMethodName() != null) { return instantiateUsingFactoryMethod(beanName, mbd, args); } // 尝试使用默认构造函数或带参数的构造函数 Constructor<?> constructorToUse = null; synchronized (mbd.constructorArgumentLock) { constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod; if (constructorToUse == null) { final Class<?> beanClass = resolveBeanClass(mbd, beanName); if (beanClass != null) { if (!Modifier.isPublic(beanClass.getModifiers())) { throw new BeanCreationException( beanName, "Bean class isn't public, and non-public classes not supported: " + beanClass.getName()); } try { constructorToUse = determineConstructorsFromBeanPostProcessors(beanClass, beanName); mbd.resolvedConstructorOrFactoryMethod = constructorToUse; } catch (Throwable ex) { throw new BeanCreationException(beanName, "Resolution of declared constructors on bean Class [" + beanClass.getName() + "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex); } } } } return instantiateBean(beanName, mbd, constructorToUse); } ```
该方法首先检查Bean定义中是否指定了工厂方法，如果有则通过工厂方法创建Bean实例；否则，尝试使用默认构造函数或带参数的构造函数。
3. 属性填充
一旦Bean实例创建完成，Spring会将依赖注入到该实例中。这一步由`populateBean`方法负责。
```java protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { if (bw == null) { if (mbd.hasPropertyValues()) { throw new BeanCreationException( beanName, "Cannot apply property values to null instance"); } else { // Skip property population phase for an existing null instance. return; } } // 应用 InstantiationAwareBeanPostProcessors boolean continueWithPropertyPopulation = true; if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessors(InstantiationAwareBeanPostProcessor.class)) { if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { continueWithPropertyPopulation = false; break; } } } if (!continueWithPropertyPopulation) { return; } PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null); if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { MutablePropertyValues newPvs = new MutablePropertyValues(pvs); if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) { autowireByName(beanName, mbd, bw, newPvs); } if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { autowireByType(beanName, mbd, bw, newPvs); } pvs = newPvs; } // 应用 BeanPostProcessors 修改属性值 boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors(); boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE); if (hasInstAwareBpps || needsDepCheck) { PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); if (hasInstAwareBpps) { for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessors(InstantiationAwareBeanPostProcessor.class)) { PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { if (pvs == null) { pvs = mbd.getPropertyValues(); } pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { return; } } pvs = pvsToUse; } } if (needsDepCheck) { checkDependencies(beanName, mbd, filteredPds, pvs); } } // 将属性值应用到 Bean 实例 if (pvs != null) { applyPropertyValues(beanName, mbd, bw, pvs); } } ```
`populateBean`方法首先应用`InstantiationAwareBeanPostProcessor`接口的`postProcessAfterInstantiation`方法，对Bean实例进行后续处理，接着根据自动装配模式（byName或byType）进行依赖注入，最后将属性值应用到Bean实例。
4. 初始化Bean
在属性填充完成后，Spring会调用Bean的初始化方法，这一步由`initializeBean`方法负责。
```java protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) { if (System.getSecurityManager() != null) { AccessControlContext acc = getAccessControlContext(); AccessController.doPrivileged((PrivilegedAction<Object>) () -> { invokeAwareMethods(beanName, bean); return null; }, acc); } else { invokeAwareMethods(beanName, bean); } Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } try { invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwable ex) { throw new BeanCreationException( (mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex); } if (mbd == null || !mbd.isSynthetic()) { wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } return wrappedBean; } ```
`initializeBean`方法首先调用`invokeAwareMethods`方法处理实现了`Aware`接口的Bean，例如，如果Bean实现了`BeanNameAware`接口，则会调用`setBeanName`方法。接着，方法应用`BeanPostProcessor`接口的`postProcessBeforeInitialization`方法，然后调用Bean的初始化方法（如`@PostConstruct`注解的方法或自定义的初始化方法）。最后，应用`BeanPostProcessor`接口的`postProcessAfterInitialization`方法。
5. 销毁Bean
当容器关闭时，Spring会调用Bean的销毁方法，这一步由`destroyBean`方法负责。
```java protected void destroyBean(String beanName, Object bean, RootBeanDefinition mbd) { new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessorCache().destructionAware).destroy(); } ```
`destroyBean`方法使用`DisposableBeanAdapter`来管理Bean的销毁过程。`DisposableBeanAdapter`会检查Bean是否实现了`DisposableBean`接口或定义了自定义的销毁方法，并调用相应的销毁方法。
总结
通过对Spring源码的详细分析，我们可以看到Spring是如何管理Bean的生命周期的：
1. **实例化**：通过反射机制创建Bean实例。
2. **属性填充**：将依赖对象注入到Bean实例中。
3. **初始化**：在属性填充完毕后调用初始化方法。
4. **销毁**：在容器关闭时调用销毁方法。
这种设计使得Spring能够灵活地管理Bean的生命周期，并提供了丰富的扩展点供开发者自定义Bean的创建和销毁逻辑。通过了解这些底层机制，我们可以更好地使用和扩展Spring框架，满足复杂应用的需求。
