前言

上一篇博客【Spring框架的ImportSelector到底可以干嘛】我们讲过如果一个类实现了ImportSelector接口，并且在配置类中被@Import加入到Spring容器中以后。Spring容器就会把ImportSelector接口方法返回的字符串数组中的类new出来对象然后放到工厂中去。并且做了一个功能开关的例子辅助讲解其功能。这次我们就接着上次讲解ImportSelector接口的内容继续扩展讲解ImportBeanDefinitionRegistrar的用法。更多Spring内容进入【Spring解读系列目录】。

ImportBeanDefinitionRegistrar

按照惯例我们还是先介绍一下这个接口里面最重要的方法：registerBeanDefinitions。

public interface ImportBeanDefinitionRegistrar {
	//虽然是俩方法，但是等于一个方法
	default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry,
         BeanNameGenerator importBeanNameGenerator) {
	//直接调用了下面的方法
      registerBeanDefinitions(importingClassMetadata, registry);
   }
   default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
   }
}

里面一共两个方法而且都被default注解了，可见确实用的不多。但是这个方法却拥有ImportSelector接口内方法的一切功能，而且更强大。这俩方法是重载方法，区别就在于有没有BeanNameGenerator，这个接口是Spring内置的BeanName生成器，无关大雅。但是注意到第一个方法其实是调用了第二个方法去实现的，可以说方法一是一个扩展，也可以说方法一等于方法二。那就直接解析参数。

1. 第一个参数AnnotationMetadata importingClassMetadata：这个参数和ImportSelector中的一样，可以拿到被@Import注解过的类的元数据，具体到例子就是笔者一直写的配置类AppConfig.class。因为也不打算进行修改，所以这个不多说。
2. 第二个参数BeanDefinitionRegistry registry：这个参数厉害了。BeanDefinitionRegistry这个接口我们以前说过，Spring想要把一个类变成对象就一定会把这个类变成一个BeanDefinition对象。这个过程怎么来的呢？就是通过实现BeanDefinitionRegistry接口类的构造方法做的。

Spring把在方法中把这个接口开放出来，就意味着我们可以在这里手动添加一个BeanDefinition给Spring容器，然后构建对象出来。通过registry我们就可以注册一个BeanDefinition进入Spring容器，就使用下面的这个方法：

registry.registerBeanDefinition(String beanName, BeanDefinition beanDefinition)

ImportBeanDefinitionRegistrar例子

按照常规我们先把必要的类都先创建出来。一个业务接口ImportTestDao，一个业务类依赖该接口ImportTestService，一个配置类AppConfig，一个测试类Test，以及一个实现了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最重要的就是实现里面的方法。所以先分析一下如何使用这个方法：首先看参数需要一个beanName和一个beanDefinition，那么第一步就是需要得到要注册的bean的beanDefinition。Spring也给我们提供了相应的类BeanDefinitionBuilder。那么最终这个类构造成这个样子：

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写在这里了，想要构建一个BeanDefinition。但是我们没有办法使用，因为ImportTestDao是一个接口， Spring没有办法给你new一个出来，也就是说没有办法实例化。那么怎么办呢？我们知道这里用的不应该是一个类，而是应该是ImportTestDao这个接口的一个代理类。所以要怎么样才能获取到这个代理呢？这需要提起来我们很早以前就提到的一个知识点FactoryBean【实例区别BeanFactory和FactoryBean】。那我们就需要构造这么一个FactoryBean，以及为了构造一个代理对象还需要一个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, 这里使用一个其中一个子类来接收，代表这里构建的就是一个普通的BeanDefinition
      GenericBeanDefinition beanDefinition= (GenericBeanDefinition) builder.getBeanDefinition();
      //这里打印是因为笔者当时不确定类名要不要包含包名
      System.out.println(beanDefinition.getBeanClassName());
      //给我们的beanDefinition添加一个构造方法，并且传入我们需要的bean名字
      beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanDefinition.getBeanClassName());
      //把代理对象给赋予给BeanDefinition
      beanDefinition.setBeanClass(MyfactoryBean.class);
      //这里的名字可以随便取，这里是随着Spring名规范取的。话说这个接口的另一个方法有BeanNameGenerator这个参数就是让大家自由发挥的
      registry.registerBeanDefinition("importTestDao",beanDefinition);
   }
}

为了更有逼格一些，我们把这个ImportBeanDefinitionRegistrar封装成为一个注解MyScaner，这个是仿照@MapperScan的

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

直接加载到AppConfig类上。

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

运行，拿到结果：
This is a proxy of ImportTestDao
query

这样就完成了从外部直接加载一个BeanDefinition到Spring容器的过程。但是小伙伴们看到这里一定会觉得：你这一顿操作猛如虎，一看战绩0比5。搞这么多有个毛线用啊？

ImportBeanDefinitionRegistrar作用

看起来笔者的例子卵用没有，但是仔细想想，大家经常使用的Mybatis是不是就是这个原理？我特意把Mybatis官网的代码调出来，想必大家都配置过。

<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，看到这里的同学，笔者可以明确的告诉你，这个解释是错的。我们要想转换UserMapper成为MapperFactoryBean，你就必须显式的告诉Spring他们之间的关系。然后Spring拿到UserMapper接口传入MapperFactoryBean，再由MapperFactoryBean动态产生UserMapper的代理对象，然后你程序里使用的一直都是这个代理对象，这一切的原理就是我们写的MyfactoryBean的一系列操作。

为了验证我的说法咱们去Mybatis的MapperFactoryBean的源码看下，是不是和我们写的基本上解构一样。

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;
   }
   ...无关，略...
   /**
    * {@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;
   }
  ...无关，略...
}

所以我们配置的这个Mybatis的xml是干嘛的呢？就是为了让MapperFactoryBean生成我们需要的(UserMapper)代理对象而已，根本就不是什么注册。

结语

了解源码了解更多神器背后的故事，谢谢大家。