[Java] spring BeanProcessor接口详解

• 在业务流程中，根据beanprocessor接口方法加在不同的位置(一般是前后)，可以实现对业务逻辑的扩展。
  
• 在业务逻辑执行前，beanprocessor的实现类必须已经被创建完成(beanprocessor接口类必须要优先实例化)。
  

//net.postprocessor.customerpostprocessor
@component
public class customerpostprocessor implements beanpostprocessor {
 
  @postconstruct
  public void init(){
   system.out.println("执行customerpostprocessor的postconstruct");
  }
 
  public customerpostprocessor(){
   system.out.println("执行customerpostprocessor的构造方法");
  }
 
  @override
  public object postprocessbeforeinitialization(object bean, string beanname) throws beansexception {
   system.out.println(bean+"======beforeinitialization======"+ beanname);
   return bean;
  }
 
  @override
  public object postprocessafterinitialization(object bean, string beanname) throws beansexception {
   system.out.println(bean+"======afterinitialization======"+ beanname);
   return bean;
  }
 
}

//net.postprocessor.customerinitialpostprocessor
@component
public class customerinitialpostprocessor implements instantiationawarebeanpostprocessor {
 
  @postconstruct
  public void init(){
   system.out.println("执行customerinitialpostprocessor的postconstruct");
  }
 
  public customerinitialpostprocessor(){
   system.out.println("执行customerinitialpostprocessor的构造方法");
  }
 
  @override
  public object postprocessbeforeinstantiation(class<?> beanclass, string beanname) throws beansexception {
   system.out.println("bean初始化前执行：class为"+beanclass.getname()+"|beanname为"+beanname);
   return null;
  }
 
  @override
  public boolean postprocessafterinstantiation(object bean, string beanname) throws beansexception {
   system.out.println("bean初始化后执行：object为"+bean+"|beanname为"+beanname);
   return false;
  }
}

//net.postprocessor.firstbean
@component
public class firstbean implements initializingbean {
 
  private string msg = "hello";
 
  @postconstruct
  public void init(){
   system.out.println("执行firstbean的postconstruct");
  }
 
  public firstbean(){
   system.out.println("firstbean构造方法！"+msg);
  }
 
  public string getmsg() {
   return msg;
  }
 
  public void setmsg(string msg) {
   this.msg = msg;
  }
 
  @override
  public void afterpropertiesset() throws exception {
   system.out.println("执行firstbean的afterpropertiesset");
  }
}

@test
public void test(){
  annotationconfigapplicationcontext applicationcontext = new annotationconfigapplicationcontext("net.postprocessor");
}
//执行得到以下结果：
执行customerinitialpostprocessor的构造方法
执行customerinitialpostprocessor的postconstruct
执行customerpostprocessor的构造方法
执行customerpostprocessor的postconstruct
  
bean初始化前执行：class为net.postprocessor.firstbean|beanname为firstbean
firstbean构造方法！hello
bean初始化后执行：object为net.postprocessor.firstbean@79179359|beanname为firstbean
  
net.postprocessor.firstbean@79179359======beforeinitialization======firstbean
执行firstbean的postconstruct
执行firstbean的afterpropertiesset
net.postprocessor.firstbean@79179359======afterinitialization======firstbean

• 创建个接口a，接口包含一些切点方法(before、after、around之类的)，实现这个接口a的类要在使用前就创建好
  
• 我们需要有个业务流程，这个业务流程由若干步组成；将接口a的接口方法插入到这些业务步骤之间(需要扩展的地方)
  
• 要执行这个业务流程时，把接口a的实现类对象赋值到业务流程中，在执行业务流程中，就会触发接口方法的执行完成功能扩展
  

@component
public class secondbean {
 
  private string msg = "world";
 
  public secondbean(){
   system.out.println("secondbean构造方法！"+msg);
  }
 
  public string getmsg() {
   return msg;
  }
 
