Spring扩展之BeanDefinitionRegistryPostProcessor

前言

上一篇博客介绍了Spring中的invokeBeanFactoryPostProcessors方法。其中涉及到了两个接口，一是BeanFactoryPostProcessor接口，二是BeanDefinitionRegistryPostProcessor接口。详细的内容可以参考上一篇博客《Spring IOC—invokeBeanFactoryPostProcessors源码分析》

而这两个接口是spring提供的扩展点，本文将介绍关于BeanDefinitionRegistryPostProcessor扩展点的应用。

1.概述

对于BeanDefinitionRegistryPostProcessor扩展点应用的学习，可以参考mybatis是如何扩展这个接口的。这种站在巨人的肩膀上学习效率更高。

mybatis基于这个扩展点，将mapper接口交给了Spring管理。众所周知Spring管理的是对象，那么是如何将mapper接口变成对象呢，又是通过怎样的方式将这个对象交给spring管理的呢？如果有疑问的读者不妨带着问题继续阅读。

1.1重点类介绍

1.1.1 MapperProxyFactory

mapper代理工厂，基于接口和mapperProxy来构建一个mapper代理对象。实现了将接口转变成一个对象。

1.1.2 MapperFactoryBean

MapperFactoryBean实现了FactoryBean。他是一个特殊的Bean对象，可以调用getObject()方法根据接口的不同，返回不同的接口代理对象，这个对象也就是通过MapperProxyFactory产生的。

1.1.3 MapperScannerRegistrar

用来将MapperScannerConfigurer注册到BeanDefinitionMap中。具体的执行时机后续会介绍。

1.1.4 MapperScannerConfigurer

实现了BeanDefinitionRegistryPostProcessor接口，这是基于spring的扩展。在Spring的内置扫描器扫描结束后触发这个类的逻辑，执行postProcessBeanDefinitionRegistry方法，构建一个mybatis的扫描器来执行扫描mapper接口。

1.1.5 ClassPathMapperScanner

mybatis实现的一个扫描器，继承了spring内置的扫描器ClassPathBeanDefinitionScanner。实现了将mapper.class到BeanDefinition的转换。

2.mybatis中如何将接口变成对象

先来看一段代码

Environment environment = new Environment("development", null, null);
Configuration configuration = new Configuration(environment);
configuration.addMapper(TestMapper.class);

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);
SqlSession sqlSession = sqlSessionFactory.openSession();
TestMapper mapper = sqlSession.getMapper(TestMapper.class);
mapper.query();

这段代码大家肯定很熟悉了，而重点就在于sqlSession.getMapper(TestMapper.class);这一句上。debug调试，一直执行下去，可以看到是使用了JDK的动态代理。基于传入的接口，生成一个代理对象。代理对象执行的方法都会去执行mapperProxy中的invoke方法。具体做了什么这里不讨论了。

//MapperProxyFactory
protected T newInstance(MapperProxy<T> mapperProxy) {
    
    
  return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] {
    
     mapperInterface }, mapperProxy);
}

第一个疑问就这样解决了，mybatis使用基于接口的动态代理生成代理对象。

3.mybatis如何将代理对象交给spring管理

不妨先来看看有哪几种方式可以将一个对象交给spring来管理

3.1将对象交给Spring管理的方式

3.1.1 api手动添加

ac.getBeanFactory().registerSingleton("beanName",new Object());

3.1.2 @Bean

@Bean
public Object object(){
    
     
   return new Object();
}

3.1.3 factoryBean

factoryBean 他是一个特殊Bean,必须实现接口FactoryBean，当前这个Bean还能产生一个Bean。将这个MyFactoryBean类交给spring管理，也就可以将一个对象A交给了Spring来进行管理了。

mybatis就是使用的这种方式。

class MyFactoryBean implements FactoryBean{
    
    

   @Override
   public Object getObject() throws Exception {
    
    
      return new A();
   }

   @Override
   public Class<?> getObjectType() {
    
    
      return A.class;
   }
}

3.2 mybatis对于spring扩展实现

需要做哪些事情呢？

首先需要扫描指定包下面的接口，将这些接口生成代理对象，再通过FactoryBean将这些代理对象交给Spring管理。

3.2.1 @MapperScan注解

这个注解的主要作用是将MapperScannerConfigurer放到BeanDefinitionMap当中。

那么他是如何工作的呢？再上一篇博客中提到了spring中的内置类ConfigurationClassPostProcessor。这个类的作用是扫描带spring注解的类添加到bdmap中，并且解析配置类上的@Import标签，若这个标签中的类实现了ImportBeanDefinitionRegistrar接口，会将这这个类实例化后放入到 importBeanDefinitionRegistrars 缓存当中。扫描完成后会执行这个集合当中的对象的registerBeanDefinitions方法。

mybatis中MapperScannerRegistrar这个方法的作用就是将MapperScannerConfigurer注册到BeanDefinitionMap当中。

