189 8069 5689

Java确保某个Bean类被最后执行的实现方法-创新互联

这篇文章主要介绍Java确保某个Bean类被最后执行的实现方法，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！

创新互联建站主要业务有网站营销策划、成都网站建设、网站建设、微信公众号开发、小程序设计、H5网站设计、程序开发等业务。一次合作终身朋友，是我们奉行的宗旨；我们不仅仅把客户当客户，还把客户视为我们的合作伙伴，在开展业务的过程中，公司还积累了丰富的行业经验、成都全网营销资源和合作伙伴关系资源，并逐渐建立起规范的客户服务和保障体系。 

一、事出有因

最近有一个场景，因同一个项目中不同JAR包依赖同一个组件，但依赖组件的版本不同，导致无论使用哪个版本都报错（无法同时兼容两个JAR包中所需的方法调用），经过分析发现差异的部份是在一个BEAN中的方法出入参不同而矣，故考虑通过动态替换掉这个存在兼容性的BEAN，换成我们自己继承自该BEAN类并实现适配兼容方法，从而最终解决组件版本不兼容问题；

二、解决方案困境

但在实现的编码过程中发现，原依赖的那个BEAN并不是普通的通过标注@Compent之类的注解实现的注册的BEAN，而是由自定义的BeanDefinitionRegistryPostProcessor BEAN类中动态注册的BEAN，这样BEAN的注册顺序是“无法确定”的，我原本想通过自定义一个BeanDefinitionRegistryPostProcessor BEAN类，在postProcessBeanDefinitionRegistry方法中通过找到原依赖BEAN的名字，然后移除该名称对应的BEAN定义信息（BeanDefinition），最后再以原BEAN的名字定义并注册成为我自己的适配器的BEAN类，这样就实现了“移花接木”的功能，然而想法是OK的但最终运行起来，发现BEAN并没有成功被替换，究其原因发现，原来我自己定义的BeanDefinitionRegistryPostProcessor BEAN类是优先于原依赖的那个问题BEAN所对应的BeanDefinitionRegistryPostProcessor BEAN类之前执行的，这样就会导致在我的自定义BeanDefinitionRegistryPostProcessor BEAN类postProcessBeanDefinitionRegistry方法中并没有找到原依赖BEAN名字对应的BeanDefinition，也就无法进行正常的替换了，如果说文字难看懂，可以见如下图所示：

Java确保某个Bean类被最后执行的实现方法

三、柳暗花明，终级解决方案

既然问题根源找到，那确保一个自定义的BeanDefinitionRegistryPostProcessor 类被最后定义为Bean、且被最后执行成为关键（至少得比原依赖的那个问题BEAN所对应的BeanDefinitionRegistryPostProcessor BEAN类【如：OldBeanDefinitionRegistryPostProcessor】之后执行才行），因为这样我们才能获得原依赖的问题Bean的BeanDefinition,才能进行正常的替换BeanDefinition，最终达到原来依赖问题Bean的自动都依赖到新的适配器Bean，从而可以控制修改问题方法的中的逻辑（比如：兼容、降级）。当然，我估计此时有人会想说，何必这么麻烦，一个AOP切面不就搞定了吗？通过实现@Around切面，把有问题的方法拦截替换成自己的适配方法逻辑，这种确实也是一种有效手段，但我认为不够优雅，而且代码的可读性不强且未必能覆盖所有方法，比如：如果涉及问题方法内部依赖的内部方法（如protected）过多或依赖的其它BEAN过多时，可能就会导致这个切面类里面要复制一堆的原问题BEAN类中的内部方法到切面类中，但这样带来的风险就是代码重复及原代码更新后导致的不一致等隐性问题，故我的原则是：如果只是简单的替换原有方法且逻辑不复杂的可以使用AOP切面来解决，但如果涉及复杂的业务逻辑且内部依赖过多，这时采取代理、适配或装饰可能更为合适一些。

好了，如下就是我要分享的三种：确保一个自定义的BeanDefinitionRegistryPostProcessor 类被最后定义为Bean、且被最后执行的实现方式。

第一种实现方案

第一种：通过嵌套注册自定义的BeanDefinitionRegistryPostProcessor 类BEAN的方式，这种方式实现思路是：PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors会先执行已获得BeanDefinitionRegistryPostProcessor BEAN集合，执行完这些BEAN集合后（这里我称为第一轮或第一层），会再次尝试获取第二轮、第三轮一直到获取的BeanDefinitionRegistryPostProcessor BEAN集合全部处理完成为止，框架相关代码片段如下：

boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : 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();
			}

实现方式代码如下：

