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);  }  }  }