Spring Data JPA系列
1、SpringBoot集成JPA及基本使用
2、Spring Data JPA Criteria查询、部分字段查询
3、Spring Data JPA数据批量插入、批量更新真的用对了吗
4、Spring Data JPA的一对一、LazyInitializationException异常、一对多、多对多操作
5、Spring Data JPA自定义Id生成策略、复合主键配置、Auditing使用
6、【源码】Spring Data JPA原理解析之Repository的自动注入(一)
前言
前面5篇分享了Spring Data JPA的用法，在Spring Data JPA中的Repository类不需要添加任何注解，为何就能够自动注入到Spring的IOC容器中呢？为何只需要继承JpaRepository或JJpaRepositoryImplementation接口，就能够使用系统的CRUD接口？为何只需要在接口方法中使用@Query注解，就能够实现对应数据库表的操作呢？让我们一起从源码中寻找答案吧！本篇基于Spring-boot-2.7.x的源码分析。
JpaRepositoriesAutoConfiguration
在Spring Boot框架中，通常通过XxxAutoConfiguration类自动注入某个插件的功能，Spring Data JPA也是如此。通常XxxAutoConfiguration类是在对应插件的starter包里面的，而Spring Data JPA的starter包下的META-INF并没有对应的spring.factories文件。如下：
搜索引用该类的地方：
说明JpaRepositoriesAutoConfiguration是spring boot自带的，但为何要使用Spring Data JPA的时候，还需要引入spring-boot-starter-data-jpa依赖呢？以下为JpaRepositoriesAutoConfiguration的代码：
package org.springframework.boot.autoconfigure.data.jpa;
@AutoConfiguration(after = { HibernateJpaAutoConfiguration.class, TaskExecutionAutoConfiguration.class })
@ConditionalOnBean(DataSource.class)
// 需要有JpaRepository类
@ConditionalOnClass(JpaRepository.class)
@ConditionalOnMissingBean({ JpaRepositoryFactoryBean.class, JpaRepositoryConfigExtension.class })
@ConditionalOnProperty(prefix = "spring.data.jpa.repositories", name = "enabled", havingValue = "true",
matchIfMissing = true)
// 自动引入内部类JpaRepositoriesImportSelector，在JpaRepositoriesImportSelector中，引入JpaRepositoriesRegistrar
@Import(JpaRepositoriesImportSelector.class)
public class JpaRepositoriesAutoConfiguration {
// 省略其他代码
static class JpaRepositoriesImportSelector implements ImportSelector {
private static final boolean ENVERS_AVAILABLE = ClassUtils.isPresent(
"org.springframework.data.envers.repository.config.EnableEnversRepositories",
JpaRepositoriesImportSelector.class.getClassLoader());
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
return new String[] { determineImport() };
}
private String determineImport() {
// 自定引入JpaRepositoriesRegistrar
return ENVERS_AVAILABLE ? EnversRevisionRepositoriesRegistrar.class.getName()
: JpaRepositoriesRegistrar.class.getName();
}
}
}
JpaRepositoriesAutoConfiguration要自动引入，条件是需要有JpaRepository类，而该类是在spring-data-jpa包下，所以需要额外导入spring-boot-starter-data-jpa依赖。
JpaRepositoriesAutoConfiguration自动注入时，会自动注入JpaRepositoriesImportSelector，该类实现了ImportSelector接口。Spring的配置类解析的时候，会执行ConfigurationClassParser.processImports(ConfigurationClass configClass, SourceClass currentSourceClass, Collection<SourceClass> importCandidates, boolean checkForCircularImports)，在该方法中，判断importCandidates是否继承于ImportSelector接口，如果是，调用ImportSelector的selectImports()方法，获取需要额外自动加入容器的类。
在JpaRepositoriesImportSelector中的selectImports()方法中，返回JpaRepositoriesRegistrar.class.getName()，自动注入JpaRepositoriesRegistrar类。
JpaRepositoriesRegistrar源码如下：
package org.springframework.boot.autoconfigure.data.jpa;
class JpaRepositoriesRegistrar extends AbstractRepositoryConfigurationSourceSupport {
private BootstrapMode bootstrapMode = null;
/**
* 指定@EnableJpaRepositories注解，所以在启动类中可以不添加该注解
* @return
*/
@Override
protected Class<? extends Annotation> getAnnotation() {
return EnableJpaRepositories.class;
}
/**
* 指定EnableJpaRepositoriesConfiguration配置类
* @return
*/
@Override
protected Class<?> getConfiguration() {
return EnableJpaRepositoriesConfiguration.class;
}
/**
* 指定RepositoryConfigurationExtension配置扩展
* @return
*/
@Override
protected RepositoryConfigurationExtension getRepositoryConfigurationExtension() {
return new JpaRepositoryConfigExtension();
}
@Override
protected BootstrapMode getBootstrapMode() {
return (this.bootstrapMode == null) ? BootstrapMode.DEFAULT : this.bootstrapMode;
}
@Override
public void setEnvironment(Environment environment) {
super.setEnvironment(environment);
configureBootstrapMode(environment);
}
private void configureBootstrapMode(Environment environment) {
String property = environment.getProperty("spring.data.jpa.repositories.bootstrap-mode");
if (StringUtils.hasText(property)) {
this.bootstrapMode = BootstrapMode.valueOf(property.toUpperCase(Locale.ENGLISH));
}
}
@EnableJpaRepositories
private static class EnableJpaRepositoriesConfiguration {
}
}
父类AbstractRepositoryConfigurationSourceSupport的核心源码代码如下：
package org.springframework.boot.autoconfigure.data;
/**
* 实现ImportBeanDefinitionRegistrar接口
*/
public abstract class AbstractRepositoryConfigurationSourceSupport
implements ImportBeanDefinitionRegistrar, BeanFactoryAware, ResourceLoaderAware, EnvironmentAware {
private ResourceLoader resourceLoader;
private BeanFactory beanFactory;
private Environment environment;
/**
* ImportBeanDefinitionRegistrar接口的方法，在ConfigurationClassBeanDefinitionReader.loadBeanDefinitionsForConfigurationClass() ->
* loadBeanDefinitionsFromRegistrars()【执行实现ImportBeanDefinitionRegistrar接口的类的
* registerBeanDefinitions()方法，注册其他bean】
*/
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry,
BeanNameGenerator importBeanNameGenerator) {
RepositoryConfigurationDelegate delegate = new RepositoryConfigurationDelegate(
getConfigurationSource(registry, importBeanNameGenerator), this.resourceLoader, this.environment);
// 子类JpaRepositoriesRegistrar.getRepositoryConfigurationExtension()返回JpaRepositoryConfigExtension
// 自动注入JpaRepositoryConfigExtension对象
delegate.registerRepositoriesIn(registry, getRepositoryConfigurationExtension());
}
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
registerBeanDefinitions(importingClassMetadata, registry, null);
}
private AnnotationRepositoryConfigurationSource getConfigurationSource(BeanDefinitionRegistry registry,
BeanNameGenerator importBeanNameGenerator) {
AnnotationMetadata metadata = AnnotationMetadata.introspect(getConfiguration());
return new AutoConfiguredAnnotationRepositoryConfigurationSource(metadata, getAnnotation(), this.resourceLoader,
this.environment, registry, importBeanNameGenerator) {
};
}
protected abstract RepositoryConfigurationExtension getRepositoryConfigurationExtension();
// 省略其他
}
通过以上的源码，Spring中会自动注入JpaRepositoryConfigExtension类。
JpaRepositoryConfigExtension
JpaRepositoryConfigExtension为Jpa repository配置扩展类，类的结构如下：
2.1 RepositoryConfigurationExtension的源码如下：
package org.springframework.data.repository.config;
/**
* SPI实现对存储库bean定义注册过程的特定于存储库的扩展
*/
public interface RepositoryConfigurationExtension {
/**
* 在所有Spring Data模块中唯一标识模块的字符串。不得包含任何空格。模块的描述性名称小写，且空格转化为“-”
*/
default String getModuleIdentifier() {
return getModuleName().toLowerCase(Locale.ENGLISH).replace(' ', '-');
}
/**
* 返回模块的描述性名称
* @return
*/
String getModuleName();
/**
* 返回｛@link BeanRegistryAotProcessor｝类型，该类型负责在本机运行时提供Spring Data Repository基础结构组件所需的AOT/本机配置。
* @return
*/
@NonNull
default Class<? extends BeanRegistrationAotProcessor> getRepositoryAotProcessor() {
return RepositoryRegistrationAotProcessor.class;
}
/**
* 通过给定的RepositoryConfigurationSource获得所有的RepositoryConfiguration对象
* @param configSource RepositoryConfigurationSource对象，封装了repository配置的源（XML/Annotation）
* @param loader 用于加载资源
* @param strictMatchesOnly 是否仅返回严格匹配的repository。为true将导致检查所处理的存储库接口和域类型是否由当前存储管理
*/
<T extends RepositoryConfigurationSource> Collection<RepositoryConfiguration<T>> getRepositoryConfigurations(
T configSource, ResourceLoader loader, boolean strictMatchesOnly);
/**
* 返回Spring Data命名查询的默认位置
*/
String getDefaultNamedQueryLocation();
/**
* 获取要使用的repository工厂类的名字
*/
String getRepositoryFactoryBeanClassName();
/**
* 回调以注册｛@literal repositories｝根节点的其他bean定义。这通常包括必须独立于要创建的存储库数量设置一次的bean。
* 将在注册任何存储库bean定义之前调用。
*/
void registerBeansForRoot(BeanDefinitionRegistry registry, RepositoryConfigurationSource configurationSource);
/**
* 回调用于对{@link BeanDefinition}进行后处理，并在必要时调整配置。
*/
void postProcess(BeanDefinitionBuilder builder, RepositoryConfigurationSource config);
/**
* 回调用于对从注释构建的{@link BeanDefinition}进行后处理，并在必要时调整配置。
*/
void postProcess(BeanDefinitionBuilder builder, AnnotationRepositoryConfigurationSource config);
/**
* 回调用于对从XML构建的{@link BeanDefinition}进行后处理，并在必要时调整配置。
*/
void postProcess(BeanDefinitionBuilder builder, XmlRepositoryConfigurationSource config);
}
2.2 RepositoryConfigurationExtensionSupport核心源码如下：
/**
* RepositoryConfigurationExtension的基本实现，以简化接口的实现。将根据实现者提供的模块前缀默认命名查询位置
* （请参见{getModulePrefix()）。截断后处理方法，因为默认情况下可能不需要它们。
*/
public abstract class RepositoryConfigurationExtensionSupport implements RepositoryConfigurationExtension {
@Override
public String getModuleName() {
return StringUtils.capitalize(getModulePrefix());
}
public <T extends RepositoryConfigurationSource> Collection<RepositoryConfiguration<T>> getRepositoryConfigurations(
T configSource, ResourceLoader loader) {
return getRepositoryConfigurations(configSource, loader, false);
}
/**
* 通过给定的RepositoryConfigurationSource获得所有的RepositoryConfiguration对象
* @param configSource RepositoryConfigurationSource对象，封装了repository配置的源（XML/Annotation）
* @param loader 用于加载资源
* @param strictMatchesOnly 是否仅返回严格匹配的repository。为true将导致检查所处理的存储库接口和域类型是否由当前存储管理
*/
public <T extends RepositoryConfigurationSource> Collection<RepositoryConfiguration<T>> getRepositoryConfigurations(
T configSource, ResourceLoader loader, boolean strictMatchesOnly) {
Assert.notNull(configSource, "ConfigSource must not be null");
Assert.notNull(loader, "Loader must not be null");
Set<RepositoryConfiguration<T>> result = new HashSet<>();
// configSource.getCandidates(loader)返回所有定义的Repository接口类
for (BeanDefinition candidate : configSource.getCandidates(loader)) {
RepositoryConfiguration<T> configuration = getRepositoryConfiguration(candidate, configSource);
// 获取Repository接口类，如GoodsRepository.class
Class<?> repositoryInterface = loadRepositoryInterface(configuration,
getConfigurationInspectionClassLoader(loader));
if (repositoryInterface == null) {
result.add(configuration);
continue;
}
// 解析接口的Repository元信息，保存对应Repository<T, ID>中T及ID的类型元信息
RepositoryMetadata metadata = AbstractRepositoryMetadata.getMetadata(repositoryInterface);
// 判断是否为Repository
boolean qualifiedForImplementation = !strictMatchesOnly || configSource.usesExplicitFilters()
|| isStrictRepositoryCandidate(metadata);
if (qualifiedForImplementation && useRepositoryConfiguration(metadata)) {
result.add(configuration);
}
}
return result;
}
}该类最核心的方法是getRepositoryConfigurations()方法，通过该方法，执行configSource.getCandidates()从configSource获取要自动注入Spring容器的Repository Bean。
2.2.1 通过configSource.getCandidates()方法，获取Repository Bean
代码在RepositoryConfigurationSourceSupport中实现，代码如下：
public abstract class RepositoryConfigurationSourceSupport implements RepositoryConfigurationSource {
/**
* 返回要为其创建存储库实例的存储库接口的源BeanDefinition
*/
@Override
public Streamable<BeanDefinition> getCandidates(ResourceLoader loader) {
// 定义一个RepositoryComponentProvider对象，传入包含的过滤器。
// getIncludeFilters()在子类中实现，
// 子类有AnnotationRepositoryConfigurationSource和XmlRepositoryConfigurationSource
RepositoryComponentProvider scanner = new RepositoryComponentProvider(getIncludeFilters(), registry);
scanner.setConsiderNestedRepositoryInterfaces(shouldConsiderNestedRepositories());
scanner.setEnvironment(environment);
scanner.setResourceLoader(loader);
// 添加排除的类型过滤器
getExcludeFilters().forEach(scanner::addExcludeFilter);
return Streamable.of(() -> getBasePackages().stream()//
// 遍历基础包，根据RepositoryComponentProvider定义时添加的包含filter和排除filter，扫描beanDefinition对象
.flatMap(it -> scanner.findCandidateComponents(it).stream()));
}
}2.2.1.1 在该方法中，先new一个RepositoryComponentProvider对象，其中的getIncludeFilter()和getExcludeFilters()分别用于添加扫描时要包含和排除的过滤器。对于使用注解实现的JPA，实现在子类AnnotationRepositoryConfigurationSource，该类主要职责是解析@EnableJpaRepositories注解的信息，其中的包含和排除的过滤器就是在该注解中配置的includeFilters和excludeFilters。
RepositoryComponentProvider代码如下：
/**
* 自定义类路径扫描候选组件提供程序ClassPathScanningCandidateComponentProvider，扫描给定基本接口的接口类。
* 不使用ClassPathScanningCandidateComponentProvider中的默认过滤器。
* 跳过添加@NoRepositoryBean的接口
*/
class RepositoryComponentProvider extends ClassPathScanningCandidateComponentProvider {
private boolean considerNestedRepositoryInterfaces;
private BeanDefinitionRegistry registry;
public RepositoryComponentProvider(Iterable<? extends TypeFilter> includeFilters, BeanDefinitionRegistry registry) {
// 父类的构造方法中传入false，即不适用默认的过滤器。即仅使用RepositoryComponentProvider添加的过滤器
super(false);
Assert.notNull(includeFilters, "Include filters must not be null");
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
// DefaultListableBeanFactory对象
this.registry = registry;
// 添加指定的类型过滤器
if (includeFilters.iterator().hasNext()) {
for (TypeFilter filter : includeFilters) {
addIncludeFilter(filter);
}
} else {
// 如果没有类型过滤器，则添加Repository接口的类型过滤器以及添加@RepositoryDefinition注解的类型过滤器
super.addIncludeFilter(new InterfaceTypeFilter(Repository.class));
// AnnotationTypeFilter类似InterfaceTypeFilter类，前面是用于过滤特定注解，后面用于过滤特定接口
super.addIncludeFilter(new AnnotationTypeFilter(RepositoryDefinition.class, true, true));
}
// 不扫描添加@NoRepositoryBean注解的类
addExcludeFilter(new AnnotationTypeFilter(NoRepositoryBean.class));
}
/**
* 重写父类的方法，在添加入参的TypeFilter以外，还需要同时满足继承Repository，或添加了@RepositoryDefinition注解
*/
@Override
public void addIncludeFilter(TypeFilter includeFilter) {
List<TypeFilter> filterPlusInterface = new ArrayList<>(2);
filterPlusInterface.add(includeFilter);
filterPlusInterface.add(new InterfaceTypeFilter(Repository.class));
// 添加TypeFilter及继承Repository的类型过滤器
super.addIncludeFilter(new AllTypeFilter(filterPlusInterface));
List<TypeFilter> filterPlusAnnotation = new ArrayList<>(2);
filterPlusAnnotation.add(includeFilter);
filterPlusAnnotation.add(new AnnotationTypeFilter(RepositoryDefinition.class, true, true));
// 添加TypeFilter及添加@RepositoryDefinition注解
super.addIncludeFilter(new AllTypeFilter(filterPlusAnnotation));
}
/**
* 自定义存储库接口检测并触发对它们的注释检测
*/
@Override
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
// 是非存储库接口，不是Repository.class
boolean isNonRepositoryInterface = !ClassUtils.isGenericRepositoryInterface(beanDefinition.getBeanClassName());
// 不是顶级类型
boolean isTopLevelType = !beanDefinition.getMetadata().hasEnclosingClass();
// 是考虑嵌套存储库
boolean isConsiderNestedRepositories = isConsiderNestedRepositoryInterfaces();
return isNonRepositoryInterface && (isTopLevelType || isConsiderNestedRepositories);
}
@Override
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
// 查找所有的Repository类
Set<BeanDefinition> candidates = super.findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
if (candidate instanceof AnnotatedBeanDefinition) {
// 处理通用注解，解析@Lazy、@Primary、@DependOn、@Role、@Description中的value，添加到BeanDefinition中
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
}
return candidates;
}
/**
* 接口类型过滤器，对应类必须的接口，且为构造方法传入的targetType或targetType的子类。
* 在super.match()中会遍历继承树，判断是否为targetType，即父类为targetType
*/
private static class InterfaceTypeFilter extends AssignableTypeFilter {
public InterfaceTypeFilter(Class<?> targetType) {
super(targetType);
}
/*
* 返回对应的类是否为接口，且为构造方法传入的targetType或targetType的子类。
* 在super.match()中会遍历继承树，判断是否为targetType，即父类为targetType
*/
@Override
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
throws IOException {
return metadataReader.getClassMetadata().isInterface() && super.match(metadataReader, metadataReaderFactory);
}
}
/**
* 匹配所有的类型过滤器
*/
private static class AllTypeFilter implements TypeFilter {
private final List<TypeFilter> delegates;
public AllTypeFilter(List<TypeFilter> delegates) {
Assert.notNull(delegates, "TypeFilter deleages must not be null");
this.delegates = delegates;
}
/*
* 遍历所有的TypeFilter，只要一个不匹配，则返回false
*/
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
throws IOException {
for (TypeFilter filter : delegates) {
if (!filter.match(metadataReader, metadataReaderFactory)) {
return false;
}
}
return true;
}
}
}在构造方法中，由于没有添加@EnableJpaRepositories注解注解，也就没有添加对应的includeFilters，所以走else分支，添加了Repository接口的类型过滤器以及@RepositoryDefinition注解的类型过滤器。然后添加了@NoRepositoryBean注解的排除过滤器。即会扫描实现Repository接口或添加@RepositoryDefinition注解的类，且类中不能添加@NoRepositoryBean注解。
另外，父类ClassPathScanningCandidateComponentProvider的构造方法中，如果传入的值为true，会添加@Component注解类的自动扫描。
2.2.1.2 然后调用RepositoryComponentProvider的findCandidateComponents(it)方法。该方法调用父类ClassPathScanningCandidateComponentProvider的findCandidateComponents()方法。
ClassPathScanningCandidateComponentProvider的代码如下：
package org.springframework.context.annotation;
/**
* 从基本包中扫描候选组件的组件提供程序。可以使用{@link CandidateComponentsIndex the index}（如果可用）
* 扫描类路径，否则，通过应用排除（exclude）和包含（include）过滤器来识别候选组件。
* 特定注解类型过滤器（AnnotationTypeFilter）、可转化的类型过滤器（AssignableTypeFilter，为特定类型的子类）支持
* CandidateComponentsIndex的筛选：如果指定了任何其他包含筛选器，则会忽略CandidateComponentsIndex，而使用类路径扫描。
*/
public class ClassPathScanningCandidateComponentProvider implements EnvironmentCapable, ResourceLoaderAware {
// 默认资源模式。扫描所有的.class文件
static final String DEFAULT_RESOURCE_PATTERN = "**/*.class";
protected final Log logger = LogFactory.getLog(getClass());
private String resourcePattern = DEFAULT_RESOURCE_PATTERN;
// 包含的过滤器，满足条件的类会被扫描注册成bean。默认为添加@Component、@Repository、
// @Service、@Controller、@ManagedBean、@Named注解的类，后面两个需要引入相关依赖
private final List<TypeFilter> includeFilters = new LinkedList<>();
// 不包含的过滤器，满足条件的类会被忽略，不扫描
private final List<TypeFilter> excludeFilters = new ArrayList<>();
// 运行时环境，可以获取系统变量和配置文件信息
@Nullable
private Environment environment;
// @Conditional条件判断的计算器。@Conditional可以添加在@Bean上，满足@Conditional条件的bean才会被加载到Spring容器中
@Nullable
private ConditionEvaluator conditionEvaluator;
// 资源匹配模式解析器
@Nullable
private ResourcePatternResolver resourcePatternResolver;
// MetadataReader的工厂类，用于读取类文件的元数据
@Nullable
private MetadataReaderFactory metadataReaderFactory;
// 提供对META-INF/spring.components中定义的候选者的访问控制
@Nullable
private CandidateComponentsIndex componentsIndex;
protected ClassPathScanningCandidateComponentProvider() {
}
/**
* 创建一个标注环境的扫描组件提供器。useDefaultFilters用于指定是否应用默认的过滤器。如果为true，会自动包含对
* @Component、@Repository、@Service、@Controller的支持
*/
public ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters) {
this(useDefaultFilters, new StandardEnvironment());
}
public ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters, Environment environment) {
// 如果为true，调用registerDefaultFilters()，注册默认的过滤器，包含对
// @Component、@Repository、@Service、@Controller的支持
if (useDefaultFilters) {
registerDefaultFilters();
}
setEnvironment(environment);
setResourceLoader(null);
}
/**
* 添加一个包含的类型过滤器，用于指定对应类型的组件在被包含的扫描结果中
*/
public void addIncludeFilter(TypeFilter includeFilter) {
this.includeFilters.add(includeFilter);
}
/**
* 添加一个排除的类型过滤器，用于指定对应类型的组件不在被包含的扫描结果中
*/
public void addExcludeFilter(TypeFilter excludeFilter) {
this.excludeFilters.add(0, excludeFilter);
}
/**
* 重置过滤器，清空包含和排除的过滤器集合，重写注册默认的类型过滤器
*/
public void resetFilters(boolean useDefaultFilters) {
this.includeFilters.clear();
this.excludeFilters.clear();
if (useDefaultFilters) {
registerDefaultFilters();
}
}
/**
* 注册默认的过滤器，包含对@Component、@Repository、@Service、@Controller、@ManagedBean、@Named的过滤
*/
@SuppressWarnings("unchecked")
protected void registerDefaultFilters() {
// 添加@Component过滤，@Repository、@Service、@Controller都添加了@Component，
// 也会过滤@Repository、@Service、@Controller
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
try {
// 添加@ManagedBean过滤
this.includeFilters.add(new AnnotationTypeFilter(
((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
}
catch (ClassNotFoundException ex) {
// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
}
try {
// 添加@Named过滤
this.includeFilters.add(new AnnotationTypeFilter(
((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
}
catch (ClassNotFoundException ex) {
// JSR-330 API not available - simply skip.
}
}
/**
* 设置用于加载资源的ResourceLoader实例
*/
@Override
public void setResourceLoader(@Nullable ResourceLoader resourceLoader) {
// 如果resourceLoader实现了ResourcePatternResolver，直接返回，否则创建一个PathMatchingResourcePatternResolver对象
this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
this.metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader);
// 读取配置文件META-INF/spring.components中的信息，如果有信息，创建一个CandidateComponentsIndex对象并保存配置信息返回
this.componentsIndex = CandidateComponentsIndexLoader.loadIndex(this.resourcePatternResolver.getClassLoader());
}
/**
* 设置用于创建MetadataReader实例的工厂。允许自定义如何读取类的元数据
*/
public void setMetadataReaderFactory(MetadataReaderFactory metadataReaderFactory) {
this.metadataReaderFactory = metadataReaderFactory;
}
/**
* 返回一个带缓存功能的MetadataReaderFactory工厂，可以将某个类对应的MetadataReader进行缓存
* @return
*/
public final MetadataReaderFactory getMetadataReaderFactory() {
if (this.metadataReaderFactory == null) {
this.metadataReaderFactory = new CachingMetadataReaderFactory();
}
return this.metadataReaderFactory;
}
/**
* 扫描指定包及其子包的候选组件
*/
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
// 如果componentsIndex不为null，即META-INF/spring.components中有配置信息，
// 且include过滤器都支持@Indexed注解，从配置中扫描
if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
}
else {
// 扫描特定包
return scanCandidateComponents(basePackage);
}
}
/**
* 判断包含的过滤器是否支持都支持@Indexed注解，都支持返回true，否则返回false
*/
private boolean indexSupportsIncludeFilters() {
for (TypeFilter includeFilter : this.includeFilters) {
if (!indexSupportsIncludeFilter(includeFilter)) {
return false;
}
}
return true;
}
/**
* 确认指定的filter是否支持@Indexed注解或者是javax.开头的注解
*/
private boolean indexSupportsIncludeFilter(TypeFilter filter) {
if (filter instanceof AnnotationTypeFilter) {
Class<? extends Annotation> annotation = ((AnnotationTypeFilter) filter).getAnnotationType();
return (AnnotationUtils.isAnnotationDeclaredLocally(Indexed.class, annotation) ||
annotation.getName().startsWith("javax."));
}
if (filter instanceof AssignableTypeFilter) {
Class<?> target = ((AssignableTypeFilter) filter).getTargetType();
return AnnotationUtils.isAnnotationDeclaredLocally(Indexed.class, target);
}
return false;
}
/**
* 获取TypeFilter的原型，即名称
*/
@Nullable
private String extractStereotype(TypeFilter filter) {
if (filter instanceof AnnotationTypeFilter) {
return ((AnnotationTypeFilter) filter).getAnnotationType().getName();
}
if (filter instanceof AssignableTypeFilter) {
return ((AssignableTypeFilter) filter).getTargetType().getName();
}
return null;
}
private Set<BeanDefinition> addCandidateComponentsFromIndex(CandidateComponentsIndex index, String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
Set<String> types = new HashSet<>();
for (TypeFilter filter : this.includeFilters) {
// 获取filter的名称。全限定名，包名加类名，如：org.springframework.stereotype.Component
String stereotype = extractStereotype(filter);
if (stereotype == null) {
throw new IllegalArgumentException("Failed to extract stereotype from " + filter);
}
// 查找basePackage包下所有stereotype类型的类的名称
types.addAll(index.getCandidateTypes(basePackage, stereotype));
}
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
for (String type : types) {
// 获取类中元数据读取器，包含类的资源信息、类元模型、类中添加的注解元模型
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(type);
// 判断给定的MetadataReader是否是一个候选组件。该组件不在排除过滤器中，
//是在包含的过滤器中，且满足@Conditional条件或没有@Conditional
if (isCandidateComponent(metadataReader)) {
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setSource(metadataReader.getResource());
// 确定给定的bean定义是否符合候选条件。默认实现检查类是否不是接口，是否不依赖于封闭类可以在子类中重写
if (isCandidateComponent(sbd)) {
if (debugEnabled) {
logger.debug("Using candidate component class from index: " + type);
}
candidates.add(sbd);
}
else {
if (debugEnabled) {
logger.debug("Ignored because not a concrete top-level class: " + type);
}
}
}
else {
if (traceEnabled) {
logger.trace("Ignored because matching an exclude filter: " + type);
}
}
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
return candidates;
}
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
// 包的查询路径，如：classpath*:com/jingai/jpa/**/*.class
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + '/' + this.resourcePattern;
// 获得符合查询条件的所有类的资源
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
for (Resource resource : resources) {
if (traceEnabled) {
logger.trace("Scanning " + resource);
}
if (resource.isReadable()) {
try {
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
if (isCandidateComponent(metadataReader)) {
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setSource(resource);
if (isCandidateComponent(sbd)) {
if (debugEnabled) {
logger.debug("Identified candidate component class: " + resource);
}
candidates.add(sbd);
}
else {
if (debugEnabled) {
logger.debug("Ignored because not a concrete top-level class: " + resource);
}
}
}
else {
if (traceEnabled) {
logger.trace("Ignored because not matching any filter: " + resource);
}
}
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to read candidate component class: " + resource, ex);
}
}
else {
if (traceEnabled) {
logger.trace("Ignored because not readable: " + resource);
}
}
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
return candidates;
}
protected String resolveBasePackage(String basePackage) {
return ClassUtils.convertClassNameToResourcePath(getEnvironment().resolveRequiredPlaceholders(basePackage));
}
/**
* 判断给定的MetadataReader是否是一个候选组件。该组件不在排除过滤器中，
* 是在包含的过滤器中，且满足@Conditional条件或没有@Conditional
*/
protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
// 如果在排除的过滤器中，返回false
for (TypeFilter tf : this.excludeFilters) {
if (tf.match(metadataReader, getMetadataReaderFactory())) {
return false;
}
}
// 如果在包含的过滤器中，满足@Conditional注解的配置要求或没有@Conditional注解，返回true，否则返回false
for (TypeFilter tf : this.includeFilters) {
if (tf.match(metadataReader, getMetadataReaderFactory())) {
return isConditionMatch(metadataReader);
}
}
return false;
}
/**
* 判断是否满足@Conditional注解的配置要求，如果不满足，返回false。没有添加或满足，返回true
*/
private boolean isConditionMatch(MetadataReader metadataReader) {
if (this.conditionEvaluator == null) {
this.conditionEvaluator =
new ConditionEvaluator(getRegistry(), this.environment, this.resourcePatternResolver);
}
return !this.conditionEvaluator.shouldSkip(metadataReader.getAnnotationMetadata());
}
/**
* 确定给定的bean定义是否符合候选条件。默认实现检查类是否不是接口，是否不依赖于封闭类可以在子类中重写。
*/
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
AnnotationMetadata metadata = beanDefinition.getMetadata();
// 确定基础类是独立的，即它是顶级类或可以独立于封闭类构造的嵌套类（静态内部类）
// 返回底层类是否表示具体类，即既不是接口也不是抽象类，或者是抽象类，但添加了@Lockup注解
return (metadata.isIndependent() && (metadata.isConcrete() ||
(metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName()))));
}
}在findCandidateComponents()方法中，执行else分支，调用scanCandidateComponents()，扫描特定包下的组件，传入此方法的basePackage的值没有设置的情况下，默认传入的是SpringBoot主方法所在的包。如本Spring Data JPA系列篇章传入的basePackage为com.jingai.jpa。
1）获得packageSearchPath，值为classpath*:com/jingai/jpa/**/*.class，即扫描com.jingai.jpa包及其子包所有class类；
2）遍历class类，获取类对应的MetadataReader。其中MetadataReader用于访问类元数据的简单外观，由ASM｛@link org.springframework.ASM.ClassReader｝读取。包含类文件资源信息、类元数据、注解元数据；
3）调用isCandidateComponent()方法，判断该组件不在排除excludeFilters过滤器中，是在包含includeFilters的过滤器中，且满足@Conditional条件或没有@Conditional。
结合上面调用构造函数时创建的过滤器可知：
默认的ClassPathScanningCandidateComponentProvider，
includeFilters包含添加了@Component、@Repository、@Service、@Controller注解的类【@Repository、@Service、@Controller注解添加了@Component，也会扫描】，会扫描。excludeFilters为空。该默认方式也是Spring默认处理的方式，所以在类中添加上面的注解，即可自动注入到Spring IOC容器；
对于RepositoryComponentProvider，继承了ClassPathScanningCandidateComponentProvider，传入构造方法的值为false，不会添加默认的过滤器，只添加了自己的过滤器，includeFilters包含实现了Repository接口、添加@RepositoryDefinition注解的类，会扫描。excludeFilters包含@NoRepositoryBean注解，不会扫描。即只扫描跟JPA的Repository相关的类。
在项目中，Repository实现了JpaRepositoryImplementation或JpaRepository接口，它们都继承了Repository接口。
此处有一个优化点，最好指定Repository所在的包，省得扫描整个SpringBoot启动类所在的包及其子包来获取Repository类；
4）调用isCandidateComponent()，确定给定的bean定义是否符合候选条件。默认实现检查类是否不是接口，是否不依赖于封闭类可以在子类中重写；
通过findCandidateComponents()方法，找出所有满足条件的组件，即bean。
2.2.2 遍历2.2.1中找到的所有满足条件的组件
组件实现Repository接口或添加了@RepositoryDefinition注解，且不能添加@NoRepositoryBean注解的类，调用loadRepositoryInterface()方法，获取Repository接口类；
调用AbstractRepositoryMetadata.getMetadata(repositoryInterface)，解析接口的Repository元信息，保存对应Repository<T, ID>中T及ID的类型元信息；
进行元数据判断，此处的strictMatchesOnly为false，所以都会加入到集合中返回；
2.3 JpaRepositoryConfigExtension源码如下
public class JpaRepositoryConfigExtension extends RepositoryConfigurationExtensionSupport {
private static final Class<?> PAB_POST_PROCESSOR = PersistenceAnnotationBeanPostProcessor.class;
private static final String DEFAULT_TRANSACTION_MANAGER_BEAN_NAME = "transactionManager";
private static final String ENABLE_DEFAULT_TRANSACTIONS_ATTRIBUTE = "enableDefaultTransactions";
private static final String JPA_METAMODEL_CACHE_CLEANUP_CLASSNAME = "org.springframework.data.jpa.util.JpaMetamodelCacheCleanup";
private static final String ESCAPE_CHARACTER_PROPERTY = "escapeCharacter";
private final Map<Object, String> entityManagerRefs = new LinkedHashMap<>();
@Override
public String getModuleName() {
return "JPA";
}
/**
* 获取要使用的repository工厂类的名字
*/
@Override
public String getRepositoryFactoryBeanClassName() {
return JpaRepositoryFactoryBean.class.getName();
}
@Override
protected String getModulePrefix() {
return getModuleName().toLowerCase(Locale.US);
}
/**
* 获取识别注解。识别@Entity和@MappedSuperclass。一个用于实体类、一个用于实体类的父类
* @return
*/
@Override
protected Collection<Class<? extends Annotation>> getIdentifyingAnnotations() {
return Arrays.asList(Entity.class, MappedSuperclass.class);
}
/**
* 获取识别类型，识别JpaRepository接口类。父类RepositoryConfigurationExtensionSupport.isStrictRepositoryCandidate()方法调用
* @return
*/
@Override
protected Collection<Class<?>> getIdentifyingTypes() {
return Collections.<Class<?>> singleton(JpaRepository.class);
}
// 省略其他
}在上面的2.2.2最后的元数据判断时，如果传入的strictMatchesOnly为true，会调用JpaRepositoryConfigExtension.getIdentifyingTypes()方法，判断Repository<T, ID>接口中的T是否添加了@Entity或@MappedSuperclass注解。
此处的getRepositoryFactoryBeanClassName()方法返回JpaRepositoryFactoryBean类名。
Repository加入Spring IOC容器
Spring启动时，通过ConfigurationClassBeanDefinitionReader.loadBeanDefinitionsFromRegistrars() -> ImportBeanDefinitionRegistrar.registerBeanDefinitions() -> AbstractRepositoryConfigurationSourceSupport.registerBeanDefinitions() -> RepositoryConfigurationDelegate.registerRepositoriesIn()，一步一步调用，执行到RepositoryConfigurationDelegate的registerRepositoriesIn()方法，代码如下：
public class RepositoryConfigurationDelegate {
public List<BeanComponentDefinition> registerRepositoriesIn(BeanDefinitionRegistry registry,
RepositoryConfigurationExtension extension) {
if (logger.isInfoEnabled()) {
logger.info(LogMessage.format("Bootstrapping Spring Data %s repositories in %s mode.", //
extension.getModuleName(), configurationSource.getBootstrapMode().name()));
}
extension.registerBeansForRoot(registry, configurationSource);
RepositoryBeanDefinitionBuilder builder = new RepositoryBeanDefinitionBuilder(registry, extension,
configurationSource, resourceLoader, environment);
if (logger.isDebugEnabled()) {
logger.debug(LogMessage.format("Scanning for %s repositories in packages %s.", //
extension.getModuleName(), //
configurationSource.getBasePackages().stream().collect(Collectors.joining(", "))));
}
StopWatch watch = new StopWatch();
ApplicationStartup startup = getStartup(registry);
StartupStep repoScan = startup.start("spring.data.repository.scanning");
repoScan.tag("dataModule", extension.getModuleName());
repoScan.tag("basePackages",
() -> configurationSource.getBasePackages().stream().collect(Collectors.joining(", ")));
watch.start();
// 获取所有的Repository类，如GoodsRepository
Collection<RepositoryConfiguration<RepositoryConfigurationSource>> configurations = extension
.getRepositoryConfigurations(configurationSource, resourceLoader, inMultiStoreMode);
List<BeanComponentDefinition> definitions = new ArrayList<>();
Map<String, RepositoryConfiguration<?>> configurationsByRepositoryName = new HashMap<>(configurations.size());
Map<String, RepositoryConfigurationAdapter<?>> metadataByRepositoryBeanName = new HashMap<>(configurations.size());
for (RepositoryConfiguration<? extends RepositoryConfigurationSource> configuration : configurations) {
// key为Repository类的接口名称，如com.jingai.jpa.dao.entity.GoodsRepository.class
configurationsByRepositoryName.put(configuration.getRepositoryInterface(), configuration);
// 创建一个BeanDefinitionBuilder
BeanDefinitionBuilder definitionBuilder = builder.build(configuration);
// definitionBuilder中添加transactionManager、entityManager等属性信息
extension.postProcess(definitionBuilder, configurationSource);
if (isXml) {
extension.postProcess(definitionBuilder, (XmlRepositoryConfigurationSource) configurationSource);
} else {
// definitionBuilder中添加enableDefaultTransactions属性信息
extension.postProcess(definitionBuilder, (AnnotationRepositoryConfigurationSource) configurationSource);
}
// 从builder中获取beanDefinition
RootBeanDefinition beanDefinition = (RootBeanDefinition) definitionBuilder.getBeanDefinition();
beanDefinition.setTargetType(getRepositoryFactoryBeanType(configuration));
beanDefinition.setResourceDescription(configuration.getResourceDescription());
// 获取bean的名称，如goodsRepository
String beanName = configurationSource.generateBeanName(beanDefinition);
if (logger.isTraceEnabled()) {
logger.trace(LogMessage.format(REPOSITORY_REGISTRATION, extension.getModuleName(), beanName,
configuration.getRepositoryInterface(), configuration.getRepositoryFactoryBeanClassName()));
}
// 保存
metadataByRepositoryBeanName.put(beanName, builder.buildMetadata(configuration));
// 自动注册goodsRepository，添加到bean容器
registry.registerBeanDefinition(beanName, beanDefinition);
definitions.add(new BeanComponentDefinition(beanDefinition, beanName));
}
potentiallyLazifyRepositories(configurationsByRepositoryName, registry, configurationSource.getBootstrapMode());
watch.stop();
repoScan.tag("repository.count", Integer.toString(configurations.size()));
repoScan.end();
if (logger.isInfoEnabled()) {
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"));
}
registerAotComponents(registry, extension, metadataByRepositoryBeanName);
return definitions;
}
}3.1 通过RepositoryConfigurationExtension.getRepositoryConfigurations()方法，也就是前面讲解的RepositoryConfigurationExtensionSupport的getRepositoryConfigurations()方法，获取所有实现Repository接口的类，封装成RepositoryConfiguration；
3.2 遍历RepositoryConfiguration，调用builder.build()方法，创建一个BeanDefinitionBuilder对象；其中build()方法如下：
class RepositoryBeanDefinitionBuilder {
public BeanDefinitionBuilder build(RepositoryConfiguration<?> configuration) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
Assert.notNull(resourceLoader, "ResourceLoader must not be null");
// configuration.getRepositoryFactoryBeanClassName()返回org.springframework.data.jpa.repository.support.JpaRepositoryFactoryBean
// 创建一个BeanDefinitionBuilder对象，其factoryMethodName为null
// BeanDefinitionBuilder.rootBeanDefinition()方法会将"org.springframework.data.jpa.repository.support.JpaRepositoryFactoryBean"
// 赋值给BeanDefinition的beanClass
BeanDefinitionBuilder builder = BeanDefinitionBuilder
.rootBeanDefinition(configuration.getRepositoryFactoryBeanClassName());
builder.getRawBeanDefinition().setSource(configuration.getSource());
// 构造方法参数值为接口名，如com.jingai.jpa.dao.GoodsRepository
builder.addConstructorArgValue(configuration.getRepositoryInterface());
// 配置属性。在RepositoryComponentProvider的findCandidateComponents()方法中，调用
// AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate)
// 解析类的@Lazy、@Primary、@DependOn、@Role、@Description等注解得到的值
builder.addPropertyValue("queryLookupStrategyKey", configuration.getQueryLookupStrategyKey());
builder.addPropertyValue("lazyInit", configuration.isLazyInit());
builder.setLazyInit(configuration.isLazyInit());
builder.setPrimary(configuration.isPrimary());
configuration.getRepositoryBaseClassName()//
.ifPresent(it -> builder.addPropertyValue("repositoryBaseClass", it));
// extension.getDefaultNamedQueryLocation()返回classpath*:META-INF/jpa-named-queries.properties
NamedQueriesBeanDefinitionBuilder definitionBuilder = new NamedQueriesBeanDefinitionBuilder(
extension.getDefaultNamedQueryLocation());
configuration.getNamedQueriesLocation().ifPresent(definitionBuilder::setLocations);
String namedQueriesBeanName = BeanDefinitionReaderUtils
.uniqueBeanName(extension.getModuleIdentifier() + ".named-queries", registry);
BeanDefinition namedQueries = definitionBuilder.build(configuration.getSource());
registry.registerBeanDefinition(namedQueriesBeanName, namedQueries);
builder.addPropertyValue("namedQueries", new RuntimeBeanReference(namedQueriesBeanName));
registerCustomImplementation(configuration).ifPresent(it -> {
builder.addPropertyReference("customImplementation", it);
builder.addDependsOn(it);
});
String fragmentsBeanName = registerRepositoryFragments(configuration);
builder.addPropertyValue("repositoryFragments", new RuntimeBeanReference(fragmentsBeanName));
return builder;
}
}核心逻辑是执行configuration.getRepositoryFactoryBeanClassName()返回org.springframework.data.jpa.repository.support.JpaRepositoryFactoryBean，创建一个BeanDefinitionBuilder对象，其factoryMethodName为null
BeanDefinitionBuilder.rootBeanDefinition()方法会将"org.springframework.data.jpa.repository.support.JpaRepositoryFactoryBean"赋值给BeanDefinition的beanClass。
3.3 获取builder中的BeanDefinition对象，执行registry.registerBeanDefinition(beanName, beanDefinition)，将Repository类及对应的beanDefinition添加到Spring IOC容器中；
小结
本篇源码比较多，做一个简单总结：
1、在SpringBoot中引入spring-boot-starter-data-jpa依赖时，会自动注入JpaRepositoriesAutoConfiguration，从而注入JpaRepositoryConfigExtension；
2、在JpaRepositoryConfigExtension的父类RepositoryConfigurationExtensionSupport的getRepositoryConfigurations()方法，获取所有实现Repository接口的类，封装成RepositoryConfiguration；
3、SpringBoot启动时，会执行RepositoryConfigurationDelegate的registerRepositoriesIn()方法，在该方法中，调用2中的方法，获取所有实现Repository接口的类，创建类的BeanDefinition对象，其中beanClass为"org.springframework.data.jpa.repository.support.JpaRepositoryFactoryBean"字符串。并执行registry.registerBeanDefinition(beanName, beanDefinition)，将Repository类及对应的beanDefinition添加到Spring IOC容器中；
限于篇幅，本篇就先讲解到这里。
关于本篇内容你有什么自己的想法或独到见解，欢迎在评论区一起交流探讨下吧。