//MapperScannerRegistrar
@Override
  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    
    
    AnnotationAttributes mapperScanAttrs = AnnotationAttributes
        .fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
    if (mapperScanAttrs != null) {
    
    
      registerBeanDefinitions(importingClassMetadata, mapperScanAttrs, registry,
          generateBaseBeanName(importingClassMetadata, 0));
    }
  }
 void registerBeanDefinitions(AnnotationMetadata annoMeta, AnnotationAttributes annoAttrs,
    BeanDefinitionRegistry registry, String beanName) {
    
    

  BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
  // 。。。。忽略不重要的代码

  registry.registerBeanDefinition(beanName, builder.getBeanDefinition());

}

3.2.2 MapperScannerConfigurer

MapperScannerConfigurer实现了BeanDefinitionRegistryPostProcessor接口，即对spring进行扩展

还记得上一篇博客中这些后置处理器的执行顺序嘛？

根据3.2.1MapperScannerConfigurer是在spring内置的后置处理器执行完毕后就被注册到了bdMap中。而之后会去执行实现了BeanDefinitionRegistryPostProcessor接口和Ordered接口的后置处理器。然后会执行实现了BeanDefinitionRegistryPostProcessor的后置处理器。

所以会去执行MapperScannerConfigurer中的postProcessBeanDefinitionRegistry方法，如下

主要的逻辑就是初始化一个mybatis中实现的扫描器ClassPathMapperScanner，然后用这个扫描器执行扫描工作，即执行scan方法。

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    
    
  if (this.processPropertyPlaceHolders) {
    
    
    processPropertyPlaceHolders();
  }

  ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);//mybatis中的扫描器
  //下面的一系列set方法是对这个扫描器进行初始化
  scanner.setAddToConfig(this.addToConfig);
  scanner.setAnnotationClass(this.annotationClass);
  scanner.setMarkerInterface(this.markerInterface);
  scanner.setSqlSessionFactory(this.sqlSessionFactory);
  scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
  scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
  scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
  scanner.setResourceLoader(this.applicationContext);
  scanner.setBeanNameGenerator(this.nameGenerator);
  scanner.setMapperFactoryBeanClass(this.mapperFactoryBeanClass);
  if (StringUtils.hasText(lazyInitialization)) {
    
    
    scanner.setLazyInitialization(Boolean.valueOf(lazyInitialization));
  }
  scanner.registerFilters();//注册一些扫描用的过滤器
  scanner.scan(
      StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));//扫描basePackage包
}

ClassPathMapperScanner并没有重写父类的scan方法，所以这里调用的是父类的scan方法，如下。

public int scan(String... basePackages) {
    
    
   int beanCountAtScanStart = this.registry.getBeanDefinitionCount();

   // 完成扫描
   doScan(basePackages);

   // Register annotation config processors, if necessary.
   if (this.includeAnnotationConfig) {
    
    
      AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
   }

   return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
}

重点在执行doScan方法，该方法由ClassPathMapperScanner重写了。

@Override
public Set<BeanDefinitionHolder> doScan(String... basePackages) {
    
    
  Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);//扫描包下的接口

  if (beanDefinitions.isEmpty()) {
    
    
    LOGGER.warn(() -> "No MyBatis mapper was found in '" + Arrays.toString(basePackages)
        + "' package. Please check your configuration.");
  } else {
    
    
    processBeanDefinitions(beanDefinitions);//将这些接口变成FactoryBean
  }

  return beanDefinitions;
}

首先会去调用父类的doScan方法来执行扫描，

遍历包名

<1>处执行findCandidateComponents方法，根据包名去扫描符合条件的类。其中会调用到scanCandidateComponents(basePackage)方法。这个方法会根据包名得到这个包下的所有的文件资源。然后会遍历这些资源将所有的接口添加到候选集合中返回。

<2>处遍历找到的候选bd

<3>处设置一些默认的属性值

<4>处看是否有注解，处理这些注解，例如@Lazy，@Primary、@DependsOn等

<5>检查beanName是否冲突，没有冲突的话构建成bdHolder，保存在一个set集合中并注册bd 。

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
    
    
   Assert.notEmpty(basePackages, "At least one base package must be specified");
   Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
   for (String basePackage : basePackages) {
    
    //遍历包名

      Set<BeanDefinition> candidates = findCandidateComponents(basePackage);//<1>寻找符合条件的候选BeanDefinition

      for (BeanDefinition candidate : candidates) {
    
    //<2>遍历找到的候选bd
         ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
         candidate.setScope(scopeMetadata.getScopeName());//设置Scope
         String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
         if (candidate instanceof AbstractBeanDefinition) {
    
    
            postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);//<3>设置一些默认的属性值
         }
         if (candidate instanceof AnnotatedBeanDefinition) {
    
    
            AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);//<4>看是否有注解，处理这些注解，例如@Lazy，@Primary、@DependsOn等
         }
         if (checkCandidate(beanName, candidate)) {
    
    //<5>检查beanName是否冲突，没有冲突的话构建成bdHolder，保存在一个set集合中并注册bd 。
            BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
            definitionHolder =
                  AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
            beanDefinitions.add(definitionHolder);
            registerBeanDefinition(definitionHolder, this.registry);
         }
      }
   }
   return beanDefinitions;
}