  public void setmsg(string msg) {
   this.msg = msg;
  }
}

@component
public class customerpostprocessor implements beanpostprocessor {
 
  @postconstruct
  public void init(){
   system.out.println("执行customerpostprocessor的postconstruct");
  }
 
  public customerpostprocessor(){
   system.out.println("执行customerpostprocessor的构造方法");
  }
 
  @override
  public object postprocessbeforeinitialization(object bean, string beanname) throws beansexception {
   system.out.println(bean+"======beforeinitialization======"+ beanname);
   return bean;
  }
 
  @override
  public object postprocessafterinitialization(object bean, string beanname) throws beansexception {
   system.out.println(bean+"======afterinitialization======"+ beanname);
   return bean;
  }
 
}

public class postprocessor {
 
  //模拟扫描到的bean信息<"secondbean", "net.postprocessor.secondbean">
  map<string, string> scanbeanmap = new hashmap<>();
 
  //模拟spring的beanpostprocessors列表
  list<beanpostprocessor> processorbeanlist = new arraylist<>();
 
  //模拟bean对象缓存
  map<string, object> beancache = new hashmap<>();
 
  //添加扫描的bean信息
  public postprocessor addbeaninfo(string beanname, string classpath){
   this.scanbeanmap.put(beanname, classpath);
   return this;
  }
 
  //模拟bean创建流程
  public object execute(){
   try {
   //先临时存储实现了postprocessor接口的bean对象
   list<beanpostprocessor> postprocessorstrlist = new arraylist<>();
   //循环scanbeanmap，获取bean列表中实现了postprocessor接口的类，加入processorbeanlist中
   for(string temp: scanbeanmap.keyset()){
    class<?> clazz = class.forname(scanbeanmap.get(temp));
    //判断是否实现了beanpostprocessor接口
    if(beanpostprocessor.class.isassignablefrom(clazz)){
    //实例化让如临时容器
    postprocessorstrlist.add((beanpostprocessor)createbean(temp));
    }
   }
   //将实现了postprocessor接口的bean加入processorbeanlist中
   for(beanpostprocessor obj: postprocessorstrlist){
    processorbeanlist.add(obj);
   }
 
   //再次循环scanbeanmap初始化所用bean
   for(string temp: scanbeanmap.keyset()){
    createbean(temp);
   }
 
   } catch (classnotfoundexception e) {
   e.printstacktrace();
   }
   return null;
  }
 
  //bean实例化
  public object createbean(string beanname){
   //从缓存中获取
   if(beancache.containskey(beanname)){
   return beancache.get(beanname);
   }else{
   //缓存中取不到，则进行创建后加入缓存
   try {
    class<?> clazz = class.forname(scanbeanmap.get(beanname));
    //processor前置方法执行
    for(beanpostprocessor processor : processorbeanlist){
    processor.postprocessbeforeinitialization(clazz, beanname);
    }
 
    //bean实例化
    object result = clazz.getconstructor().newinstance();
 
    //processor后置方法执行
    for(beanpostprocessor processor : processorbeanlist){
    processor.postprocessafterinitialization(result, beanname);
    }
 
    //将bean加入缓存
    beancache.put(beanname, result);
    return result;
   } catch (classnotfoundexception e) {
    e.printstacktrace();
   } catch (illegalaccessexception e) {
    e.printstacktrace();
   } catch (instantiationexception e) {
    e.printstacktrace();
   } catch (nosuchmethodexception e) {
    e.printstacktrace();
   } catch (invocationtargetexception e){
    e.printstacktrace();
   }
   }
   return null;
  }
 
}

public static void main(string[] args) {
  postprocessor postprocessor = new postprocessor();
  //添加扫描到的bean
  postprocessor
  .addbeaninfo("secondbean", "net.postprocessor.secondbean")
  .addbeaninfo("customerpostprocessor", "net.postprocessor.customerpostprocessor");
  postprocessor.execute();
}
 
