Spring InitializingBean init-method @PostConstruct 執行順序

Spring 容器中的 Bean 是有生命周期的，Spring 允許在 Bean 在初始化完成后以及 Bean 銷毀前執行特定的操作，常用的設定方式有以下三種：

 

通過實現 InitializingBean/DisposableBean 接口來定制初始化之后/銷毀之前的操作方法；

通過 元素的 init-method/destroy-method屬性指定初始化之后 /銷毀之前調用的操作方法；

在指定方法上加上@PostConstruct 或@PreDestroy注解來制定該方法是在初始化之后還是銷毀之前調用。 

它們的先后順序是怎樣的，我們用下面的測試代碼來驗證

package com.example;

public class InitSequenceBean implements InitializingBean {   
    
    public InitSequenceBean() {   
       System.out.println("InitSequenceBean: constructor");   
    }   
      
    @PostConstruct  
    public void postConstruct() {   
       System.out.println("InitSequenceBean: postConstruct");   
    }   
      
    public void initMethod() {   
       System.out.println("InitSequenceBean: init-method");   
    }   
      
    @Override  
    public void afterPropertiesSet() throws Exception {   
       System.out.println("InitSequenceBean: afterPropertiesSet");   
    }   
}  

 

配置如下

<bean id="initSequenceBean " class="com.example.InitSequenceBean" init-method="initMethod"/>

好了，我們啟動Spring容器，觀察輸出結果

InitSequenceBean: constructor

InitSequenceBean: postConstruct

InitSequenceBean: afterPropertiesSet

InitSequenceBean: init-method

通過上述輸出結果，三者的先后順序也就一目了然了：

 

Constructor > @PostConstruct > InitializingBean > init-method

 

先大致分析下為什么會出現這些的結果：構造器（Constructor）被率先調用毋庸置疑，InitializingBean先於init-method我們也可以理解（在也談Spring容器的生命周期中已經討論過），但是PostConstruct為何率先於InitializingBean執行呢？

 

我們再次帶着這個疑問去查看Spring源代碼來一探究竟。

通過Debug並查看調用棧，我們發現了這個類org.springframework.context.annotation.CommonAnnotationBeanPostProcessor，從命名上，我們就可以得到某些信息——這是一個BeanPostProcessor。想到了什么？在也談Spring容器的生命周期中，我們提到過BeanPostProcessor的postProcessBeforeInitialization是在Bean生命周期中afterPropertiesSet和init-method之前執被調用的。

 

再次觀察CommonAnnotationBeanPostProcessor這個類，它繼承自InitDestroyAnnotationBeanPostProcessor。InitDestroyAnnotationBeanPostProcessor顧名思義，就是在Bean初始化和銷毀的時候所作的一個前置/后置處理器。

 

通過查看InitDestroyAnnotationBeanPostProcessor類下的postProcessBeforeInitialization方法：

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {   
       LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());   
       try {   
           metadata.invokeInitMethods(bean, beanName);   
       }   
       catch (InvocationTargetException ex) {   
           throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());   
       }   
       catch (Throwable ex) {   
           throw new BeanCreationException(beanName, "Couldn't invoke init method", ex);   
       }   
        return bean;   
    }  
  

查看findLifecycleMetadata方法，繼而我們跟蹤到buildLifecycleMetadata這個方法體中，看下buildLifecycleMetadata這個方法體的內容：

private LifecycleMetadata buildLifecycleMetadata(final Class clazz) {   
       final LifecycleMetadata newMetadata = new LifecycleMetadata();   
       final boolean debug = logger.isDebugEnabled();   
       ReflectionUtils.doWithMethods(clazz, new ReflectionUtils.MethodCallback() {   
           public void doWith(Method method) {   
              if (initAnnotationType != null) {   
                  if (method.getAnnotation(initAnnotationType) != null) {   
                     newMetadata.addInitMethod(method);   
                     if (debug) {   
                         logger.debug("Found init method on class [" + clazz.getName() + "]: " + method);   
                     }   
                  }   
              }   
              if (destroyAnnotationType != null) {   
                  if (method.getAnnotation(destroyAnnotationType) != null) {   
                     newMetadata.addDestroyMethod(method);   
                     if (debug) {   
                         logger.debug("Found destroy method on class [" + clazz.getName() + "]: " + method);   
                     }   
                  }   
              }   
           }   
       });   
       return newMetadata;   
}  

分析這段代碼發現，在這里會去判斷某方法有沒有被initAnnotationType/destroyAnnotationType注釋，如果有，則添加到init/destroy隊列中，后續一一執行。

 

initAnnotationType/destroyAnnotationType注釋是什么呢，我們在CommonAnnotationBeanPostProcessor的構造函數中看到下面這段代碼：

public CommonAnnotationBeanPostProcessor() {   
       setOrder(Ordered.LOWEST_PRECEDENCE - 3);   
       setInitAnnotationType(PostConstruct.class);   
       setDestroyAnnotationType(PreDestroy.class);   
       ignoreResourceType("javax.xml.ws.WebServiceContext");   
}  

一切都清晰了吧。一言以蔽之，@PostConstruct注解后的方法在BeanPostProcessor前置處理器中就被執行了，所以當然要先於InitializingBean和init-method執行了。

 

接下來看看為什么InitializingBean先於init-method執行，通過查看spring的加載bean的源碼類(AbstractAutowireCapableBeanFactory)可看出其中奧妙

AbstractAutowireCapableBeanFactory類中的invokeInitMethods講解的非常清楚，源碼如下：

protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd) throws Throwable {
    //判斷該bean是否實現了實現了InitializingBean接口，如果實現了InitializingBean接口，則只掉調用bean的afterPropertiesSet方法
    boolean isInitializingBean = (bean instanceof InitializingBean);
    if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
        if (logger.isDebugEnabled()) {
            logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
        }
         
        if (System.getSecurityManager() != null) {
            try {
                AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                    public Object run() throws Exception {
                        //直接調用afterPropertiesSet
                        ((InitializingBean) bean).afterPropertiesSet();
                        return null;
                    }
                },getAccessControlContext());
            } catch (PrivilegedActionException pae) {
                throw pae.getException();
            }
        }                
        else {
            //直接調用afterPropertiesSet
            ((InitializingBean) bean).afterPropertiesSet();
        }
    }
    if (mbd != null) {
        String initMethodName = mbd.getInitMethodName();
        //判斷是否指定了init-method方法，如果指定了init-method方法，則再調用制定的init-method
        if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                !mbd.isExternallyManagedInitMethod(initMethodName)) {
            //進一步查看該方法的源碼，可以發現init-method方法中指定的方法是通過反射實現
            invokeCustomInitMethod(beanName, bean, mbd);
        }
    }
}

總結

1：spring為bean提供了兩種初始化bean的方式，實現InitializingBean接口，實現afterPropertiesSet方法，或者在配置文件中同過init-method指定，兩種方式可以同時使用

2：實現InitializingBean接口是直接調用afterPropertiesSet方法，比通過反射調用init-method指定的方法效率相對來說要高點。但是init-method方式消除了對spring的依賴

3：如果調用afterPropertiesSet方法時出錯，則不調用init-method指定的方法。

 

最后，給出本文的結論，Bean在實例化的過程中：

 

Constructor > @PostConstruct > InitializingBean > init-method