项目结构：
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。
这是我个人的理解，如果大家有不同的观点或看法，请大家多多指教……
大家一起讨论，这样大家才会一起进步。