//执行结果
执行customerpostprocessor的构造方法
class net.postprocessor.secondbean======beforeinitialization======secondbean
secondbean构造方法！world
net.postprocessor.secondbean@1b40d5f0======afterinitialization======secondbean

• 循环bean信息列表，将beanpostprocessor接口bean分离出来优先实例化(实例化中缓存bean对象)，并将之放入临时容器。
  
• 循环完成，将临时容器中的beanpostprocessor接口bean赋值到全局beanpostprocessor接口列表中
  
• 再次循环bean信息列表，缓存存在则直接返回缓存对象，不存在则进行bean实例化，期间循环调用全局beanpostprocessor接口对象方法
  

public void refresh() throws beansexception, illegalstateexception {
  synchronized (this.startupshutdownmonitor) {
   // prepare this context for refreshing.
   //刷新准备
   preparerefresh();
 
   // tell the subclass to refresh the internal bean factory.
   //告诉子类刷新内部bean工厂。
   configurablelistablebeanfactory beanfactory = obtainfreshbeanfactory();
 
   // prepare the bean factory for use in this context.
   //为容器准备bean工程
   preparebeanfactory(beanfactory);
 
   try {
   // allows post-processing of the bean factory in context subclasses.
   //允许在上下文bean的后处理工厂子类。
   postprocessbeanfactory(beanfactory);
 
   // invoke factory processors registered as beans in the context.
   //优先将beandefinitionregistrypostprocessor\beanfactorypostprocessor接口的bean对象实例化
   //属于spring内部组件调用
   invokebeanfactorypostprocessors(beanfactory);
 
   // register bean processors that intercept bean creation.
   //处理用户自定义postprocessor接口对象，之后加入spring的beanpostprocessors列表，
   // 供之后预实例化其他bean时触发这些postprocessor方法
   registerbeanpostprocessors(beanfactory);
 
    //...省略代码
  //实例化所有(non-lazy-init)单件。
    finishbeanfactoryinitialization(beanfactory);
   }
 
   catch (beansexception ex) {
   if (logger.iswarnenabled()) {
    logger.warn("exception encountered during context initialization - " +
     "cancelling refresh attempt: " + ex);
   }
 
   // destroy already created singletons to avoid dangling resources.
   //bean销毁
   destroybeans();
 
   // reset 'active' flag.
   //取消刷新
   cancelrefresh(ex);
 
   // propagate exception to caller.
   throw ex;
   }
 
   finally {
   // reset common introspection caches in spring's core, since we
   // might not ever need metadata for singleton beans anymore...
   //重置公共缓存
   resetcommoncaches();
   }
  }
}

• postprocessbeanfactory(beanfactory)，这个是一共空的扩展方法，显然无关
  
• invokebeanfactorypostprocessors(beanfactory)，处理spring中实现了beanprocessor接口的内部组件直接调用接口方法
  
• registerbeanpostprocessors(beanfactory)，实例化用户自定义beanprocessor接口bean组件，之后循环赋值到全局beanprocessor列表中
  

//abstractapplicationcontext#registerbeanpostprocessors
protected void registerbeanpostprocessors(configurablelistablebeanfactory beanfactory) {
  //委托给postprocessorregistrationdelegate.registerbeanpostprocessors进行处理
  postprocessorregistrationdelegate.registerbeanpostprocessors进行处理(beanfactory, this);
}