方法结束后返回结果到ClassPathMapperScanner中的doScan继续执行

此时得到的bd并不是所要的，不能对其进行实例化，因为他所包含的类还是个接口，接口是不能被实例化的。需要将其转变成一个FactoryBean。

执行 processBeanDefinitions(beanDefinitions)

if (beanDefinitions.isEmpty()) {
    
    
    LOGGER.warn(() -> "No MyBatis mapper was found in '" + Arrays.toString(basePackages)
        + "' package. Please check your configuration.");
  } else {
    
    
    processBeanDefinitions(beanDefinitions);
  }

这个方法会设置构造函数的参数为这个接口，然后将beanClass修改为MapperFactoryBean。之后实例化的时候会调用这个FactoryBean的getObject()方法来构建一个代理Mapper对象。这就是如何将map接口转变成一个对象交给Spring管理的关键。

private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
    
    
  GenericBeanDefinition definition;
  for (BeanDefinitionHolder holder : beanDefinitions) {
    
    
    definition = (GenericBeanDefinition) holder.getBeanDefinition();
    String beanClassName = definition.getBeanClassName();
    LOGGER.debug(() -> "Creating MapperFactoryBean with name '" + holder.getBeanName() + "' and '" + beanClassName
        + "' mapperInterface");

    // the mapper interface is the original class of the bean
    // but, the actual class of the bean is MapperFactoryBean
    definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName); // issue #59 添加构造函数需要的参数
	// 上面这一行代码可以使用下面的代码替代
    // MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
		// 第一个参数 是set方法去掉set 后首字母小写的名字。 setMapperInterface 去掉set M改成小写 得 mapperInterface
    // propertyValues.add("mapperInterface",aClass);
    definition.setBeanClass(this.mapperFactoryBeanClass);//设置类型为mapperFactoryBeanClass。之后的实例化会调用MapperFactoryBean中的getObject()来构建出一个基于接口的代理对象交给spring管理。

   //省略非重要代码
  }
}

4.模仿mybatis实现一个自定义扫描器

通过对mybatis中对spring的扩展的学习，试着模仿一下实现使用自定义的注解，使得添加了该注解的类可以交给Spring来管理。

首先先来总结一下mybatis的如何实现的

1. @MapperScan

   继承了Import注解，MapperScannerRegistrar实现了ImportBeanDefinitionRegistrar接口，将MapperScannerConfigurer后置处理器注册到BeanDefinitionMap中。执行时机详见3.2.1。

2. MapperScannerConfigurer

   这是一个Spring的扩展，实现了BeanDefinitionRegistryPostProcessor接口，主要的作用就是构建一个扫描器执行扫描。

3. ClassPathMapperScanner

   mybatis实现的扫描器，继承了Spring中的ClassPathBeanDefinitionScanner。实现属于自己扫描的逻辑。

根据以上的总结可以模仿着来实现一套属于自己的扫描规则。

4.1 @MyBeanScan

模仿@MapperScan，继承了@Import标签

该注解用于添加在配置类上，Spring内置的扫描器在完成了扫描之后会解析配置类上的Import标签。将实现了ImportBeanDefinitionRegistrar的类实例化并添加到importBeanDefinitionRegistrars 这个map当中。之后会执行这个map中对象的registerBeanDefinitions方法。

4.2 MyScannerRegistrar

模仿MapperScannerRegistrar，实现了ImportBeanDefinitionRegistrar接口

主要逻辑就是将一个实现了BeanDefinitionRegistryPostProcessor接口的后置处理器注册到BeanDefinitionMap当中。

4.3 MyPostRegistryPostProcessor

模仿MapperScannerConfigurer，实现了BeanDefinitionRegistryPostProcessor接口。

Spring会执行这个类中的postProcessBeanDefinitionRegistry方法。这个方法主要逻辑是构建一个自定义的扫描器，配置一些过滤规则，然后执行扫描。这里扫描的是com.gongsenlin.custom包下的类。

4.4 MyScanner

自定义的扫描器，继承了Spring的扫描器。可以对里面的一些方法进行重写。

4.5 MyFilter

在扫描器执行扫描的时候，会根据过滤器来过滤掉一些不符合条件的类。

自定义的过滤器，说明一些过滤规则。这里实现的是，类上注解包含了@MyBean的返回true。就是说留下包含注解@MyBean的类，过滤掉不符合的。

4.6 实验结果

com.gongsenlin.custom包下现在有两个类，一个X和一个Y。Y上添加了MyBean注解。

编写测试类，启动Spring容器。

可以看到添加了MyBean注解的类被添加到了BeanDefinitionMap当中。