1.spring源码-BeanPostProcessor后置处理器

1.BeanPostProcessor接口的介绍：

BeanPostProcessor是一个接口，其中有两个方法，postProcessBeforeInitialization和postProcessAfterInitialization两个方法，这两个方法分别是在spring容器中的bean初始化前后执行，所以spring容器中的每一个bean对象初始化前后，都会执行BeanPostProcessor接口的实现类的这两个方法。因此我们可以在每个bean对象初始化前后，加上自己的逻辑。实现方式：自定义一个BeanPostProcessor接口的实现类A，然后在类A的postProcessBeforeInitialization和postProcessAfterInitialization方法里面写上自己的逻辑。

看一下BeanPostProcessor接口的代码：

 public interface BeanPostProcessor {
     @Nullable
     default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
         return bean;
     }

     @Nullable
     default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
         return bean;
     }
 }

postProcessBeforeInitialization和postProcessAfterInitialization方法中的bean参数，就是将要初始化或已经初始化的spring容器中的bean对象。

2.如何证明spring容器中的bean对象初始化前后，都会执行BeanPostProcessor实现类的postProcessBeforeInitialization和postProcessAfterInitialization两个方法：
　　a.首先spring中有一个类AbstractAutowireCapableBeanFactory
　　b.展示AbstractAutowireCapableBeanFactory的三个个方法：spring容器初始化前后，都会执行它的applyBeanPostProcessorsBeforeInitialization和applyBeanPostProcessorsAfterInitialization
　　　两个方法，而在这两个方法中都会遍历BeanPostProcessor的所有实现类，并分别执行BeanPostProcessor实现类的前置和后置方法。

     public List<BeanPostProcessor> getBeanPostProcessors() {
         return this.beanPostProcessors;
     }

     public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException {
         Object result = existingBean;

         Object current;
         //遍历所有的BeanPostProcessor实现类，spring容器中每个bean对象都要执行所有的BeanPostProcessor实现类的前置方法(postProcessBeforeInitialization)
         for(Iterator var4 = this.getBeanPostProcessors().iterator(); var4.hasNext(); result = current) {
             BeanPostProcessor beanProcessor = (BeanPostProcessor)var4.next();
             current = beanProcessor.postProcessBeforeInitialization(result, beanName);
             if(current == null) {
                 return result;
             }
         }

         return result;
     }

     public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
         Object result = existingBean;

         Object current;
         //遍历所有的BeanPostProcessor实现类，spring容器中每个bean对象都要执行所有的BeanPostProcessor实现类的后置方法(postProcessAfterInitialization)
         for(Iterator var4 = this.getBeanPostProcessors().iterator(); var4.hasNext(); result = current) {
             BeanPostProcessor beanProcessor = (BeanPostProcessor)var4.next();
             current = beanProcessor.postProcessAfterInitialization(result, beanName);
             if(current == null) {
                 return result;
             }
         }

         return result;
     }

写一个需求：
现在我有两个类分别是Dog和Bird，这两个类都有一个属性int类型age属性，现在我想把这两个类交给spring容器来管理，并在初始化时，让Dog的对象的age属性值为15，

让Bird的对象的age属性值为9. 
实现步骤：
　　1.先写好Dog和Bird两个类：

 @Component
 public class Bird {

     private int age;

     @Override
     public String toString() {
         return "Bird [age=" + age + "]";
     }
 }

 @Component
 public class Dog {

      private int age;//狗一般活到15岁

     @Override
     public String toString() {
         return "Dog [age=" + age + "]";
     }
 }

　　2.然后在写一个类MyBeanPostProcessor实现bean后置处理器接口BeanPostProcessor：

 @Component
 public class MyBeanPostProcessor implements BeanPostProcessor {
     //在bean对象初始化之前被调用 bean是Spring容器管理一个对象，beanName就是当前对象在Spring容器中关联的key
     @Override
     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
         if(bean.getClass()==Dog.class){
           try{
               Field field =    bean.getClass().getDeclaredField("age");
               field.setAccessible(true);
               field.set(bean, 15);
           }catch(Exception ex){
               ex.printStackTrace();
           }
         }else if(bean.getClass()==Bird.class){
              try{
                   Field field =    bean.getClass().getDeclaredField("age");
                   field.setAccessible(true);
                   field.set(bean, 9);
               }catch(Exception ex){
                   ex.printStackTrace();
               }
         }
         return bean;
     }

     //在bean对象初始化之后被调用 bean是Spring容器管理一个对象，beanName就是当前对象在Spring容器中关联的key
     @Override
     public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
         // TODO Auto-generated method stub
         return bean;
     }
 }

　　3.写个测试类来查看一下结果：

 public class TestMain {

     public static void main(String[] args) {
         // 1.获得Spring容器对象
         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ApplicationConfig.class);
         Dog dog = (Dog)context.getBean("dog");
         System.out.println(dog);
         Bird bird = (Bird)context.getBean("bird");
         System.out.println(bird);
     }
 }

　　4.输出结果：输出的结果满足需求。