Spring Bean的生命周期

什么是Spring Bean的生命周期？

       在一个 bean 实例被初始化时，需要执行一系列的初始化操作以达到可用的状态。同样的，当一个 bean 不在被调用时需要进行相关的销毁

操作，并从 bean 容器中移除。

 

下面正式开始：

 

Spring Bean的生命周期是四个阶段，每个阶段都会有拓展点：

1.实例化 Instantiation

2.属性赋值 Popultate

3.初始化 Initialization

4.销毁 Destruction

 

AbstractAutowireCapableBeanFactory#doCreateBean()方法中：

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {
   ''''''
   if (instanceWrapper == null) {
      //1.实例化
      instanceWrapper = createBeanInstance(beanName, mbd, args);
   }
   ''''''
   try {
      //注入属性
      populateBean(beanName, mbd, instanceWrapper);
      //初始化
      exposedObject = initializeBean(beanName, exposedObject, mbd);
   }
   '''''
   return exposedObject;
}

销毁，是在容器关闭时调用的，详见ConfigurableApplicationContext#close()。

AbstractAutowireCapableBeanFactory#createBean()方法中:

/**
* Central method of this class: creates a bean instance,
* populates the bean instance, applies post-processors, etc.
* @see #doCreateBean
*/
@Override
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.
      //for循环调用所有的InstantiationAwareBeanPostProcessor  
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
      if (bean != null) {
         return bean;
      }
   }
   ''''''
   try {
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      return beanInstance;
   }
  ''''
}

/**
* Apply before-instantiation post-processors, resolving whether there is a
* before-instantiation shortcut for the specified bean.
* @param beanName the name of the bean
* @param mbd the bean definition for the bean
* @return the shortcut-determined bean instance, or {@code null} if none
*/
@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
   Object bean = null;
   if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
      // Make sure bean class is actually resolved at this point.
      //实现InstantiationAwareBeanPostProcessors接口
      if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
         Class<?> targetType = determineTargetType(beanName, mbd);
         if (targetType != null) {
            bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
            if (bean != null) {
               bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
            }
         }
      }
      mbd.beforeInstantiationResolved = (bean != null);
   }
   return bean;
}

由源码可见，在doCreatBean之前会看是否实现了InstantiationAwareBeanPostProcessor接口，会调用其中的InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation()。

接下来就是进行实例化，实例化后就是属性注入，在InstantiationAwareBeanPostProcessor#populate()中：

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
   ''''''
   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
               continueWithPropertyPopulation = false;
               break;
            }
         }
      }
   }
''''''

在属性注入时候会调用InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation()方法。

接下来就是初始化

/**
* Initialize the given bean instance, applying factory callbacks
* as well as init methods and bean post processors.
* <p>Called from {@link #createBean} for traditionally defined beans,
* and from {@link #initializeBean} for existing bean instances.
* @param beanName the bean name in the factory (for debugging purposes)
* @param bean the new bean instance we may need to initialize
* @param mbd the bean definition that the bean was created with
* (can also be {@code null}, if given an existing bean instance)
* @return the initialized bean instance (potentially wrapped)
* @see BeanNameAware
* @see BeanClassLoaderAware
* @see BeanFactoryAware
* @see #applyBeanPostProcessorsBeforeInitialization
* @see #invokeInitMethods
* @see #applyBeanPostProcessorsAfterInitialization
*/
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
         invokeAwareMethods(beanName, bean);
         return null;
      }, getAccessControlContext());
   }
   else {
      //BeanNameAware BeanClassLoaderAware BeanFactoryAware
      invokeAwareMethods(beanName, bean);
   }
   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
      //postProcessBeforeInitialization
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }
   try {
      //init()
      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()) {
      //postProcessAfterInitialization
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }
   return wrappedBean;
}

private void invokeAwareMethods(final String beanName, final Object bean) {
   if (bean instanceof Aware) {
      if (bean instanceof BeanNameAware) {
         ((BeanNameAware) bean).setBeanName(beanName);
      }
      if (bean instanceof BeanClassLoaderAware) {
         ClassLoader bcl = getBeanClassLoader();
         if (bcl != null) {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
         }
      }
      if (bean instanceof BeanFactoryAware) {
         ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
      }
   }
}

源码可见，如果bean实现了BeanNameAware、BeanClassLoaderAware、BeanFactoryAware接口则调用各自的方法。

然后如果实现了BeanPostProcessor接口,则调用BeanPostProcessor#postProcessBeforeInitialization()前置方法，afterPropertiesSet()和init-method()方法

则调用，最后调用BeanPostProcessor#postProcessAfterInitialization()前置方法。

最后看下DefaultListableBeanFactory#preInstantiateSingletons()：

@Override
public void preInstantiateSingletons() throws BeansException {

       ''''''''''''''''
    getBean(beanName);

   // Trigger post-initialization callback for all applicable beans...
   for (String beanName : beanNames) {
      Object singletonInstance = getSingleton(beanName);
      if (singletonInstance instanceof SmartInitializingSingleton) {
         final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
         if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
               smartSingleton.afterSingletonsInstantiated();
               return null;
            }, getAccessControlContext());
         }
         else {
            smartSingleton.afterSingletonsInstantiated();
         }
      }
   }
}

所有bean初始化完成后，遍历，如果实现了SmartInitializingSingleton，则调用afterSingletonsInstantiated()方法。

 

总结