ImportBeanDefinitionRegistrar 定义：

一个类实现 ImportBeanDefinitionRegistrar ，通过 configuration 注解和 import 注解可以动态注入一个bean 到spring 容器。mybatis mapper 类的扫码注册就是通过 ImportBeanDefinitionRegistrar 实现的。

spring 框架自动配置，与其他框架组件融合时，都是通过 ImportBeanDefinitionRegistrar 实现的。比如 feign的自动配置，MybatisAutoConfiguratio、以及很多以 Enable 开头的配置类。

  1. package org.springframework.context.annotation;
  3. import org.springframework.beans.factory.support.BeanDefinitionRegistry;
  4. import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
  5. import org.springframework.core.type.AnnotationMetadata;
  7. /**
  8.  * Interface to be implemented by types that register additional bean definitions when
  9.  * processing @{@link Configuration} classes. Useful when operating at the bean definition
  10.  * level (as opposed to {@code @Bean} method/instance level) is desired or necessary.
  11.  *
  12.  * <p>Along with {@code @Configuration} and {@link ImportSelector}, classes of this type
  13.  * may be provided to the @{@link Import} annotation (or may also be returned from an
  14.  * {@code ImportSelector}).
  15.  *
  16.  * <p>An {@link ImportBeanDefinitionRegistrar} may implement any of the following
  17.  * {@link org.springframework.beans.factory.Aware Aware} interfaces, and their respective
  18.  * methods will be called prior to {@link #registerBeanDefinitions}:
  19.  * <ul>
  20.  * <li>{@link org.springframework.context.EnvironmentAware EnvironmentAware}</li>
  21.  * <li>{@link org.springframework.beans.factory.BeanFactoryAware BeanFactoryAware}
  22.  * <li>{@link org.springframework.beans.factory.BeanClassLoaderAware BeanClassLoaderAware}
  23.  * <li>{@link org.springframework.context.ResourceLoaderAware ResourceLoaderAware}
  24.  * </ul>
  25.  *
  26.  * <p>See implementations and associated unit tests for usage examples.
  27.  *
  28.  * @author Chris Beams
  29.  * @since 3.1
  30.  * @see Import
  31.  * @see ImportSelector
  32.  * @see Configuration
  33.  */
  34. public interface ImportBeanDefinitionRegistrar {
  36.     /**
  37.      * Register bean definitions as necessary based on the given annotation metadata of
  38.      * the importing {@code @Configuration} class.
  39.      * <p>Note that {@link BeanDefinitionRegistryPostProcessor} types may <em>not</em> be
  40.      * registered here, due to lifecycle constraints related to {@code @Configuration}
  41.      * class processing.
  42.      * @param importingClassMetadata annotation metadata of the importing class
  43.      * @param registry current bean definition registry
  44.      */
  45.     public void registerBeanDefinitions(
  46.             AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);
  48. }

使用方法

1.一个类实现ImportBeanDefinitionRegistrar 接口；
2.registerBeanDefinitions 实现bean 的注册逻辑；
3.在 @configuration 注解的类上面使用 import 注解导入实现 ImportBeanDefinitionRegistrar 接口的类；

Demo

自动扫码注册包含 Mapper 注解的类到spring 容器

1.自定义注解

  1. /**
  2.  * @author: michael
  3.  * @create: 2020/12/30
  4.  */
  5. @Inherited
  6. @Target(ElementType.TYPE)
  7. @Retention(RetentionPolicy.RUNTIME)
  8. public @interface Mapper {
  10. }

2.定义一个类实现 ImportBeanDefinitionRegistrar 接口

通过重写registerBeanDefinitions 方法，把包含 mapper 注解的类扫描注册到 spring 容器。

  1. public class MapperDefinitionRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {
  3.     private ResourceLoader resourceLoader;
  5.     @Override
  6.     public void setResourceLoader(ResourceLoader resourceLoader) {
  7.         this.resourceLoader = resourceLoader;
  8.     }
  10.     @Override
  11.     public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,         BeanDefinitionRegistry registry) {
  12.         MapperDefinitionScanner scanner = new MapperDefinitionScanner(registry);
  13.         scanner.addIncludeFilter(new AnnotationTypeFilter(Mapper.class));
  14.         scanner.setResourceLoader(resourceLoader);
  15.         scanner.doScan("com.alibaba.demon.mapper");
  16.     }
  17. }

3.MapperDefinitionScanner 继承类ClassPathBeanDefinitionScanner

  1. public class MapperDefinitionScanner extends ClassPathBeanDefinitionScanner {
  2.     public MapperDefinitionScanner(BeanDefinitionRegistry registry) {
  3.         super(registry);
  4.     }
  5.     public void doScan(String packages) {
  6.         super.doScan(packages);
  7.     }
  8. }

4.使用import 注解引入 MapperDefinitionRegistrar

  1. @Configuration
  2. @Import(MapperDefinitionRegistrar.class)
  3. public class MapperAutoConfig {
  6. }

5.定义一个类，使用 mapper注解

  1. @Mapper
  2. public class  WaybillMapper {
  5. }

6. 测试，可以正常跑通

  1. @SpringBootTest
  2. @RunWith(SpringRunner.class)
  3. public class MapperAutoConfigTest {
  5.     @Autowired
  6.     private WaybillMapper waybillMapper;
  8.     @Test
  9.     public void  test() {
  10.         Assert.assertNotNull(waybillMapper.getClass());
  11.     }
  12. }

Spring data jpa中的使用

jpa 的自动扫描注册就使用的是 ImportBeanDefinitionRegistrar

EnableJpaRepositories

  2. /**
  3.  * Annotation to enable JPA repositories. Will scan the package of the
  4.    annotated configuration class for Spring Data repositories by default.
  5.  * 
  6.  * @author Oliver Gierke
  7.  * @author Thomas Darimont
  8.  */
  9. @Target(ElementType.TYPE)
  10. @Retention(RetentionPolicy.RUNTIME)
  11. @Documented
  12. @Inherited
  13. @Import(JpaRepositoriesRegistrar.class)
  14. public @interface EnableJpaRepositories {
  16.     String[] value() default {};
  17.     String[] basePackages() default {};
  18.     Class<?>[] basePackageClasses() default {};
  19.     Filter[] includeFilters() default {};
  20.     Filter[] excludeFilters() default {};
  21.     String repositoryImplementationPostfix() default "Impl";
  22.     String namedQueriesLocation() default "";
  23.     Key queryLookupStrategy() default Key.CREATE_IF_NOT_FOUND;
  25.     Class<?> repositoryFactoryBeanClass() default JpaRepositoryFactoryBean.class;
  27.     /**
  28.      * Configure the repository base class to be used to create repository proxies for this particular configuration.
  29.      * 
  30.      * @return
  31.      * @since 1.9
  32.      */
  33.     Class<?> repositoryBaseClass() default DefaultRepositoryBaseClass.class;
  35.     // JPA specific configuration
  37.     /**
  38.      * Configures the name of the {@link EntityManagerFactory} bean definition to be used to create repositories
  39.      * discovered through this annotation. Defaults to {@code entityManagerFactory}.
  40.      * 
  41.      * @return
  42.      */
  43.     String entityManagerFactoryRef() default "entityManagerFactory";
  45.     /**
  46.      * Configures the name of the {@link PlatformTransactionManager} bean definition to be used to create repositories
  47.      * discovered through this annotation. Defaults to {@code transactionManager}.
  48.      * 
  49.      * @return
  50.      */
  51.     String transactionManagerRef() default "transactionManager";
  53.     /**
  54.      * Configures whether nested repository-interfaces (e.g. defined as inner classes) should be discovered by the
  55.      * repositories infrastructure.
  56.      */
  57.     boolean considerNestedRepositories() default false;
  59.     /**
  60.      * Configures whether to enable default transactions for Spring Data JPA repositories. Defaults to {@literal true}. If
  61.      * disabled, repositories must be used behind a facade that's configuring transactions (e.g. using Spring's annotation
  62.      * driven transaction facilities) or repository methods have to be used to demarcate transactions.
  63.      * 
  64.      * @return whether to enable default transactions, defaults to {@literal true}.
  65.      */
  66.     boolean enableDefaultTransactions() default true;
  67. }

JpaRepositoriesRegistrar

  1. class JpaRepositoriesRegistrar extends RepositoryBeanDefinitionRegistrarSupport {
  4.     @Override
  5.     protected Class<? extends Annotation> getAnnotation() {
  6.         return EnableJpaRepositories.class;
  7.     }
  8.     @Override
  9.     protected RepositoryConfigurationExtension getExtension() {
  10.         return new JpaRepositoryConfigExtension();
  11.     }
  12. }

RepositoryBeanDefinitionRegistrarSupport

  1. public abstract class RepositoryBeanDefinitionRegistrarSupport
  2.         implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
  4.     private @SuppressWarnings("null") @Nonnull ResourceLoader resourceLoader;
  5.     private @SuppressWarnings("null") @Nonnull Environment environment;
  8.     @Override
  9.     public void setResourceLoader(ResourceLoader resourceLoader) {
  10.         this.resourceLoader = resourceLoader;
  11.     }
  13.     @Override
  14.     public void setEnvironment(Environment environment) {
  15.         this.environment = environment;
  16.     }
  18.     /*
  19.      * (non-Javadoc)
  20.      * @see org.springframework.context.annotation.ImportBeanDefinitionRegistrar#registerBeanDefinitions(org.springframework.core.type.AnnotationMetadata, org.springframework.beans.factory.support.BeanDefinitionRegistry)
  21.      */
  22.     public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry registry) {
  24.         Assert.notNull(annotationMetadata, "AnnotationMetadata must not be null!");
  25.         Assert.notNull(registry, "BeanDefinitionRegistry must not be null!");
  26.         Assert.notNull(resourceLoader, "ResourceLoader must not be null!");
  28.         // Guard against calls for sub-classes
  29.         if (annotationMetadata.getAnnotationAttributes(getAnnotation().getName()) == null) {
  30.             return;
  31.         }
  33.         AnnotationRepositoryConfigurationSource configurationSource = new AnnotationRepositoryConfigurationSource(
  34.                 annotationMetadata, getAnnotation(), resourceLoader, environment, registry);
  36.         RepositoryConfigurationExtension extension = getExtension();
  37.         RepositoryConfigurationUtils.exposeRegistration(extension, registry, configurationSource);
  39.         RepositoryConfigurationDelegate delegate = new RepositoryConfigurationDelegate(configurationSource, resourceLoader,
  40.                 environment);
  42.         delegate.registerRepositoriesIn(registry, extension);
  43.     }