spring开发_BeanPostProcessor

spring开发_BeanPostProcessor_Bean后处理器

项目结构：

http://www.cnblogs.com/hongten/gallery/image/112581.html

/spring_1600_Bean后处理器/src/com/b510/app/test/SpringTest.java

 1 package com.b510.app.test;
 2 
 3 import org.springframework.beans.factory.xml.XmlBeanFactory;
 4 import org.springframework.context.ApplicationContext;
 5 import org.springframework.context.support.ClassPathXmlApplicationContext;
 6 import org.springframework.core.io.ClassPathResource;
 7 
 8 import com.b510.app.util.AppBeanPostProcessor;
 9 import com.b510.service.AnimalService;
10 
11 /**
12  * 测试类，这里使用了ApplicationContext作为容器，无需手动注册BeanPostProcessor
13  * registerManually()方法提供的是手动注册BeanPostProcessor
14  * 
15  * @author Hongten
16  * 
17  */
18 public class SpringTest {
19     public static void main(String[] args) {
20         ApplicationContext act = new ClassPathXmlApplicationContext("beans.xml");
21         // 获取id为animaleServiceOfDog的Bean
22         AnimalService animalServiceOfDog = (AnimalService) act
23                 .getBean("animaleServiceOfDog");
24         animalServiceOfDog.getInfo();
25         // 获取id为animaleServiceOfCat的Bean
26         AnimalService animalServiceOfCat = (AnimalService) act
27                 .getBean("animaleServiceOfCat");
28         animalServiceOfCat.getInfo();
29         System.out
30                 .println("*************手动注册BeanPostProcessor处理结果********************");
31         registerManually();
32     }
33 
34     /**
35      * 手动注册BeanPostProcessor
36 */
37     public static void registerManually() {
38         // CLASSPATH路径下的bean.xml文件创建Resource对象
39         ClassPathResource isr = new ClassPathResource("beans.xml");
40         // 以Resource对象作为参数，创建BeanFactory的实例
41         XmlBeanFactory factory = new XmlBeanFactory(isr);
42         // 获取Bean后处理器实例
43         AppBeanPostProcessor prr = (AppBeanPostProcessor) factory.getBean(
44                 "appBeanPostProcessor", AppBeanPostProcessor.class);
45         // 注册BeanPostProcessor实例
46         factory.addBeanPostProcessor(prr);
47         // 获取id为animaleServiceOfDog的Bean
48         AnimalService animalServiceOfDog = (AnimalService) factory
49                 .getBean("animaleServiceOfDog");
50         animalServiceOfDog.getInfo();
51         // 获取id为animaleServiceOfCat的Bean
52         AnimalService animalServiceOfCat = (AnimalService) factory
53                 .getBean("animaleServiceOfCat");
54         animalServiceOfCat.getInfo();
55     }
56 }

/spring_1600_Bean后处理器/src/com/b510/app/util/AppBeanPostProcessor.java

 1 package com.b510.app.util;
 2 
 3 import org.springframework.beans.BeansException;
 4 import org.springframework.beans.factory.config.BeanPostProcessor;
 5 
 6 import com.b510.service.impl.CatServiceBean;
 7 import com.b510.service.impl.DogServiceBean;
 8 import com.b510.service.impl.FishServiceBean;
 9 import com.b510.service.impl.PorkServiceBean;
10 
11 public class AppBeanPostProcessor implements BeanPostProcessor {
12 
13     /**
14      * 对容器中的Bean实例进行后处理 参数一：需要进行后处理的原Bean实例 参数二：需要进行处理的Bean实例的名字 返回：处理完成后的Bean
15 */
16     @Override
17     public Object postProcessAfterInitialization(Object bean, String beanName)
18             throws BeansException {
19         System.out.println("postProcessAfterInitialization方法,被处理的Bean的名称为:" + beanName);
20         return bean;
21     }
22 
23     /**
24      * 对容器中的Bean实例进行后处理，给方法是在postProcessAfterInitialization()之前调用
25      * 参数一：需要进行后处理的原Bean实例 参数二：需要进行处理的Bean实例的名字 返回：处理完成后的Bean
26 */
27     @Override
28     public Object postProcessBeforeInitialization(Object bean, String beanName)
29             throws BeansException {
30         // 如果该Bean是FishServiceBean的实例
31         if (bean instanceof FishServiceBean) {
32             System.out.println("鱼肉Bean被后处理器初始化");
33         }
34         if (bean instanceof PorkServiceBean) {
35             System.out.println("猪肉Bean被后处理器初始化");
36         }
37         if (bean instanceof DogServiceBean) {
38             System.out.println("狗类Bean被后处理器初始化");
39         }
40         if (bean instanceof CatServiceBean) {
41             System.out.println("猫类Bean被后处理器初始化");
42         }
43         return bean;
44     }
45 }

