Spring 进阶(1) Bean后处理器

1. 水平还不够，就接受着知识吧。
2. Bean后处理器的作用就是在bean初始化的时候对bean进行进一步的处理，可以在初始化之前，也可以在初始化之后。
   1. 实现后处理器的类应该实现BeanPostProcess接口，然后重写，postProcessBeforeInitalization方法和postAfterBeforeInitalization，第一个参数是bean的实例，第二个参数是bean的id，其实你看好多都是这么实现的，让某个工具类实现啥接口或者继承什么类，然后重写什么方法，注册一下，就成了。

          Object postProcessBeforeInitialization(Object var1, String var2) throws BeansException;
      
          Object postProcessAfterInitialization(Object var1, String var2) throws BeansException;

   2. 书上那个被处理的类继承Inittializition并不是必要的，就是看看而已。bean后处理器的逻辑是判断postAfterBeforeInitalization，postProcessBeforeInitalization方法传进来的参数是什么，然后进行操作。
   3. 话有点多啦，代码奉上

      package InstanceClass;
      
      
      import org.springframework.beans.factory.InitializingBean;
      
      public class TestPostProcess implements InitializingBean {
      
          private  String showStr;
      
          public String getShowStr() {
              return showStr;
          }
      
          public void setShowStr(String showStr) {
              this.showStr = showStr;
          }
      
      
      //    这个方法可以看到bean被后处理器处理后的效果
          @Override
          public void afterPropertiesSet() throws  Exception{
              System.out.println(getShowStr());
              System.out.println("afterPropertiesSet function...");
          }
      
      }
      

      package postProcessor;
      
      import InstanceClass.TestPostProcess;
      import org.springframework.beans.factory.config.BeanPostProcessor;
      
      import java.lang.reflect.Field;
      
      public class PostProcessor implements BeanPostProcessor {
      
      //在初始化之前对bean实例进行处理
          @Override
          public Object postProcessBeforeInitialization(Object bean, String beanName){
              return  bean;
          }
      
      //在初始化之后对bean实例进行处理
          @Override
          public Object postProcessAfterInitialization(Object bean, String beanName) {
              System.out.println(beanName);
              if(bean instanceof TestPostProcess){
                  try{
      //                可以看到反射是不二之选
                      Class class1 = bean.getClass();
                      Field field = class1.getDeclaredField("showStr");
                      field.setAccessible(true);
                      field.set(bean, "javaee");
                  }catch (Exception e ){
                      e.printStackTrace();
                  }
              }
              return bean;
          }
      
      }
      

      package testPackage;
      
      import InstanceClass.TestPostProcess;
      import org.springframework.context.ApplicationContext;
      import org.springframework.context.support.ClassPathXmlApplicationContext;
      //测试类，可以看到被后处理器处理完之后ShowStr已被成功修改
      public class SpringTest {
          public static void main(String []args){
              ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
              TestPostProcess testPostProcess = applicationContext.getBean("instanceClass", TestPostProcess.class);
              System.out.println(testPostProcess.getShowStr());
          }
      }
      

      <?xml version="1.0" encoding="GBK"?>
      <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns="http://www.springframework.org/schema/beans" xmlns:util="http://www.springframework.org/schema/util"
             xsi:schemaLocation="http://www.springframework.org/schema/beans
      	http://www.springframework.org/schema/beans/spring-beans-4.0.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
      
          <!--这是一个普通bean-->
          <bean id="instanceClass" class="InstanceClass.TestPostProcess">
              <property name="showStr" value="java"/>
          </bean>
      
          <!--配置一个后处理器bean，它无需指定id，它会对所有bean进行处理-->
          <bean class="postProcessor.PostProcessor"/>
      
      </beans>

      整理一下各个方法的执行时间 

      1. 注入依赖关系

      2. postProcessBeforeInitalization方法

      3. init-method

      4. postProcessAfterInitalization方法

   4. 这是我看李刚编著的《轻量级javaEE企业应用实战（第五版）-Struts2+Spring5+Hibernate5/JAP2》后总结出来的。