public static void registerbeanpostprocessors(
   configurablelistablebeanfactory beanfactory, abstractapplicationcontext applicationcontext) {
 
  //查询实现了beanpostprocessor接口的beanname
  string[] postprocessornames = beanfactory.getbeannamesfortype(beanpostprocessor.class, true, false);
 
  // register beanpostprocessorchecker that logs an info message when
  // a bean is created during beanpostprocessor instantiation, i.e. when
  // a bean is not eligible for getting processed by all beanpostprocessors.
  int beanprocessortargetcount = beanfactory.getbeanpostprocessorcount() + 1 + postprocessornames.length;
  beanfactory.addbeanpostprocessor(new beanpostprocessorchecker(beanfactory, beanprocessortargetcount));
 
  // separate between beanpostprocessors that implement priorityordered,
  // ordered, and the rest.
  list<beanpostprocessor> priorityorderedpostprocessors = new arraylist<>();
  list<beanpostprocessor> internalpostprocessors = new arraylist<>();
  list<string> orderedpostprocessornames = new arraylist<>();
  list<string> nonorderedpostprocessornames = new arraylist<>();
  //根据beanname循环调用getbean进行实例化
  for (string ppname : postprocessornames) {
   if (beanfactory.istypematch(ppname, priorityordered.class)) {
   beanpostprocessor pp = beanfactory.getbean(ppname, beanpostprocessor.class);
   priorityorderedpostprocessors.add(pp);
   if (pp instanceof mergedbeandefinitionpostprocessor) {
    internalpostprocessors.add(pp);
   }
   }
   else if (beanfactory.istypematch(ppname, ordered.class)) {
   orderedpostprocessornames.add(ppname);
   }
   else {
   nonorderedpostprocessornames.add(ppname);
   }
  }
 
  // first, register the beanpostprocessors that implement priorityordered.
  //对beanpostprocessor接口对象进行排序
  sortpostprocessors(priorityorderedpostprocessors, beanfactory);
  //将获取到的postprocessors接口对象加入到spring的beanpostprocessors列表
  registerbeanpostprocessors(beanfactory, priorityorderedpostprocessors);
 
  // next, register the beanpostprocessors that implement ordered.
  list<beanpostprocessor> orderedpostprocessors = new arraylist<>();
  for (string ppname : orderedpostprocessornames) {
   beanpostprocessor pp = beanfactory.getbean(ppname, beanpostprocessor.class);
   orderedpostprocessors.add(pp);
   if (pp instanceof mergedbeandefinitionpostprocessor) {
   internalpostprocessors.add(pp);
   }
  }
  sortpostprocessors(orderedpostprocessors, beanfactory);
  registerbeanpostprocessors(beanfactory, orderedpostprocessors);
 
  // now, register all regular beanpostprocessors.
  list<beanpostprocessor> nonorderedpostprocessors = new arraylist<>();
  for (string ppname : nonorderedpostprocessornames) {
   beanpostprocessor pp = beanfactory.getbean(ppname, beanpostprocessor.class);
   nonorderedpostprocessors.add(pp);
   if (pp instanceof mergedbeandefinitionpostprocessor) {
   internalpostprocessors.add(pp);
   }
  }
  registerbeanpostprocessors(beanfactory, nonorderedpostprocessors);
 
  // finally, re-register all internal beanpostprocessors.
  sortpostprocessors(internalpostprocessors, beanfactory);
  registerbeanpostprocessors(beanfactory, internalpostprocessors);
 
  // re-register post-processor for detecting inner beans as applicationlisteners,
  // moving it to the end of the processor chain (for picking up proxies etc).
  beanfactory.addbeanpostprocessor(new applicationlistenerdetector(applicationcontext));
}

• 循环扫描到的bean列表，获取实现了beanpostprocessor接口的beanname数组
  
• 循环beanname数组数组，调用beanfactory.getbean()将bean实例化，并放入priorityorderedpostprocessors列表中
  
• 调用sortpostprocessors对priorityorderedpostprocessors列表进行排序(处理beanpostprocessor调用的顺序)
  
• 调用registerbeanpostprocessors将priorityorderedpostprocessors列表中的bean对象赋值到全局列表beanpostprocessors中
  
• 回到refresh()中，当调用finishbeanfactoryinitialization()对所用bean进行预实例化时就会调用这些beanpostprocessor接口方法