Java 确保某个Bean类被最后执行的几种实现方式
一、事出有因
最近有一个场景，因同一个项目中不同JAR包依赖同一个组件，但依赖组件的版本不同，导致无论使用哪个版本都报错（无法同时兼容两个JAR包中所需的方法调用），经过分析发现差异的部份是在一个BEAN中的方法出入参不同而矣，故考虑通过动态替换掉这个存在兼容性的BEAN，换成我们自己继承自该BEAN类并实现适配兼容方法，从而最终解决组件版本不兼容问题；
二、解决方案困境
但在实现的编码过程中发现，原依赖的那个BEAN并不是普通的通过标注@Compent之类的注解实现的注册的BEAN，而是由自定义的BeanDefinitionRegistryPostProcessorBEAN类中动态注册的BEAN，这样BEAN的注册顺序是“无法确定”的，我原本想通过自定义一个BeanDefinitionRegistryPostProcessorBEAN类，在postProcessBeanDefinitionRegistry方法中通过找到原依赖BEAN的名字，然后移除该名称对应的BEAN定义信息（BeanDefinition），最后再以原BEAN的名字定义并注册成为我自己的适配器的BEAN类，这样就实现了“移花接木”的功能，然而想法是OK的但最终运行起来，发现BEAN并没有成功被替换，究其原因发现，原来我自己定义的BeanDefinitionRegistryPostProcessorBEAN类是优先于原依赖的那个问题BEAN所对应的BeanDefinitionRegistryPostProcessorBEAN类之前执行的，这样就会导致在我的自定义BeanDefinitionRegistryPostProcessorBEAN类postProcessBeanDefinitionRegistry方法中并没有找到原依赖BEAN名字对应的BeanDefinition，也就无法进行正常的替换了，如果说文字难看懂，可以见如下图所示：
三、柳暗花明，终级解决方案
既然问题根源找到，那确保一个自定义的BeanDefinitionRegistryPostProcessor类被最后定义为Bean、且被最后执行成为关键（至少得比原依赖的那个问题BEAN所对应的BeanDefinitionRegistryPostProcessorBEAN类【如：OldBeanDefinitionRegistryPostProcessor】之后执行才行），因为这样我们才能获得原依赖的问题Bean的BeanDefinition,才能进行正常的替换BeanDefinition，最终达到原来依赖问题Bean的自动都依赖到新的适配器Bean，从而可以控制修改问题方法的中的逻辑（比如：兼容、降级）。当然，我估计此时有人会想说，何必这么麻烦，一个AOP切面不就搞定了吗？通过实现@Around切面，把有问题的方法拦截替换成自己的适配方法逻辑，这种确实也是一种有效手段，但我认为不够优雅，而且代码的可读性不强且未必能覆盖所有方法，比如：如果涉及问题方法内部依赖的内部方法（如protected）过多或依赖的其它BEAN过多时，可能就会导致这个切面类里面要复制一堆的原问题BEAN类中的内部方法到切面类中，但这样带来的风险就是代码重复及原代码更新后导致的不一致等隐性问题，故我的原则是：如果只是简单的替换原有方法且逻辑不复杂的可以使用AOP切面来解决，但如果涉及复杂的业务逻辑且内部依赖过多，这时采取代理、适配或装饰可能更为合适一些。
好了，如下就是我要分享的三种：确保一个自定义的BeanDefinitionRegistryPostProcessor类被最后定义为Bean、且被最后执行的实现方式。
第一种实现方案
第一种：通过嵌套注册自定义的BeanDefinitionRegistryPostProcessor类BEAN的方式，这种方式实现思路是：PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors会先执行已获得BeanDefinitionRegistryPostProcessorBEAN集合，执行完这些BEAN集合后（这里我称为第一轮或第一层），会再次尝试获取第二轮、第三轮一直到获取的BeanDefinitionRegistryPostProcessorBEAN集合全部处理完成为止，框架相关代码片段如下：
booleanreiterate=true;
while(reiterate){
reiterate=false;
postProcessorNames=beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class,true,false);
for(StringppName:postProcessorNames){
if(!processedBeans.contains(ppName)){
currentRegistryProcessors.add(beanFactory.getBean(ppName,BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate=true;
}
}
sortPostProcessors(currentRegistryProcessors,beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors,registry);
currentRegistryProcessors.clear();
}
实现方式代码如下：
//如下是第一层自定义的BeanDefinitionRegistryPostProcessorBEAN，内部再注册真正用于替换BEAN目的NewBeanDefinitionRegistryPostProcessorBEAN
//author:zuowenjun
@Component
publicclassFirstDynamicBeanPostProcessorimplementsBeanDefinitionRegistryPostProcessor{
@Override
publicvoidpostProcessBeanDefinitionRegistry(BeanDefinitionRegistrybeanDefinitionRegistry)throwsBeansException{
BeanDefinitionBuilderbeanDefinitionBuilder=BeanDefinitionBuilder.genericBeanDefinition(NewBeanDefinitionRegistryPostProcessor.class);
beanDefinitionRegistry.registerBeanDefinition("newBeanDefinitionRegistryPostProcessor",beanDefinitionBuilder.getBeanDefinition());
System.out.printf("【%1$tF%1$tT.%1$tL】%s,FirstDynamicBeanPostProcessor.postProcessBeanDefinitionRegistry%n",newDate());
}
@Override
publicvoidpostProcessBeanFactory(ConfigurableListableBeanFactoryconfigurableListableBeanFactory)throwsBeansException{
System.out.printf("【%1$tF%1$tT.%1$tL】%s,FirstDynamicBeanPostProcessor.postProcessBeanFactory%n",newDate());
}
}
//用于将原依赖的问题Bean替换为同名的新的适配器Bean(下文中所有替换方式最终都要使用该类)
publicclassNewBeanDefinitionRegistryPostProcessorimplementsBeanDefinitionRegistryPostProcessor{
@Override
publicvoidpostProcessBeanDefinitionRegistry(BeanDefinitionRegistrybeanDefinitionRegistry)throwsBeansException{
System.out.printf("【%1$tF%1$tT.%1$tL】%s,NewBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry%n",newDate());
booleanisContainsSpecialBean=((DefaultListableBeanFactory)beanDefinitionRegistry).containsBean("old问题Bean名称");
if(isContainsSpecialBean){
beanDefinitionRegistry.removeBeanDefinition("old问题Bean名称");
BeanDefinitionBuilderbeanDefinitionBuilder=BeanDefinitionBuilder.genericBeanDefinition(DemoCompentB.class);
beanDefinitionBuilder.addConstructorArgValue(((DefaultListableBeanFactory)beanDefinitionRegistry).getBean(NewBeanAdapter.class));//NewBeanAdapter为继承自old问题Bean的装饰者、适配器类
AbstractBeanDefinitionbeanDefinition=beanDefinitionBuilder.getBeanDefinition();
beanDefinition.setPrimary(true);
beanDefinitionRegistry.registerBeanDefinition("old问题Bean名称",beanDefinition);
}
}
@Override
publicvoidpostProcessBeanFactory(ConfigurableListableBeanFactoryconfigurableListableBeanFactory)throwsBeansException{
System.out.printf("【%1$tF%1$tT.%1$tL】%s,NewBeanDefinitionRegistryPostProcessor.postProcessBeanFactory%n",newDate());
}
}
最终执行的顺序如下：(可以看到NewBeanDefinitionRegistryPostProcessor是在OldBeanDefinitionRegistryPostProcessor之后执行的，这样就可以正常替换Bean定义了)
FirstDynamicBeanPostProcessor.postProcessBeanDefinitionRegistry(第一轮)
OldBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry(第一轮)
NewBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry（第二轮）
FirstDynamicBeanPostProcessor.postProcessBeanFactory
OldBeanDefinitionRegistryPostProcessor.postProcessBeanFactory
NewBeanDefinitionRegistryPostProcessor.postProcessBeanFactory
第二种实现方案
第二种：通过额外定义一个BeanDefinitionRegistryPostProcessorBEAN并实现PriorityOrdered、BeanFactoryAware接口，确保该BEAN最先被执行(Order=0)，然后在postProcessBeanDefinitionRegistry方法中通过applicationContext.setDependencyComparator设置自定义的排序器，达到排序BeanDefinitionRegistryPostProcessorBEAN集合的执行顺序，这种方式实现思路是：在执行BeanDefinitionRegistryPostProcessorBEAN集合前会调用sortPostProcessors方法进行排序，而排序规则又依赖于DependencyComparator，通过控制排序规则实现间接控制执行顺序，先看框架的代码片段：
privatestaticvoidsortPostProcessors(ListpostProcessors,ConfigurableListableBeanFactorybeanFactory){
Comparator
实现方式代码如下：
@Component
publicstaticclassFirstBeanDefinitionRegistryPostProcessorimplementsBeanDefinitionRegistryPostProcessor,PriorityOrdered
,BeanFactoryAware{
privateBeanFactorybeanFactory;
@Override
publicvoidsetBeanFactory(BeanFactorybeanFactory)throwsBeansException{
this.beanFactory=beanFactory;
}
@Override
publicvoidpostProcessBeanDefinitionRegistry(BeanDefinitionRegistrybeanDefinitionRegistry)throwsBeansException{
((DefaultListableBeanFactory)beanFactory).setDependencyComparator(newOrderComparator(){
@Override
protectedintgetOrder(Objectobj){
if(objinstanceofNewBeanDefinitionRegistryPostProcessor){//如果是NewBeanDefinitionRegistryPostProcessor则将它的排序序号设置为最大
returnInteger.MAX_VALUE;
}
returnsuper.getOrder(obj)-1;//其余的全部设为比它小1
}
});
System.out.printf("【%1$tF%1$tT.%1$tL】%s,FirstBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry%n",newDate());
}
@Override
publicvoidpostProcessBeanFactory(ConfigurableListableBeanFactoryconfigurableListableBeanFactory)throwsBeansException{
System.out.printf("【%1$tF%1$tT.%1$tL】%s,FirstBeanDefinitionRegistryPostProcessor.postProcessBeanFactory%n",newDate());
}
@Override
publicintgetOrder(){
return0;//确保
}
}
最终执行的顺序如下：（NewBeanDefinitionRegistryPostProcessor在OldBeanDefinitionRegistryPostProcessor后面执行）
FirstBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry（第1批：实现PriorityOrdered执行）
OldBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry（第3批：普通BEAN执行）
NewBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry（第3批：普通BEAN执行）
FirstBeanDefinitionRegistryPostProcessor.postProcessBeanFactory
OldBeanDefinitionRegistryPostProcessor.postProcessBeanFactory
NewBeanDefinitionRegistryPostProcessor.postProcessBeanFactory
第三种实现方案
第三种：通过自定义DeferredImportSelector类并配合@Import注解，实现NewBeanDefinitionRegistryPostProcessor最后才被注册成为BEAN，最后才有机会执行，这种方式实现思路是：因为DeferredImportSelector的执行时机是在所有@Configuration类型bean解析之后。
实现方式代码如下：
publicstaticclassBeansImportSelectorimplementsDeferredImportSelector{
@Override
publicString[]selectImports(AnnotationMetadataimportingClassMetadata){
returnnewString[]{NewBeanDefinitionRegistryPostProcessor.class.getName()};
}
}
@Configuration
@Import(BeansImportSelector.class)
publicclassBeansConfig{
}
最终执行的顺序如下：（NewBeanDefinitionRegistryPostProcessor在OldBeanDefinitionRegistryPostProcessor后面执行）
OldBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry
NewBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry
OldBeanDefinitionRegistryPostProcessor.postProcessBeanFactory
NewBeanDefinitionRegistryPostProcessor.postProcessBeanFactory
四、引发的思考
如上就是三种实现方式，至于哪种方式最好，这要看具体的场景，第一种、第三种影响面相对较小，而第二种因为涉及更换DependencyComparator，可能影响的是全局。另外之所以会研究如上实现方式，主要原因还是因为我们的项目框架代码没有考虑扩展性及规范性，比如要动态注册BEAN，至少应实现PriorityOrdered或Order接口或指明@Order注解，这样当我们在某些特定场景需要做一下优化或替换时，则可以直接采取相同的方式但指定Order在前或在后即可，也就不用这么复杂了，比如：
@Component
publicclassOldBeanDefinitionRegistryPostProcessorimplementsBeanDefinitionRegistryPostProcessor,Order{
@Override
publicintgetOrder(){
return100;
}
...
}
@Component
publicclassNewBeanDefinitionRegistryPostProcessorimplementsBeanDefinitionRegistryPostProcessor,Order{
@Override
publicintgetOrder(){
return101;//只需序号在OldBeanDefinitionRegistryPostProcessor.getOrder之后即可
}
...
}
以上就是Java确保某个BeanDefinitionRegistryPostProcessorBean被最后执行的几种实现方式的详细内容，更多关于确保BeanDefinitionRegistryPostProcessorBean执行的资料请关注毛票票其它相关文章！
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。