Spring 的几个接口

Spring 的几个接口

1.InitializingBean接口，在初始化Bean时容器会调用前者的afterPropertiesSet() 方法

2.DisposableBean接口，在析构Bean时容器会调用destroy()方法，在下面的例子中好像没有体现出来（革命尚未成功，同志仍需努力）

3.BeanFactoryAware接口，当它被BeanFactory创建后，它会拥有一个指向创建它的BeanFactory的引用

4.BeanPostProcessor接口，这个接口两个方法，postProcessBeforeInitialization(Object bean, String beanName)和postProcessAfterInitialization(Object bean, String beanName) 在其他Bean构造前后执行

5.BeanFactoryPostProcessor接口，Spring IoC容器允许BeanFactoryPostProcessor在容器实际实例化任何其它的bean之前 读取配置元数据，并有可能修改它

 

下面来看一下例子

1. package  com.test;
3. public   class  User {
4.      private  String name;
5.     
6.      public  String getName() {
7.          return  name;
8.     }
10.      public   void  setName(String name) {
11.         System.out.println( "User类 setName方法" );
12.          this .name = name;
13.     }
14.      public   void  init()  throws  Exception {
15.         System.out.println( "User类init 方法" );
16.         
17.     }
18.      public  User(){
19.         System.out.println( "User类构造方法" );
20.     }
21.     
22. }

 

1. package  com.test;
3. import  org.springframework.beans.BeansException;
4. import  org.springframework.beans.factory.BeanFactory;
5. import  org.springframework.beans.factory.BeanFactoryAware;
6. import  org.springframework.beans.factory.DisposableBean;
7. import  org.springframework.beans.factory.InitializingBean;
8. import  org.springframework.beans.factory.config.BeanFactoryPostProcessor;
9. import  org.springframework.beans.factory.config.BeanPostProcessor;
10. import  org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
12. public   class  JavaBean  implements  InitializingBean,DisposableBean,BeanFactoryAware,BeanPostProcessor ,BeanFactoryPostProcessor{
13.      private  String name;
14.      public  JavaBean(){
15.         System.out.println( "JavaBean类构造方法" );
16.     }
17.      @Override
18.      public   void  afterPropertiesSet()  throws  Exception {
19.         System.out.println( "InitializingBean 接口 afterPropertiesSet方法" );
20.         
21.     }
23.      @Override
24.      public   void  destroy()  throws  Exception {
25.         System.out.println( "DisposableBean 接口 destroy方法" );
26.         
27.     }
28.      public   void  init()  throws  Exception {
29.         System.out.println( "JavaBean类init 方法" );
30.         
31.     }
33.      @Override
34.      public   void  setBeanFactory(BeanFactory beanFactory)  throws  BeansException {
35.         System.out.println( "BeanFactoryAware 接口 setBeanFactory方法" );
36.         
37.     }
39.      @Override
40.      public  Object postProcessAfterInitialization(Object bean, String beanName)
41.              throws  BeansException {
42.         System.out.println(beanName+ ":BeanPostProcessor 接口 postProcessAfterInitialization方法" );
43.          return  bean;
44.     }
46.      @Override
47.      public  Object postProcessBeforeInitialization(Object bean, String beanName)
48.              throws  BeansException {
49.         System.out.println(beanName+ ":BeanPostProcessor 接口 postProcessBeforeInitialization 方法" );
50.          return  bean;
51.     }
53.      public  String getName() {
54.          return  name;
55.     }
57.      public   void  setName(String name) {
58.         System.out.println( "JavaBean类setName 方法" );
59.          this .name = name;
60.     }
61.      @Override
62.      public   void  postProcessBeanFactory(
63.             ConfigurableListableBeanFactory beanFactory)  throws  BeansException {
64.         System.out.println( "BeanFactoryPostProcessor 接口 postProcessBeanFactory 方法" );
65.     }
66.     
68. }

 

1. package  com.test;
3. import  org.springframework.context.ApplicationContext;
4. import  org.springframework.context.support.ClassPathXmlApplicationContext;
6. public   class  Test {
8.      /**
9.      * @param args
10.      */
11.      public   static   void  main(String[] args) {
12.         System.out.println( "加载Spring配置文件" );
13.          ApplicationContext context =  
14.                  new  ClassPathXmlApplicationContext( "spring.xml" ); 
15.          System.out.println( "加载Spring配置文件结束" );
16.          JavaBean bean=(JavaBean)context.getBean( "javaBean" );
17.          System.out.println( "获取name属性：" +bean.getName());
18.          System.out.println( "程序结束" );
19.     }
21. }

