Spring框架中ImportBeanDefinitionRegistrar的應(yīng)用詳解

更新時間：2024年01月29日 10:15:17 作者：Smallc0de

這篇文章主要介紹了Spring框架中ImportBeanDefinitionRegistrar的應(yīng)用詳解,如果實現(xiàn)了ImportSelector接口,在配置類中被@Import加入到Spring容器中以后,Spring容器就會把ImportSelector接口方法返回的字符串數(shù)組中的類new出來對象然后放到工廠中去,需要的朋友可以參考下

前言

我們講過如果一個類實現(xiàn)了ImportSelector接口，并且在配置類中被@Import加入到Spring容器中以后。

Spring容器就會把ImportSelector接口方法返回的字符串數(shù)組中的類new出來對象然后放到工廠中去。

并且做了一個功能開關(guān)的例子輔助講解其功能。這次我們就接著上次講解ImportSelector接口的內(nèi)容繼續(xù)擴展講解ImportBeanDefinitionRegistrar的用法。

ImportBeanDefinitionRegistrar

按照慣例我們還是先介紹一下這個接口里面最重要的方法：registerBeanDefinitions。

public interface ImportBeanDefinitionRegistrar {
	//雖然是倆方法，但是等于一個方法
	default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry,
         BeanNameGenerator importBeanNameGenerator) {
	//直接調(diào)用了下面的方法
      registerBeanDefinitions(importingClassMetadata, registry);
   }
   default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
   }
}

里面一共兩個方法而且都被default注解了，可見確實用的不多。但是這個方法卻擁有ImportSelector接口內(nèi)方法的一切功能，而且更強大。這倆方法是重載方法，區(qū)別就在于有沒有BeanNameGenerator，這個接口是Spring內(nèi)置的BeanName生成器，無關(guān)大雅。但是注意到第一個方法其實是調(diào)用了第二個方法去實現(xiàn)的，可以說方法一是一個擴展，也可以說方法一等于方法二。那就直接解析參數(shù)。

第一個參數(shù)AnnotationMetadata importingClassMetadata：這個參數(shù)和ImportSelector中的一樣，可以拿到被@Import注解過的類的元數(shù)據(jù)，具體到例子就是筆者一直寫的配置類AppConfig.class。因為也不打算進行修改，所以這個不多說。
第二個參數(shù)BeanDefinitionRegistry registry：這個參數(shù)厲害了。BeanDefinitionRegistry這個接口我們以前說過，Spring想要把一個類變成對象就一定會把這個類變成一個BeanDefinition對象。這個過程怎么來的呢？就是通過實現(xiàn)BeanDefinitionRegistry接口類的構(gòu)造方法做的。

Spring把在方法中把這個接口開放出來，就意味著我們可以在這里手動添加一個BeanDefinition給Spring容器，然后構(gòu)建對象出來。通過registry我們就可以注冊一個BeanDefinition進入Spring容器，就使用下面的這個方法：

registry.registerBeanDefinition(String beanName, BeanDefinition beanDefinition)

ImportBeanDefinitionRegistrar例子

按照常規(guī)我們先把必要的類都先創(chuàng)建出來。一個業(yè)務(wù)接口ImportTestDao，一個業(yè)務(wù)類依賴該接口ImportTestService，一個配置類AppConfig，一個測試類Test，以及一個實現(xiàn)了ImportBeanDefinitionRegistrar的類MyImportDBR。

public interface ImportTestDao {
   public void query();
}

@Component
public class ImportTestService {
    @Autowired
    ImportTestDao importTestDao;
    public void find(){
        System.out.println("ImportTestService importTestDao.query()");
        importTestDao.query();
    }
}

@ComponentScan("com.demo")
public class AppConfig {
}

public class Test {
   public static void main(String[] args) {
     AnnotationConfigApplicationContext anno= new AnnotationConfigApplicationContext(AppConfig.class);
     ImportTestDao importTestDao= (ImportTestDao) anno.getBean("importTestDao");
     importTestDao.query();
   }
}

public class MyImportDBR implements ImportBeanDefinitionRegistrar {
   @Override
   public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
   }
}

要完成MyImportDBR最重要的就是實現(xiàn)里面的方法。所以先分析一下如何使用這個方法：首先看參數(shù)需要一個beanName和一個beanDefinition，那么第一步就是需要得到要注冊的bean的beanDefinition。Spring也給我們提供了相應(yīng)的類BeanDefinitionBuilder。那么最終這個類構(gòu)造成這個樣子：

public class MyImportDBR implements ImportBeanDefinitionRegistrar {
   @Override
   public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
      //得到BD，掃描接口
      BeanDefinitionBuilder builder= BeanDefinitionBuilder.genericBeanDefinition(ImportTestDao.class);
      GenericBeanDefinition beanDefinition= (GenericBeanDefinition) builder.getBeanDefinition();
      beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanDefinition.getBeanClassName());
      registry.registerBeanDefinition("importTestDao",beanDefinition);
   }
}

但是這里有一個問題：因為我們這里雖然把ImportTestDao.class寫在這里了，想要構(gòu)建一個BeanDefinition。但是我們沒有辦法使用，因為ImportTestDao是一個接口， Spring沒有辦法給你new一個出來，也就是說沒有辦法實例化。那么怎么辦呢？我們知道這里用的不應(yīng)該是一個類，而是應(yīng)該是ImportTestDao這個接口的一個代理類。所以要怎么樣才能獲取到這個代理呢？這需要提起來我們很早以前就提到的一個知識點FactoryBean。那我們就需要構(gòu)造這么一個FactoryBean，以及為了構(gòu)造一個代理對象還需要一個InvocationHandler。

