一、事出有因
最近有一個場景，因同一個專案中不同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，也就無法進行正常的替換了，如果說文字難看懂，可以見如下圖所示：
三、柳暗花明，終級解決方案
既然問題根源找到，那確保一個自定義的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<Object> 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之後即可
}
...
}