//如下是第一层自定义的BeanDefinitionRegistryPostProcessor BEAN，内部再注册真正用于替换BEAN目的NewBeanDefinitionRegistryPostProcessor BEAN
//author:zuowenjun
@Component
public class FirstDynamicBeanPostProcessor implements BeanDefinitionRegistryPostProcessor {
 @Override
 public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
 BeanDefinitionBuilder beanDefinitionBuilder=BeanDefinitionBuilder.genericBeanDefinition(NewBeanDefinitionRegistryPostProcessor.class);
beanDefinitionRegistry.registerBeanDefinition("newBeanDefinitionRegistryPostProcessor",beanDefinitionBuilder.getBeanDefinition());
 System.out.printf("【%1$tF %1$tT.%1$tL】%s,FirstDynamicBeanPostProcessor.postProcessBeanDefinitionRegistry%n", new Date());
 }

 @Override
 public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
 System.out.printf("【%1$tF %1$tT.%1$tL】%s,FirstDynamicBeanPostProcessor.postProcessBeanFactory%n", new Date());
 }
}

//用于将原依赖的问题Bean替换为同名的新的适配器Bean(下文中所有替换方式最终都要使用该类)
public class NewBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
 @Override
 public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
 System.out.printf("【%1$tF %1$tT.%1$tL】%s,NewBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry%n",new Date());
 boolean isContainsSpecialBean = ((DefaultListableBeanFactory) beanDefinitionRegistry).containsBean("old问题Bean名称");
 if (isContainsSpecialBean) {
 beanDefinitionRegistry.removeBeanDefinition("old问题Bean名称");
 BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(DemoCompentB.class);
 beanDefinitionBuilder.addConstructorArgValue(((DefaultListableBeanFactory) beanDefinitionRegistry).getBean(NewBeanAdapter.class)); //NewBeanAdapter为继承自old问题Bean的装饰者、适配器类
 AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();
 beanDefinition.setPrimary(true);
 beanDefinitionRegistry.registerBeanDefinition("old问题Bean名称", beanDefinition);
 }

 }

 @Override
 public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
 System.out.printf("【%1$tF %1$tT.%1$tL】%s,NewBeanDefinitionRegistryPostProcessor.postProcessBeanFactory%n",new Date());
 }
}

最终执行的顺序如下：(可以看到NewBeanDefinitionRegistryPostProcessor是在OldBeanDefinitionRegistryPostProcessor之后执行的，这样就可以正常替换Bean定义了)

FirstDynamicBeanPostProcessor.postProcessBeanDefinitionRegistry (第一轮)

OldBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry (第一轮)

NewBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry （第二轮）

FirstDynamicBeanPostProcessor.postProcessBeanFactory

OldBeanDefinitionRegistryPostProcessor.postProcessBeanFactory

NewBeanDefinitionRegistryPostProcessor.postProcessBeanFactory

第二种实现方案

第二种：通过额外定义一个BeanDefinitionRegistryPostProcessor BEAN并实现PriorityOrdered、BeanFactoryAware接口，确保该BEAN最先被执行(Order=0)，然后在postProcessBeanDefinitionRegistry方法中通过applicationContext.setDependencyComparator设置自定义的排序器，达到排序BeanDefinitionRegistryPostProcessor BEAN集合的执行顺序，这种方式实现思路是：在执行BeanDefinitionRegistryPostProcessor BEAN集合前会调用sortPostProcessors方法进行排序，而排序规则又依赖于DependencyComparator，通过控制排序规则实现间接控制执行顺序，先看框架的代码片段：

private static void sortPostProcessors(List postProcessors, ConfigurableListableBeanFactory beanFactory) {
		Comparator comparatorToUse = null;
		if (beanFactory instanceof DefaultListableBeanFactory) {
			comparatorToUse = ((DefaultListableBeanFactory) beanFactory).getDependencyComparator();
		}
		if (comparatorToUse == null) {
			comparatorToUse = OrderComparator.INSTANCE;
		}
		postProcessors.sort(comparatorToUse);
	}

