轉載自：http://blog.csdn.net/lovesomnus/article/details/50158761

關於在spring  容器初始化 bean 和銷燬前所做的操作定義方式有三種：

1. import javax.annotation.PostConstruct;    
2. import javax.annotation.PreDestroy;    
3. publicclass DataInitializer{     
4.     @PostConstruct
5.     publicvoid initMethod() throws
    Exception {  
6.         System.out.println("initMethod 被執行");  
7.     }  
8.     @PreDestroy
9.     publicvoid destroyMethod() throws Exception {  
10.         System.out.println("destroyMethod 被執行");  
11.     }  
12. }  

1. publicclass DataInitializer{  
2.     publicvoid initMethod() throws Exception {  
3.         System.out.println("initMethod 被執行");  
4.     }  
5.     publicvoid destroyMethod() throws Exception {  
6.         System.out.println("destroyMethod 被執行");  
7.     }  
8. }  

1. <beanid="dataInitializer"class="com.somnus.demo.DataInitializer"init-method="initMethod"destory-method
   ="destroyMethod"/>

1. import org.springframework.beans.factory.DisposableBean;  
2. publicclass DataInitializer implements InitializingBean，DisposableBean{  
3.     @Override
4.     publicvoid afterPropertiesSet() throws Exception {  
5.         System.out.println("afterPropertiesSet 被執行");  
6.     }  
7.     @Override
8.     publicvoid destroy() throws Exception {  
9.         System.out.println("destroy 被執行");  
10.     }  
11. }  

其中第一種和第二種是同一種形式，只不過一種xml配置，另外一種採用註解形式罷了，有很大區別的是第三種，

如果同一個bean同時採用兩種方式初始化的時候執行某個方法，首先在執行順序上就會體現出來。

先執行afterPropertiesSet()，

後執行initMethod()

這裡我們看下原始碼

這方式在spring中是怎麼實現的？

通過檢視spring的載入bean的原始碼類(AbstractAutowireCapableBeanFactory)可看出其中奧妙

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

1. protectedvoid invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)  
2.       throws Throwable {  
3.   //判斷該bean是否實現了實現了InitializingBean介面，如果實現了InitializingBean介面，則只掉呼叫bean的afterPropertiesSet方法
4.   boolean isInitializingBean = (bean instanceof InitializingBean);  
5.   if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {  
6.       if (logger.isDebugEnabled()) {  
7.           logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");  
8.       }  
9.       if (System.getSecurityManager() != null) {  
10.           try {  
11.               AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {  
12.                   public Object run() throws Exception {  
13.                       //直接呼叫afterPropertiesSet
14.                       ((InitializingBean) bean).afterPropertiesSet();  
15.                       returnnull;  
16.                   }  
17.               },getAccessControlContext());  
18.           } catch (PrivilegedActionException pae) {  
19.               throw pae.getException();  
20.           }  
21.       }                  
22.       else {  
23.           //直接呼叫afterPropertiesSet
24.           ((InitializingBean) bean).afterPropertiesSet();  
25.       }  
26.   }  
27.   if (mbd != null) {  
28.       String initMethodName = mbd.getInitMethodName();  
29.       //判斷是否指定了init-method方法，如果指定了init-method方法，則再呼叫制定的init-method
30.       if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&  
31.               !mbd.isExternallyManagedInitMethod(initMethodName)) {  
32.               //進一步檢視該方法的原始碼，可以發現init-method方法中指定的方法是通過反射實現
33.           invokeCustomInitMethod(beanName, bean, mbd);  
34.       }  
35.   }  

1：spring為bean提供了兩種初始化bean的方式，實現InitializingBean介面，實現afterPropertiesSet方法，或者在配置檔案中同過

init-method指定，兩種方式可以同時使用

2：實現InitializingBean介面是直接呼叫afterPropertiesSet方法，比通過反射呼叫init-method指定的方法效率相對來說要高點。但是

init-method方式消除了對spring的依賴