如何理解BeanPostProcessor

==> 学习汇总（持续更新）
==> 从零搭建后端基础设施系列（一）-- 背景介绍

---

• 原始片段
  创建bean的时候，有这么一段代码，遍历所有实现了BeanPostProcessor这个接口的类，并一个个调用其中的方法。

  protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
  	for (BeanPostProcessor bp : getBeanPostProcessors()) {
  		if (bp instanceof InstantiationAwareBeanPostProcessor) {
  			InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  			Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
  			if (result != null) {
  				return result;
  			}
  		}
  	}
  	return null;
  }
  

  相信看到这里，就差不多可以理解这个接口的用途。这就是框架的可扩展性，把结构搭出来，然后你可以往里面填东西。

• 自制一个简单的case

  • 接口类

    interface BeanProcessor {
    	void beforeCreate();
    	void aroundCreate();
    	void afterCreate();
    }
    

  • 实现类A

    public class A implements BeanProcessor{
    
    	@Override
     	public void beforeCreate() {
    		System.out.println("A创建之前做点啥");
    	}
    
     	@Override
    	public void aroundCreate() {
    		System.out.println("A正在创建的时候做点啥");
    	}
    
    	@Override
    	public void afterCreate() {
    		System.out.println("A创建完了做点啥");
    	}
    }
    

  • 实现类B

    public class B implements BeanProcessor{
    
    	@Override
     	public void beforeCreate() {
    		System.out.println("B创建之前做点啥");
    	}
    
     	@Override
    	public void aroundCreate() {
    		System.out.println("B正在创建的时候做点啥");
    	}
    
    	@Override
    	public void afterCreate() {
    		System.out.println("B创建完了做点啥");
    	}
    }
    

  • 业务逻辑

    public class Main {
    	public static void main(String[] args) {
    		Reflections reflections = new Reflections("com.acme.test");
            		Set<Class<? extends BeanProcessor>> subClass = reflections.getSubTypesOf(BeanProcessor.class);
            System.out.println("开始创建……");
            subClass.forEach(v -> {
                try {
                    v.newInstance().beforeCreate();
                } catch (Throwable e) {
                    e.printStackTrace();
                }
            });
            System.out.println("正在创建……");
            subClass.forEach(v -> {
                try {
                    v.newInstance().aroundCreate();
                } catch (Throwable e) {
                    e.printStackTrace();
                }
            });
            System.out.println("结束创建……");
            subClass.forEach(v -> {
                try {
                    v.newInstance().afterCreate();
                } catch (Throwable e) {
                    e.printStackTrace();
                }
            });
        }
    }
    

  然后我们以后还有CDEFG等等类似的需求，都可以这样扩展。

• 思考
  为什么挑这个点讲呢？其实是最近对于代码重构有自己的一些想法。大家都在疯狂去diss业务代码，却没有认真的去思考自己写的代码是否合格，可扩展性真的不是说一说，要落到实地去，这样既能提高自己的水平，还能惠及后人，接手项目的时候，就不再是"接锅侠"了。总结一点就是，不管是什么代码，永远记住，将基本或者大概率不会变的逻辑封装起来，将可能或频繁变更的点，以接口的形式暴露出来。这样，不管来多少个类似的需求，那不是轻轻松松的就搞定了吗？