/spring_1600_Bean后处理器/src/com/b510/service/AnimalService.java

 1 package com.b510.service;
 2 
 3 /**
 4  * 动物抽象类
 5  * 
 6  * @author Hongten
 7  * 
 8  */
 9 public interface AnimalService {
10 
11     /**
12      * 获取相关信息
13 */
14     public abstract void getInfo();
15 
16 }

/spring_1600_Bean后处理器/src/com/b510/service/MeatService.java

 1 package com.b510.service;
 2 
 3 /**
 4  * 定义抽象类MeatService肉类
 5  * 
 6  * @author Hongten
 7  * 
 8  */
 9 public interface MeatService {
10 
11     /**
12      * 定义方法whatMeat
13      * 
14      * @return 返回一个字符串
15 */
16     public abstract String whatMeat();
17 }

/spring_1600_Bean后处理器/src/com/b510/service/impl/CatServiceBean.java

 1 package com.b510.service.impl;
 2 
 3 import com.b510.service.AnimalService;
 4 import com.b510.service.MeatService;
 5 
 6 /**
 7  * 定义猫类实现AnimaleService抽象类
 8  * 
 9  * @author Hongten
10  * 
11  */
12 public class CatServiceBean implements AnimalService {
13     private int age;
14     private MeatService meatService;
15 
16     public CatServiceBean(){
17         System.out.println("猫类被初始化了");
18     }
19 
20     public int getAge() {
21         return age;
22     }
23 
24     @Override
25     public void getInfo() {
26         System.out.println("我是猫，我的年龄是:"+age+",我很喜欢吃"+meatService.whatMeat());
27     }
28     public MeatService getMeatService() {
29         return meatService;
30     }
31 
32     public void setAge(int age) {
33         this.age = age;
34     }
35 
36     public void setMeatService(MeatService meatService) {
37         this.meatService = meatService;
38     }
39     
40 
41 }

/spring_1600_Bean后处理器/src/com/b510/service/impl/DogServiceBean.java

 1 package com.b510.service.impl;
 2 
 3 import com.b510.service.AnimalService;
 4 import com.b510.service.MeatService;
 5 
 6 /**
 7  * 定义DogServiceBean类
 8  * 
 9  * @author Hongten
10  * 
11  */
12 public class DogServiceBean implements AnimalService {
13     private int age;
14     private MeatService meatService;
15 
16     public DogServiceBean() {
17         System.out.println("狗类被初始化了");
18     }
19 
20     public int getAge() {
21         return age;
22     }
23 
24     @Override
25     public void getInfo() {
26         System.out.println("我是狗，我的年龄是:" + age + ",我很喜欢吃"
27                 + meatService.whatMeat());
28     }
29 
30     public MeatService getMeatService() {
31         return meatService;
32     }
33 
34     public void setAge(int age) {
35         this.age = age;
36     }
37 
38     public void setMeatService(MeatService meatService) {
39         this.meatService = meatService;
40     }
41 
42 }

/spring_1600_Bean后处理器/src/com/b510/service/impl/FishServiceBean.java

 1 package com.b510.service.impl;
 2 
 3 import com.b510.service.MeatService;
 4 
 5 /**
 6  * 定义鱼肉实现MeatService抽象类
 7  * 
 8  * @author Hongten
 9  * 
10  */
11 public class FishServiceBean implements MeatService {
12 
13     public FishServiceBean(){
14         System.out.println("鱼肉类被初始化了");
15     }
16     @Override
17     public String whatMeat() {
18         return "鱼肉";
19     }
20 
21 }

/spring_1600_Bean后处理器/src/com/b510/service/impl/PorkServiceBean.java

 1 package com.b510.service.impl;
 2 
 3 import com.b510.service.MeatService;
 4 
 5 /**
 6  * 定义猪肉实现MeatService抽象类
 7  * 
 8  * @author Hongten
 9  * 
10  */
11 public class PorkServiceBean implements MeatService {
12 
13     public PorkServiceBean(){
14         System.out.println("猪肉类被初始化了");
15     }
16     @Override
17     public String whatMeat() {
18         return "猪肉";
19     }
20 
21 }