Spring配置文件

 

1. <? xml   version = "1.0"   encoding = "UTF-8" ?>  
2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
3. < beans >
4.      < bean   id = "javaBean"   class = "com.test.JavaBean"   init-method = "init" >
5.          < property   name = "name"   value = "zhjb" > </ property >
6.      </ bean >
7.      < bean   id = "user"   class = "com.test.User"   init-method = "init" >
8.          < property   name = "name"   value = "zhjb"   > </ property >
9.      </ bean >
10. </ beans >

运行结果如下：

加载Spring配置文件
JavaBean类构造方法
JavaBean类setName 方法
BeanFactoryAware 接口 setBeanFactory方法
InitializingBean 接口 afterPropertiesSet方法
JavaBean类init 方法
BeanFactoryPostProcessor 接口 postProcessBeanFactory 方法
User类构造方法
User类 setName方法
user:BeanPostProcessor 接口 postProcessBeforeInitialization 方法
User类init 方法
user:BeanPostProcessor 接口 postProcessAfterInitialization方法
加载Spring配置文件结束
获取name属性：zhjb
程序结束

 

从结果进行分析，Bean的初始化顺序应该是

1.构造函数

2.初始化属性

3.如果实现了BeanFactoryAware 接口执行setBeanFactory方法

4..如果实现了InitializingBean 接口执行afterPropertiesSet方法

5.如果在配置文件中指定了init-method，那么执行该方法

6..如果实现了BeanFactoryPostProcessor 接口在 “new”其他类之前执行 postProcessBeanFactory 方法（通过这个方法可以改变配置文件里面的属性值的配置）

7.如果实现了BeanFactoryPostProcessor 接口，那么会在其他bean初始化方法之前执行postProcessBeforeInitialization 方法，之后执行postProcessAfterInitialization方法

感觉奇怪的地方就是没有执行destroy方法，目前还不知道原因在什么地方

 

 

　　LifeCycle

　　1. InitializingBean/init-method

　　实现org.springframework.beans.factory.InitializingBean接口允许一个bean在他的所有必需的属性被BeanFactory设置后，来执行初始化的工作。

　　当然可以使用init-method来取代实现这个接口，以让应用不与spring产生耦合。

　　如果一个bean既实现了InitializingBean，又指定了init-method,则spring会先调InitializingBean的方法，在调init-method指定的方法。

　　2. DisposableBean/destroy-method

　　实现org.springframework.beans.factory.DisposableBean接口允许一个bean，可以在包含他的BeanFactory销毁的时候得到一个回调。

　　注意：BeanFactory对bean的管理默认是单实例的，如果bean不是单示例的，spring就不能管理他的生命周期。

　　3. BeanFactoryAware

　　对于实现了org.springframework.beans.factory.BeanFactoryAware接口的类，当它被BeanFactory创建后，它会拥有一个指向创建他的BeanFactory的引用。

　　4. BeanNameAware

　　如果一个bean实现了org.springframework.beans.factory.BeanNameAware接口，并且被部署到 一个BeanFactory中，那么BeanFactory就会通过这个接口来调用bean,以便通知这个bean他被部署的id。这个回调发生在普通的 bean属性设置之后，在初始化回调之前，比如InitializingBean的afterProperteis方法（或者自定义的init- method)。

　　Bean的生命周期如下

　　1. Bean的构造

　　2. 调用setXXX()方法设置Bean的属性

　　3. 调用BeanNameAware的setBeanName();

　　4. 调用BeanFactoryAware的setBeanFactory()方法

　　5. 调用BeanPostProcessor的postProcessBeforeInitialization()方法

　　6. 调用InitializingBean的afterPropertiesSet()方法

　　7. 调用自定义的初始化方法

　　8. 调用BeanPostProcessor类的postProcessAfterInitialization()方法

　　9. 调用DisposableBean的destroy()方法

　　10. 调用自定义的销毁方法。