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.输出结果：输出的结果满足需求。