/spring_1600_Bean后处理器/src/beans.xml

 1 <?xml version="1.0" encoding="GBK"?>
 2     <!-- Spring配置文件的根元素，使用spring-beans-3.0.xsd语义约束 -->
 3 <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xmlns="http://www.springframework.org/schema/beans" xmlns:p="http://www.springframework.org/schema/p"
 5     xsi:schemaLocation="http://www.springframework.org/schema/beans
 6     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
 7 
 8     <bean id="meatServiceOfFish" class="com.b510.service.impl.FishServiceBean"></bean>
 9     <bean id="meatServiceOfPork" class="com.b510.service.impl.PorkServiceBean"></bean>
10     <bean id="animaleServiceOfDog" class="com.b510.service.impl.DogServiceBean"
11         p:age="12" p:meatService-ref="meatServiceOfPork" />
12     <bean id="animaleServiceOfCat" class="com.b510.service.impl.CatServiceBean"
13         p:age="3" p:meatService-ref="meatServiceOfFish" />
14     <!-- 配置Bean后处理器的时候，无需指定id属性,这里主要是为了展示手动注册才需要配置id属性 -->
15     <bean id="appBeanPostProcessor" class="com.b510.app.util.AppBeanPostProcessor"></bean>
16 </beans>

运行结果；

 1 2012-3-12 15:41:10 org.springframework.context.support.AbstractApplicationContext prepareRefresh
 2 信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@19c26f5: display name [org.springframework.context.support.ClassPathXmlApplicationContext@19c26f5]; startup date [Mon Mar 12 15:41:10 CST 2012]; root of context hierarchy
 3 2012-3-12 15:41:10 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
 4 信息: Loading XML bean definitions from class path resource [beans.xml]
 5 2012-3-12 15:41:13 org.springframework.context.support.AbstractApplicationContext obtainFreshBeanFactory
 6 信息: Bean factory for application context [org.springframework.context.support.ClassPathXmlApplicationContext@19c26f5]: org.springframework.beans.factory.support.DefaultListableBeanFactory@4a63d8
 7 2012-3-12 15:41:13 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
 8 信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@4a63d8: defining beans [meatServiceOfFish,meatServiceOfPork,animaleServiceOfDog,animaleServiceOfCat,appBeanPostProcessor]; root of factory hierarchy
 9 鱼肉类被初始化了
10 鱼肉Bean被后处理器初始化
11 postProcessAfterInitialization方法,被处理的Bean的名称为:meatServiceOfFish
12 猪肉类被初始化了
13 猪肉Bean被后处理器初始化
14 postProcessAfterInitialization方法,被处理的Bean的名称为:meatServiceOfPork
15 狗类被初始化了
16 狗类Bean被后处理器初始化
17 postProcessAfterInitialization方法,被处理的Bean的名称为:animaleServiceOfDog
18 猫类被初始化了
19 猫类Bean被后处理器初始化
20 postProcessAfterInitialization方法,被处理的Bean的名称为:animaleServiceOfCat
21 我是狗，我的年龄是:12,我很喜欢吃猪肉
22 我是猫，我的年龄是:3,我很喜欢吃鱼肉
23 *************手动注册BeanPostProcessor处理结果********************
24 2012-3-12 15:41:13 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
25 信息: Loading XML bean definitions from class path resource [beans.xml]
26 狗类被初始化了
27 猪肉类被初始化了
28 猪肉Bean被后处理器初始化
29 postProcessAfterInitialization方法,被处理的Bean的名称为:meatServiceOfPork
30 狗类Bean被后处理器初始化
31 postProcessAfterInitialization方法,被处理的Bean的名称为:animaleServiceOfDog
32 我是狗，我的年龄是:12,我很喜欢吃猪肉
33 猫类被初始化了
34 鱼肉类被初始化了
35 鱼肉Bean被后处理器初始化
36 postProcessAfterInitialization方法,被处理的Bean的名称为:meatServiceOfFish
37 猫类Bean被后处理器初始化
38 postProcessAfterInitialization方法,被处理的Bean的名称为:animaleServiceOfCat
39 我是猫，我的年龄是:3,我很喜欢吃鱼肉

我们可以看到，用ApplicationContext作为容器注册BeanPostProcessor的时候，他会全部装入容器后，在进行其他操作；

而我们手动注册BeanPostProcessor的时候，系统需要什么Bean的时候，就去调用相应的Bean；手动注册的BeanPostProcessor

不会一下子就全部装入所有的Bean。

这是我个人的理解，如果大家有不同的观点或看法，请大家多多指教……

大家一起讨论，这样大家才会一起进步。