【Spring】Bean的生命周期，部分源码解释

Bean 的生命周期

生命周期指的是一个对象从诞生到销毁的整个生命过程，我们把这个过程就叫做一个对象的声明周期

Bean 的声明周期分为以下 5 个部分：

1. 实例化（为 Bean 分配空间）
2. 属性赋值（Bean 注入和装配，比如 @Autowired）
3. 初始化
   1. 执行各种通知，如 BeanNameAware，BeanFactoryAware，ApplicationContextAware 的接口方法
   2. 执行初始化方法
      • xml 定义 init-method
      • 使用注解的方式 @PostConstruct
      • 执行初始化后置方法（BeanPostProcessor）
4. 使用 Bean
5. 销毁 Bean
   • 销毁容器的各种方法，如 @PreDestory，DisposableBean 接口方法，destory-method

执行流程

• 实例化和属性赋值对应构造方法和 setter 方法的注入。
• 初始化和销毁是用户能自定义扩展的两个阶段
• 可以在实例化之后，类加载完成之前进行自定义“事件”处理

比如我们现在需要买一栋房子，那么我们的流程是这样的

1. 先买房（实例化，从无到有）
2. 装修（设置属性）
3. 买家电，如洗衣机，冰箱，电视，空调等（[各种]初始化，可以注入）
4. 入住（使用 Bean）
5. 卖房（Bean 销毁）

执行流程如下图所示：

代码演示

@Component  
public class BeanLifeComponent implements BeanNameAware {  private UserComponent userComponent;  public BeanLifeComponent() {  System.out.println("执行构造函数");  }  public void setUserComponent(UserComponent userComponent) {  System.out.println("设置属性 userComponent");  this.userComponent = userComponent;  }  @Override  public void setBeanName(String s) {  System.out.println("执行了 setBeanName 方法：" + s);  }  /**  * 初始化  */  @PostConstruct  public void postConstruct() {  System.out.println("执行 postConstruct()");  }  public void use() {  System.out.println("执行了 use 方法");  }  /**  * 销毁前执行方法  */  public void preDestroy() {  System.out.println("执行：preDestroy()");  }  
}

执行结果

通过运行结果观察：

1. 先执行构造函数
2. 设置属性
3. Bean 初始化
4. 使用 Bean
5. 销毁 Bean

源码阅读

以上步骤在源码中皆有体现

AbstractAutowireCapableBeanFactory

创建 Bean 的代码入口在 AbstractAutowireCapableBeanFactory#createBean

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactoryimplements AutowireCapableBeanFactory {protected Object createBean(String beanName, RootBeanDefinition mbd,@Nullable Object[] args) throws BeanCreationException {//...代码省略try {// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.// 在实例化之前，是否有快捷创建的Bean，也就是通过 PostProcessorsBeforeInstantiation返回的Bean// 如果存在，则会替代原来正常通过target bean生成的bean的流程Object bean = resolveBeforeInstantiation(beanName, mbdToUse);if (bean != null) {return bean;}}catch (Throwable ex) {throw new BeanCreationException(mbdToUse.getResourceDescription(),beanName,"BeanPostProcessor before instantiation of bean failed", ex);}try {// 创建Bean// 方法中包含了实例化、属性赋值、初始化过程Object beanInstance = doCreateBean(beanName, mbdToUse, args);if (logger.isTraceEnabled()) {logger.trace("Finished creating instance of bean '" + beanName + "'!");}return beanInstance;}//...代码省略}
}

doCreateBean

点进去继续看源码：doCreateBean#createBean

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {// Instantiate the bean.if (instanceWrapper == null) {// 1. 实例化阶段：通过反射调用构造函数/工厂方法instanceWrapper = createBeanInstance(beanName, mbd, args);}// Initialize the bean instance.Object exposedObject = bean;try {// 2. 属性填充阶段：依赖注入（@Autowired/@Value等）populateBean(beanName, mbd, instanceWrapper);// 3. 初始化阶段：Aware接口回调、init-method、PostProcessor处理exposedObject = initializeBean(beanName, exposedObject, mbd);}catch (Throwable ex) {// 4. 异常处理：区分是否已标记为BeanCreationExceptionif (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {throw (BeanCreationException) ex;}else {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);}}return exposedObject;
}

这三个方法与三个生命周期阶段一一对应

1. createBeanInstance() ->实例化
2. populateBean() ->属性赋值
3. initializeBean() ->初始化

initializeBean

继续点进去：initializeBean

// 初始化 Bean
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {  this.invokeAwareMethods(beanName, bean);  Object wrappedBean = bean;  if (mbd == null || !mbd.isSynthetic()) {  wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);  }  try {  this.invokeInitMethods(beanName, wrappedBean, mbd);  } catch (Throwable ex) {  throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, ex.getMessage(), ex);  }  if (mbd == null || !mbd.isSynthetic()) {  wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);  }  return wrappedBean;  
}  
// 调用的三个 Bean 开头的 Aware 方法
private void invokeAwareMethods(String beanName, Object bean) {  if (bean instanceof Aware) {  if (bean instanceof BeanNameAware) {  BeanNameAware beanNameAware = (BeanNameAware)bean;  beanNameAware.setBeanName(beanName);  }  if (bean instanceof BeanClassLoaderAware) {  BeanClassLoaderAware beanClassLoaderAware = (BeanClassLoaderAware)bean;  ClassLoader bcl = this.getBeanClassLoader();  if (bcl != null) {  beanClassLoaderAware.setBeanClassLoader(bcl);  }  }  if (bean instanceof BeanFactoryAware) {  BeanFactoryAware beanFactoryAware = (BeanFactoryAware)bean;  beanFactoryAware.setBeanFactory(this);  }  }  }