//如下是invokeBeanFactoryPostProcessors方法片段：
sortPostProcessors(currentRegistryProcessors, beanFactory);
				registryProcessors.addAll(currentRegistryProcessors);
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
实现方式代码如下：
@Component
 public static class FirstBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor, PriorityOrdered
 , BeanFactoryAware {

 private BeanFactory beanFactory;

 @Override
 public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
 this.beanFactory=beanFactory;
 }

 @Override
 public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
 ((DefaultListableBeanFactory) beanFactory).setDependencyComparator(new OrderComparator(){
 @Override
 protected int getOrder(Object obj) {
  if (obj instanceof NewBeanDefinitionRegistryPostProcessor){ //如果是NewBeanDefinitionRegistryPostProcessor则将它的排序序号设置为较大
  return Integer.MAX_VALUE;
  }
  return super.getOrder(obj)-1; //其余的全部设为比它小1
 }
 });
 System.out.printf("【%1$tF %1$tT.%1$tL】%s,FirstBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry%n", new Date());
 }

 @Override
 public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
 System.out.printf("【%1$tF %1$tT.%1$tL】%s,FirstBeanDefinitionRegistryPostProcessor.postProcessBeanFactory%n", new Date());
 }

 @Override
 public int getOrder() {
 return 0;//确保
 }
 }
最终执行的顺序如下：（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解析之后。
实现方式代码如下：
 public static class BeansImportSelector implements DeferredImportSelector {
 @Override
 public String[] selectImports(AnnotationMetadata importingClassMetadata) {
 return new String[]{NewBeanDefinitionRegistryPostProcessor.class.getName()};
 }
 }

@Configuration
@Import(BeansImportSelector.class)
public class BeansConfig {
 
}
最终执行的顺序如下：（NewBeanDefinitionRegistryPostProcessor在OldBeanDefinitionRegistryPostProcessor后面执行）
OldBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry
NewBeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry
OldBeanDefinitionRegistryPostProcessor.postProcessBeanFactory
NewBeanDefinitionRegistryPostProcessor.postProcessBeanFactory
四、引发的思考
如上就是三种实现方式，至于哪种方式好，这要看具体的场景，第一种、第三种影响面相对较小，而第二种因为涉及更换DependencyComparator，可能影响的是全局。另外之所以会研究如上实现方式，主要原因还是因为我们的项目框架代码没有考虑扩展性及规范性，比如要动态注册BEAN，至少应实现PriorityOrdered或Order接口或指明@Order注解，这样当我们在某些特定场景需要做一下优化或替换时，则可以直接采取相同的方式但指定Order在前或在后即可，也就不用这么复杂了，比如：
@Component
public class OldBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor,Order {
 
 @Override
 public int getOrder() {
 return 100;
 }
 
 ...
}

@Component
public class NewBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor,Order {
 
 @Override
 public int getOrder() {
 return 101;//只需序号在OldBeanDefinitionRegistryPostProcessor.getOrder之后即可
 }
 
 ...
}
以上是“Java确保某个Bean类被最后执行的实现方法”这篇文章的所有内容，感谢各位的阅读！希望分享的内容对大家有帮助，更多相关知识，欢迎关注创新互联行业资讯频道！
            

            本文标题：Java确保某个Bean类被最后执行的实现方法-创新互联            

            文章网址：http://cdxtjz.cn/article/dpcids.html
        
    
    

        
其他资讯

        
    




  

    

      
联系我们

      

        您好HELLO!

        感谢您来到成都网站建设公司，若您有合作意向，请您为我们留言或使用以下方式联系我们，

        我们将尽快给你回复，并为您提供真诚的设计服务，谢谢。
      

      
    
        
  • 电话：028- 86922220 18980695689
    • 
        
  • 商务合作邮箱：631063699@qq.com
    • 
        
  • 合作QQ： 532337155
    • 
        
  • 成都网站设计地址：成都市青羊区锣锅巷31号五金站写字楼6楼
    • 
      

    

    

      
小谭建站工作室

      

        成都小谭网站建设公司拥有多年以上互联网从业经验的团队，始终保持务实的风格，以"帮助客户成功"为已任，专注于提供对客户有价值的服务。

        我们已为众企业及上市公司提供专业的网站建设服务。我们不只是一家网站建设的网络公司；我们对营销、技术、管理都有自己独特见解，小谭建站采取“创意+综合+营销”一体化的方式为您提供更专业的服务！
      

      
小谭观点

      

        相对传统的成都网站建设公司而言，小谭是互联网中的网站品牌策划，我们精于企业品牌与互联网相结合的整体战略服务。

        我们始终认为，网站必须注入企业基因，真正使网站成为企业vi的一部分，让整个网站品牌策划体系变的深入而持久。
      

    

  

  

    
 
         友情链接：
        成都微信小程序开发   德阳东方电机技改   成都微信小程序开发   深圳纱窗安装   眉山发电机维修   犀浦封阳台   重庆网站制作   主机托管   成都棕树机房   四川广汉锦华     
    

  

  
 © Copyright 2023 小谭建站工作室All Rights Reserved.  成都网站建设 / 成都网站建设 / 响应式网站建设 / 成都服务器租用