public class MyfactoryBean implements FactoryBean {
   private Class clazz;
   public MyfactoryBean(Class clazz) {
      this.clazz=clazz;
   }
   @Override
   public Object getObject() throws Exception {
      Class[] clazzes=new Class[]{this.clazz};
      Object proxy= Proxy.newProxyInstance(this.getClass().getClassLoader(),clazzes,new MyInvocation());
      return proxy;
   }
   @Override
   public Class<?> getObjectType() {
      return this.clazz;
   }
   @Override
   public boolean isSingleton() {
      return false;
   }
}

public class MyInvocation implements InvocationHandler {
   public MyInvocation() {
   }
   @Override
   public Object invoke(Object proxy, Method method, Object[] args) {
   	  System.out.println("This is a proxy of ImportTestDao");
      return null;
   }
}

然后把這個FactoryBean加入進去。

public class MyImportDBR implements ImportBeanDefinitionRegistrar {
   @Override
   public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
      //得到BD，掃描接口，這里筆者寫死了，但是其實可以做一個包掃描，把某一個包下的所有類都掃描進來，就像Mybatis的@MapperScan注解一樣
      BeanDefinitionBuilder builder= BeanDefinitionBuilder.genericBeanDefinition(ImportTestDao.class);
      //拿到一個BeanDefinition, 這里使用一個其中一個子類來接收，代表這里構(gòu)建的就是一個普通的BeanDefinition
      GenericBeanDefinition beanDefinition= (GenericBeanDefinition) builder.getBeanDefinition();
      //這里打印是因為筆者當時不確定類名要不要包含包名
      System.out.println(beanDefinition.getBeanClassName());
      //給我們的beanDefinition添加一個構(gòu)造方法，并且傳入我們需要的bean名字
      beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanDefinition.getBeanClassName());
      //把代理對象給賦予給BeanDefinition
      beanDefinition.setBeanClass(MyfactoryBean.class);
      //這里的名字可以隨便取，這里是隨著Spring名規(guī)范取的。話說這個接口的另一個方法有BeanNameGenerator這個參數(shù)就是讓大家自由發(fā)揮的
      registry.registerBeanDefinition("importTestDao",beanDefinition);
   }
}

為了更有逼格一些，我們把這個ImportBeanDefinitionRegistrar封裝成為一個注解MyScaner，這個是仿照@MapperScan的

@Retention(RetentionPolicy.RUNTIME)
@Import(MyImportDBR.class)
public @interface MyScaner {
}

直接加載到AppConfig類上。

@ComponentScan("com.demo")
@MyScaner
public class AppConfig {
}
運行，拿到結(jié)果：
This is a proxy of ImportTestDao
query

這樣就完成了從外部直接加載一個BeanDefinition到Spring容器的過程。但是小伙伴們看到這里一定會覺得：你這一頓操作猛如虎，一看戰(zhàn)績0比5。搞這么多有個毛線用??？

ImportBeanDefinitionRegistrar作用

看起來筆者的例子卵用沒有，但是仔細想想，大家經(jīng)常使用的Mybatis是不是就是這個原理？我特意把Mybatis官網(wǎng)的代碼調(diào)出來，想必大家都配置過。

<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
  <property name="mapperInterface" value="org.mybatis.spring.sample.mapper.UserMapper" />
  <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

一般的博客會說，這個是把我們自己定義的UserMapper注冊給MapperFactoryBean，看到這里的同學，筆者可以明確的告訴你，這個解釋是錯的。我們要想轉(zhuǎn)換UserMapper成為MapperFactoryBean，你就必須顯式的告訴Spring他們之間的關(guān)系。然后Spring拿到UserMapper接口傳入MapperFactoryBean，再由MapperFactoryBean動態(tài)產(chǎn)生UserMapper的代理對象，然后你程序里使用的一直都是這個代理對象，這一切的原理就是我們寫的MyfactoryBean的一系列操作。

為了驗證我的說法咱們?nèi)ybatis的MapperFactoryBean的源碼看下，是不是和我們寫的基本上解構(gòu)一樣。

public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {
//通過這個接口反射代理對象，就是我們例子中的clazz
   private Class<T> mapperInterface;  
   public MapperFactoryBean() {
      // intentionally empty
   }
   public MapperFactoryBean(Class<T> mapperInterface) {
      this.mapperInterface = mapperInterface;
   }
   ...無關(guān)，略...
   /**
    * {@inheritDoc}
    */
   @Override
   public T getObject() throws Exception {
	//通過傳入接口反射得到代理對象，如果沒有接口你就沒有辦法獲取代理對象
	//這個接口怎么拿到，就是通過上面的xml配置的
      return getSqlSession().getMapper(this.mapperInterface);
   }
   /**
    * {@inheritDoc}
    */
   @Override
   public Class<T> getObjectType() {
      return this.mapperInterface;
   }
   /**
    * {@inheritDoc}
    */
   @Override
   public boolean isSingleton() {
      return true;
   }
 // ...無關(guān)，略...
}

所以我們配置的這個Mybatis的xml是干嘛的呢？就是為了讓MapperFactoryBean生成我們需要的(UserMapper)代理對象而已，根本就不是什么注冊。

到此這篇關(guān)于Spring框架中ImportBeanDefinitionRegistrar的應(yīng)用詳解的文章就介紹到這了,更多相關(guān)ImportBeanDefinitionRegistrar應(yīng)用內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: