TIP
本文涉及 Spring 扩展点，需要对 Spring 原理和扩展点有一定了解基础

@EnableJpaRepositories 源码跟踪#

在 @EnableJpaRepositories 注解中，通过 @Import 注解把 JpaRepositoriesRegistrar 注册到 IOC 容器

1
@Target({ElementType.TYPE})
2
@Retention(RetentionPolicy.RUNTIME)
3
@Documented
4
@Import({JpaRepositoriesRegistrar.class})
5
public @interface EnableJpaRepositories {
6

7
}

JpaRepositoriesRegistrar 继承了 RepositoryBeanDefinitionRegistrarSupport 的注册能力，它是通过实现 ImportBeanDefinitionRegistrar 接口（一般配合 @Import 使用）的 registerBeanDefinitions 方法在上下文启动时动态注册 Bean

ImportBeanDefinitionRegistrar

这个接口允许开发者在 Spring 应用启动过程中，通过编程方式注册额外的 Bean 定义

1
public abstract class RepositoryBeanDefinitionRegistrarSupport implements ImportBeanDefinitionRegistrar, ResourceLoaderAware, EnvironmentAware {
2

3
    /** @deprecated */
4
    @Deprecated
5
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
6
        this.registerBeanDefinitions(metadata, registry, ConfigurationClassPostProcessor.IMPORT_BEAN_NAME_GENERATOR);
7
    }
8

9
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry, BeanNameGenerator generator) {
10
        Assert.notNull(metadata, "AnnotationMetadata must not be null");
11
        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
12
        Assert.notNull(this.resourceLoader, "ResourceLoader must not be null");
13
        if (metadata.getAnnotationAttributes(this.getAnnotation().getName()) != null) {
14
            AnnotationRepositoryConfigurationSource configurationSource = new AnnotationRepositoryConfigurationSource(metadata, this.getAnnotation(), this.resourceLoader, this.environment, registry, generator);
15
            RepositoryConfigurationExtension extension = this.getExtension();
16
            RepositoryConfigurationUtils.exposeRegistration(extension, registry, configurationSource);
17
            RepositoryConfigurationDelegate delegate = new RepositoryConfigurationDelegate(configurationSource, this.resourceLoader, this.environment);
18
            // 在这个方法实现注册
19
            delegate.registerRepositoriesIn(registry, extension);
20
        }
21
    }
22
}

BeanDefinition 扫描#

最后调用 registerRepositoriesIn 方法注册 Bean，通过断点和观察，发现 BeanDefinition 是先通过 extension.getRepositoryConfigurations 方法扫描出 BeanDefinition 封装成 RepositoryConfiguration，然后通过 builder.build 方法重新构建 BeanDefinition，我们先跟踪 getRepositoryConfigurations 方法看如何扫描出 BeanDefinition，再回来看 build 方法如何构建 BeanDefinition

1
public List<BeanComponentDefinition> registerRepositoriesIn(BeanDefinitionRegistry registry, RepositoryConfigurationExtension extension) {
2
    if (logger.isInfoEnabled()) {
3
        logger.info(LogMessage.format("Bootstrapping Spring Data %s repositories in %s mode.", extension.getModuleName(), this.configurationSource.getBootstrapMode().name()));
4
    }
5

6
    extension.registerBeansForRoot(registry, this.configurationSource);
7
    RepositoryBeanDefinitionBuilder builder = new RepositoryBeanDefinitionBuilder(registry, extension, this.configurationSource, this.resourceLoader, this.environment);
8
    if (logger.isDebugEnabled()) {
9
        logger.debug(LogMessage.format("Scanning for %s repositories in packages %s.", extension.getModuleName(), this.configurationSource.getBasePackages().stream().collect(Collectors.joining(", "))));
10
    }
11

12
    StopWatch watch = new StopWatch();
13
    ApplicationStartup startup = getStartup(registry);
14
    StartupStep repoScan = startup.start("spring.data.repository.scanning");
15
    repoScan.tag("dataModule", extension.getModuleName());
16
    repoScan.tag("basePackages", () -> (String)this.configurationSource.getBasePackages().stream().collect(Collectors.joining(", ")));
17
    watch.start();
18
    // getRepositoryConfigurations 方法里扫描出 BeanDefinition 封装成 RepositoryConfiguration
19
    Collection<RepositoryConfiguration<RepositoryConfigurationSource>> configurations = extension.getRepositoryConfigurations(this.configurationSource, this.resourceLoader, this.inMultiStoreMode);
20
    List<BeanComponentDefinition> definitions = new ArrayList();
21
    Map<String, RepositoryConfiguration<?>> configurationsByRepositoryName = new HashMap(configurations.size());
22
    Map<String, RepositoryConfigurationAdapter<?>> metadataByRepositoryBeanName = new HashMap(configurations.size());
23

24
    for(RepositoryConfiguration<? extends RepositoryConfigurationSource> configuration : configurations) {
25
        configurationsByRepositoryName.put(configuration.getRepositoryInterface(), configuration);
26
        // definitionBuilder 是通过 configuration 构建 BeanDefinition，后面会回到这里分析 build 方法
27
        BeanDefinitionBuilder definitionBuilder = builder.build(configuration);
28
        extension.postProcess(definitionBuilder, this.configurationSource);
29
        if (this.isXml) {
30
            extension.postProcess(definitionBuilder, (XmlRepositoryConfigurationSource)this.configurationSource);
31
        } else {
32
            extension.postProcess(definitionBuilder, (AnnotationRepositoryConfigurationSource)this.configurationSource);
33
        }
34
        // beanDefinition 是从 definitionBuilder 获取
35
        RootBeanDefinition beanDefinition = (RootBeanDefinition)definitionBuilder.getBeanDefinition();
36
        beanDefinition.setTargetType(this.getRepositoryFactoryBeanType(configuration));
37
        beanDefinition.setResourceDescription(configuration.getResourceDescription());
38
        String beanName = this.configurationSource.generateBeanName(beanDefinition);
39
        if (logger.isTraceEnabled()) {
40
            logger.trace(LogMessage.format("Spring Data %s - Registering repository: %s - Interface: %s - Factory: %s", extension.getModuleName(), beanName, configuration.getRepositoryInterface(), configuration.getRepositoryFactoryBeanClassName()));
41
        }
42

43
        metadataByRepositoryBeanName.put(beanName, builder.buildMetadata(configuration));
44
        // 把 beanDefinition 注册到 BeanDefinitionRegistry
45
        registry.registerBeanDefinition(beanName, beanDefinition);
46
        definitions.add(new BeanComponentDefinition(beanDefinition, beanName));
47
    }
48

49
    potentiallyLazifyRepositories(configurationsByRepositoryName, registry, this.configurationSource.getBootstrapMode());
50
    watch.stop();
51
    repoScan.tag("repository.count", Integer.toString(configurations.size()));
52
    repoScan.end();
53
    if (logger.isInfoEnabled()) {
54
        logger.info(LogMessage.format("Finished Spring Data repository scanning in %s ms. Found %s %s repository interface%s.", watch.lastTaskInfo().getTimeMillis(), configurations.size(), extension.getModuleName(), configurations.size() == 1 ? "" : "s"));
55
    }
56

57
    this.registerAotComponents(registry, extension, metadataByRepositoryBeanName);
58
    return definitions;
59
}

在 getRepositoryConfigurations 方法中已经可以看到 BeanDefinition 是从 configSource.getCandidates(loader) 中返回，继续跟踪 getCandidates 方法

1
public <T extends RepositoryConfigurationSource> Collection<RepositoryConfiguration<T>> getRepositoryConfigurations(T configSource, ResourceLoader loader, boolean strictMatchesOnly) {
2
    Assert.notNull(configSource, "ConfigSource must not be null");
3
    Assert.notNull(loader, "Loader must not be null");
4
    Set<RepositoryConfiguration<T>> result = new HashSet();
5
    // BeanDefinition 是从 configSource.getCandidates(loader) 返回
6
    for(BeanDefinition candidate : configSource.getCandidates(loader)) {
7
        RepositoryConfiguration<T> configuration = this.<T>getRepositoryConfiguration(candidate, configSource);
8
        Class<?> repositoryInterface = this.loadRepositoryInterface(configuration, this.getConfigurationInspectionClassLoader(loader));
9
        if (repositoryInterface == null) {
10
            result.add(configuration);
11
        } else {
12
            RepositoryMetadata metadata = AbstractRepositoryMetadata.getMetadata(repositoryInterface);
13
            boolean qualifiedForImplementation = !strictMatchesOnly || configSource.usesExplicitFilters() || this.isStrictRepositoryCandidate(metadata);
14
            if (qualifiedForImplementation && this.useRepositoryConfiguration(metadata)) {
15
                result.add(configuration);
16
            }
17
        }
18
    }
19

20
    return result;
21
}

1
public Streamable<BeanDefinition> getCandidates(ResourceLoader loader) {
2
    // 继承了 spring 的 ClassPathScanningCandidateComponentProvider 的扫描能力，实现扫描 Repository 接口的逻辑
3
    RepositoryComponentProvider scanner = new RepositoryComponentProvider(this.getIncludeFilters(), this.registry);
4
    scanner.setConsiderNestedRepositoryInterfaces(this.shouldConsiderNestedRepositories());
5
    scanner.setEnvironment(this.environment);
6
    scanner.setResourceLoader(loader);
7
    Streamable var10000 = this.getExcludeFilters();
8
    Objects.requireNonNull(scanner);
9
    var10000.forEach(scanner::addExcludeFilter);
10
    // 通过 findCandidateComponents 方法返回扫描结果
11
    return Streamable.of(() -> this.getBasePackages().stream().flatMap((it) -> scanner.findCandidateComponents(it).stream()));
12
}

通过阅读源码，RepositoryComponentProvider 的实例扫描出 BeanDefinition，最终通过 getCandidates 方法返回，我们看 RepositoryComponentProvider 这个类

1
class RepositoryComponentProvider extends ClassPathScanningCandidateComponentProvider {
2

3
    private static boolean isGenericRepositoryInterface(@Nullable String interfaceName) {
4
        return Repository.class.getName().equals(interfaceName);
5
    }
6

7
    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
8
        // 扫描继承 Repository 接口的接口
9
        boolean isNonRepositoryInterface = !isGenericRepositoryInterface(beanDefinition.getBeanClassName());
10
        boolean isTopLevelType = !beanDefinition.getMetadata().hasEnclosingClass();
11
        boolean isConsiderNestedRepositories = this.isConsiderNestedRepositoryInterfaces();
12
        return isNonRepositoryInterface && (isTopLevelType || isConsiderNestedRepositories);
13
    }
14

15
    public Set<BeanDefinition> findCandidateComponents(String basePackage) {
16
        // 扫描包路径下符合 isCandidateComponent 条件的组件
17
        Set<BeanDefinition> candidates = super.findCandidateComponents(basePackage);
18

19
        for(BeanDefinition candidate : candidates) {
20
            if (candidate instanceof AnnotatedBeanDefinition) {
21
                AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition)candidate);
22
            }
23
        }
24

25
        return candidates;
26
    }
27
}

RepositoryComponentProvider 继承了 spring 的 ClassPathScanningCandidateComponentProvider 的扫描能力，重写 isCandidateComponent 判断组件的方法，把 Repository 接口扫描出来，通过 findCandidateComponents 方法扫描指定包路径，Spring 底层对 ASM 源码进行了扩展和封装，通过读取字节码文件，解析符合条件的文件，把文件的信息封装成 BeanDefinition

ClassPathScanningCandidateComponentProvider

是 Spring 框架中一个非常核心的类，它主要用于在类路径下扫描并发现带有特定注解的组件

到此，我们知道了 JPA 是如何实现把 Repository 接口扫描出来，但 IOC 容器只能注册实例，接口无法实例化，带着疑问我们回到之前构建 BeanDefinition 的地方

BeanDefinition 构建#

回到刚才 registerRepositoriesIn 方法里面的 builder.build 方法，继续跟踪 BeanDefinition 的构建，在 rootBeanDefinition 方法中会创建一个新的 BeanDefinition，并且把 beanClassName 设置为 JpaRepositoryFactoryBean

1
public BeanDefinitionBuilder build(RepositoryConfiguration<?> configuration) {
2
    Assert.notNull(this.registry, "BeanDefinitionRegistry must not be null");
3
    Assert.notNull(this.resourceLoader, "ResourceLoader must not be null");
4
    // rootBeanDefinition 会创建一个新的 BeanDefinition，并且设置 beanClassName 为 JpaRepositoryFactoryBean
5
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(configuration.getRepositoryFactoryBeanClassName());
6
    builder.getRawBeanDefinition().setSource(configuration.getSource());
7
    builder.addConstructorArgValue(configuration.getRepositoryInterface());
8
    builder.addPropertyValue("queryLookupStrategyKey", configuration.getQueryLookupStrategyKey());
9
    builder.addPropertyValue("lazyInit", configuration.isLazyInit());
10
    builder.setLazyInit(configuration.isLazyInit());
11
    builder.setPrimary(configuration.isPrimary());
12
    configuration.getRepositoryBaseClassName().ifPresent((it) -> builder.addPropertyValue("repositoryBaseClass", it));
13
    NamedQueriesBeanDefinitionBuilder definitionBuilder = new NamedQueriesBeanDefinitionBuilder(this.extension.getDefaultNamedQueryLocation());
14
    Optional var10000 = configuration.getNamedQueriesLocation();
15
    Objects.requireNonNull(definitionBuilder);
16
    var10000.ifPresent(definitionBuilder::setLocations);
17
    String namedQueriesBeanName = BeanDefinitionReaderUtils.uniqueBeanName(this.extension.getModuleIdentifier() + ".named-queries", this.registry);
18
    BeanDefinition namedQueries = definitionBuilder.build(configuration.getSource());
19
    this.registry.registerBeanDefinition(namedQueriesBeanName, namedQueries);
20
    builder.addPropertyValue("namedQueries", new RuntimeBeanReference(namedQueriesBeanName));
21
    this.registerCustomImplementation(configuration).ifPresent((it) -> {
22
        builder.addPropertyReference("customImplementation", it);
23
        builder.addDependsOn(it);
24
    });
25
    String fragmentsBeanName = this.registerRepositoryFragments(configuration);
26
    builder.addPropertyValue("repositoryFragments", new RuntimeBeanReference(fragmentsBeanName));
27
    return builder;
28
}

1
public static BeanDefinitionBuilder rootBeanDefinition(String beanClassName) {
2
    return rootBeanDefinition(beanClassName, (String)null);
3
}
4

5
public static BeanDefinitionBuilder rootBeanDefinition(String beanClassName, @Nullable String factoryMethodName) {
6
    BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new RootBeanDefinition());
7
    // 设置 beanClassName 为 JpaRepositoryFactoryBean
8
    builder.beanDefinition.setBeanClassName(beanClassName);
9
    builder.beanDefinition.setFactoryMethodName(factoryMethodName);
10
    return builder;
11
}

通过断点观察，新建的 BeanDefinition 的 beanClassName 都会被设置成 JpaRepositoryFactoryBean

JpaRepositoryFactoryBean#

观察 JpaRepositoryFactoryBean 这个类，通过继承 RepositoryFactoryBeanSupport 实现了 FactoryBean、InitializingBean、BeanClassLoaderAware 等扩展接口

RepositoryFactoryBeanSupport#

阅读 RepositoryFactoryBeanSupport 的源码，它主要通过实现 InitializingBean 的 afterPropertiesSet 方法，在 Bean 初始化完成后通过动态代理生成 SimpleJpaRepository 的代理对象交给 this.repository 成员变量，然后实现 FactoryBean 接口的 getObject 方法，返回这个代理对象

经常使用 JPA 的人应该对 SimpleJpaRepository 这个代理类不陌生，平时使用 CRUD 等内置方法，就是通过它调用的

InitializingBean 接口是 Bean 的生命周期扩展，afterPropertiesSet 方法是在 Bean 初始化之后执行

FactoryBean 接口是 Spring 的扩展点，当从 IOC 容器调用 getBean 方法获取 Bean 时，实际会调用 getObject 方法获取

所以刚才的疑问已经解决，实际注册到 IOC 容器的是 SimpleJpaRepository 这个代理类的实例

1
public abstract class RepositoryFactoryBeanSupport<T extends Repository<S, ID>, S, ID> implements InitializingBean, RepositoryFactoryInformation<S, ID>, FactoryBean<T>, BeanClassLoaderAware, BeanFactoryAware, ApplicationEventPublisherAware {
2

3
    public void afterPropertiesSet() {
4
        this.factory = this.createRepositoryFactory();
5
        this.factory.setQueryLookupStrategyKey(this.queryLookupStrategyKey);
6
        this.factory.setNamedQueries(this.namedQueries);
7
        this.factory.setEvaluationContextProvider((QueryMethodEvaluationContextProvider)this.evaluationContextProvider.orElseGet(() -> QueryMethodEvaluationContextProvider.DEFAULT));
8
        this.factory.setBeanClassLoader(this.classLoader);
9
        this.factory.setBeanFactory(this.beanFactory);
10
        if (this.publisher != null) {
11
            this.factory.addRepositoryProxyPostProcessor(new EventPublishingRepositoryProxyPostProcessor(this.publisher));
12
        }
13

14
        Optional var10000 = this.repositoryBaseClass;
15
        RepositoryFactorySupport var10001 = this.factory;
16
        Objects.requireNonNull(var10001);
17
        var10000.ifPresent(var10001::setRepositoryBaseClass);
18
        this.repositoryFactoryCustomizers.forEach((customizer) -> customizer.customize(this.factory));
19
        RepositoryComposition.RepositoryFragments customImplementationFragment = (RepositoryComposition.RepositoryFragments)this.customImplementation.map((xva$0) -> RepositoryFragments.just(new Object[]{xva$0})).orElseGet(RepositoryComposition.RepositoryFragments::empty);
20
        RepositoryComposition.RepositoryFragments repositoryFragmentsToUse = ((RepositoryComposition.RepositoryFragments)this.repositoryFragments.orElseGet(RepositoryComposition.RepositoryFragments::empty)).append(customImplementationFragment);
21
        this.repositoryMetadata = this.factory.getRepositoryMetadata(this.repositoryInterface);
22
        // getRepository 方法里生成 JDK 动态代理（SimpleJpaRepository），在 getObject 方法中加载并返回
23
        this.repository = Lazy.of(() -> (Repository)this.factory.getRepository(this.repositoryInterface, repositoryFragmentsToUse));
24
        // 这里会校验 repository 关联的 Entity 是否存在
25
        // Make sure the aggregate root type is present in the MappingContext (e.g. for auditing)
26
        this.mappingContext.ifPresent((it) -> it.getPersistentEntity(this.repositoryMetadata.getDomainType()));
27
        if (!this.lazyInit) {
28
            this.repository.get();
29
        }
30

31
    }
32

33
    public T getObject() {
34
        // 返回代理类
35
        return this.repository.get();
36
    }
37
}

总结#

@EnableJpaRepositories 注解是通过 ImportBeanDefinitionRegistrar 接口的 registerBeanDefinitions 方法在启动时动态注册 Bean
通过继承 ClassPathScanningCandidateComponentProvider 重写判断组件的方法扩展 spring 的扫描能力，扫描出继承了 Repository 接口的 BeanDefinition
把 Repository 接口的 BeanDefinition 替换成新建 BeanClassName 为 JpaRepositoryFactoryBean 的 BeanDefinition
当 JpaRepositoryFactoryBean 初始化后调用 InitializingBean 接口的 afterPropertiesSet 方法生成 SimpleJpaRepository 的动态代理对象
IOC 容器 getBean 时，通过 FactoryBean 接口的 getObject 方法获取到代理对象