@Import(JpaRepositoriesRegistrar.class)
public @interface EnableJpaRepositories {
}
// 使用@Import导入的类
class JpaRepositoriesRegistrar extends RepositoryBeanDefinitionRegistrarSupport {
// 获取该类需要处理的注解信息
protected Class<? extends Annotation> getAnnotation() {
return EnableJpaRepositories.class;
}
// 返回可以对jpa配置进行扩展的操作类
protected RepositoryConfigurationExtension getExtension() {
return new JpaRepositoryConfigExtension();
}
// 注册BeanDefinition
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry, BeanNameGenerator generator) {
// 如果当前类中,不存在@EnableJpaRepositories属性,则不处理
if (metadata.getAnnotationAttributes(getAnnotation().getName()) == null) {
return;
}
// 创建用于解析@EnableJpaRepositories信息的类,详见AnnotationRepositoryConfigurationSource类解析
AnnotationRepositoryConfigurationSource configurationSource = new AnnotationRepositoryConfigurationSource(metadata, getAnnotation(), resourceLoader, environment, registry, generator);
// 获取对jap配置的扩展信息类,这是个抽象方法,不同的扩展实现不同
RepositoryConfigurationExtension extension = getExtension() {
return new JpaRepositoryConfigExtension();
}
// 将jpa扩展配置类RepositoryConfigurationExtension注册为Bean
RepositoryConfigurationUtils.exposeRegistration(extension, registry, configurationSource) {
// 获取扩展类的class
Class<? extends RepositoryConfigurationExtension> extensionType = extension.getClass();
// 获取beanName:"org.springframework.data.jpa.repository.config.JpaRepositoryConfigExtension#0"
String beanName = extensionType.getName().concat(GENERATED_BEAN_NAME_SEPARATOR).concat("0");
// 如果已经注册了,就不处理
if (registry.containsBeanDefinition(beanName)) {
return;
}
// 开始注册
RootBeanDefinition definition = new RootBeanDefinition(extensionType);
// 设置该Bean的数据来源,getSource也是一个抽象方法
// 这里是来源于标注了@EnableJpaRepositories的类
definition.setSource(configurationSource.getSource());
definition.setRole(AbstractBeanDefinition.ROLE_INFRASTRUCTURE);
// 设置为懒加载
definition.setLazyInit(true);
// 注册Bean
registry.registerBeanDefinition(beanName, definition);
}
// 创建一个Repository配置的装饰类
RepositoryConfigurationDelegate delegate = new RepositoryConfigurationDelegate(configurationSource, resourceLoader, environment);
// 注册Repository类型的所有Bean,详见类方法解释
delegate.registerRepositoriesIn(registry, extension)
}
}
// JPA中Repository的配置扩展类
class JpaRepositoryConfigExtension {
public String getModuleName() {
return "JPA";
}
// 创建Repository的工厂Bean
public String getRepositoryFactoryBeanClassName() {
return JpaRepositoryFactoryBean.class.getName();
}
// 处理的实体注解
protected Collection<Class<? extends Annotation>> getIdentifyingAnnotations() {
return Arrays.asList(Entity.class, MappedSuperclass.class);
}
// 使用扩展配置类注册处理Repository的Bean(后置处理器啥的)
public void registerBeansForRoot(BeanDefinitionRegistry registry, RepositoryConfigurationSource config) {
// 获取当前Bean的来源
Object source = config.getSource();
// 如果还没有注册,则注册"emBeanDefinitionRegistrarPostProcessor"的Bean
// 类型为: EntityManagerBeanDefinitionRegistrarPostProcessor
registerLazyIfNotAlreadyRegistered(
() -> new RootBeanDefinition(EntityManagerBeanDefinitionRegistrarPostProcessor.class)
, registry,
EM_BEAN_DEFINITION_REGISTRAR_POST_PROCESSOR_BEAN_NAME, source) {
// 如果存在,就不注册
if (registry.containsBeanDefinition(beanName)) {
return;
}
// 注册,并且设置为懒加载,当前Bean的源头是@Import导入的类
AbstractBeanDefinition definition = supplier.get();
definition.setSource(source);
// 设置为懒加载
definition.setLazyInit(true);
// 注册Bean
registry.registerBeanDefinition(beanName, definition);
}
// 注册懒加载的Bean,"jpaMappingContext"
// JpaMetamodelMappingContextFactoryBean
// 创建JpaMetamodelMappingContext的FactoryBean,用于创建Mapping映射MappingContext上下文对象
// MappingContext是用来映射实体与数据库之间关系的机制
registerLazyIfNotAlreadyRegistered(() -> new RootBeanDefinition(JpaMetamodelMappingContextFactoryBean.class), registry, JPA_MAPPING_CONTEXT_BEAN_NAME, source);
// internalPersistenceAnnotationProcessor: PersistenceAnnotationBeanPostProcessor
// 注册处理PersistenceContext,PersistenceUnit字段注入的处理类
registerLazyIfNotAlreadyRegistered(() -> new RootBeanDefinition(PAB_POST_PROCESSOR), registry, AnnotationConfigUtils.PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME, source);
// 注册默认的JPA上下文Bean
// "jpaContext": DefaultJpaContext
// 并设置该Bean是构造注入
// 内部保存了受管实体->对应操作这个实体的EntityManager的映射,从容器中获取所有EntityManager进行注入
registerLazyIfNotAlreadyRegistered(() -> {
RootBeanDefinition contextDefinition = new RootBeanDefinition(DefaultJpaContext.class);
contextDefinition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
return contextDefinition;
}, registry, JPA_CONTEXT_BEAN_NAME, source);
// 注册清理Jpa元模型缓存的类
//"org.springframework.data.jpa.util.JpaMetamodelCacheCleanup": JpaMetamodelCacheCleanup
registerIfNotAlreadyRegistered(() -> new RootBeanDefinition(JPA_METAMODEL_CACHE_CLEANUP_CLASSNAME), registry, JPA_METAMODEL_CACHE_CLEANUP_CLASSNAME, source);
// 用于JPA特定的SpEL函数的EvaluationContextExtension
registerIfNotAlreadyRegistered(() -> {
// 获取@EnableJpaRepositories注解的escapeCharacter属性值,指定的转义字符
Object value = AnnotationRepositoryConfigurationSource.class.isInstance(config ? config.getRequiredAttribute(ESCAPE_CHARACTER_PROPERTY, Character.class) : config.getAttribute(ESCAPE_CHARACTER_PROPERTY).orElse("\\");
// 创建JpaEvaluationContextExtension的BD
BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(JpaEvaluationContextExtension.class);
// 添加构造函数参数
builder.addConstructorArgValue(value);
// 生成BD
return builder.getBeanDefinition();
}, registry, JpaEvaluationContextExtension.class.getName(), source);
}
// 后置处理Repository的Bean的BD信息
public void postProcess(BeanDefinitionBuilder builder, RepositoryConfigurationSource source) {
// 获取@EnableJpaRepositories注解中的transactionManagerRef的属性值
Optional<String> transactionManagerRef = source.getAttribute("transactionManagerRef");
// 给BD添加属性事务管理器,默认为transactionManager
builder.addPropertyValue("transactionManager", transactionManagerRef.orElse(DEFAULT_TRANSACTION_MANAGER_BEAN_NAME));
// 给BD添加属性实体管理器
builder.addPropertyValue("entityManager", getEntityManagerBeanDefinitionFor(source, source.getSource()) {
// 添加SharedEntityManagerCreator这个实体管理器
BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition("org.springframework.orm.jpa.SharedEntityManagerCreator");
// 设置工厂方法
builder.setFactoryMethod("createSharedEntityManager");
// 添加SharedEntityManagerCreator的构造函数
builder.addConstructorArgReference(getEntityManagerBeanRef(config) {
// @EnableJpaRepositories注解中的entityManagerFactoryRef的属性值,引用的Bean
Optional<String> entityManagerFactoryRef = config.getAttribute("entityManagerFactoryRef");
// 默认为entityManagerFactory的Bean
return entityManagerFactoryRef.orElse("entityManagerFactory");
});
// 使用Builder生成BD
AbstractBeanDefinition bean = builder.getRawBeanDefinition();
// 设置数据来源
bean.setSource(source);
return bean;
});
// 给BD添加属性escapeCharacter,自定义的转义字符,用于处理SQL中的转义字符
builder.addPropertyValue(ESCAPE_CHARACTER_PROPERTY, getEscapeCharacter(source).orElse('\\'));
// 给BD添加属性mappingContext,引用mappingContext的Bean
builder.addPropertyReference("mappingContext", JPA_MAPPING_CONTEXT_BEAN_NAME) {
this.beanDefinition.getPropertyValues().add(name, new RuntimeBeanReference(beanName));
}
}
// 处理AnnotationRepositoryConfigurationSource类型的信息
public void postProcess(BeanDefinitionBuilder builder, AnnotationRepositoryConfigurationSource config) {
AnnotationAttributes attributes = config.getAttributes();
// 给BD添加属性enableDefaultTransactions,值为@EnableJpaRepositories注解中的enableDefaultTransactions属性值
builder.addPropertyValue(ENABLE_DEFAULT_TRANSACTIONS_ATTRIBUTE, attributes.getBoolean(ENABLE_DEFAULT_TRANSACTIONS_ATTRIBUTE));
}
protected String getModulePrefix() {
return getModuleName().toLowerCase(Locale.US);
}
// 获取自定义命名查询的文件路径
public String getDefaultNamedQueryLocation() {
return String.format("classpath*:META-INF/%s-named-queries.properties", getModulePrefix());
}
}
// 创建EntityManagerFactory对象的FactoryBean
// 用于解析@EnableJpaRepositories注解的配置信息类
class AnnotationRepositoryConfigurationSource {
public AnnotationRepositoryConfigurationSource(AnnotationMetadata metadata, Class<? extends Annotation> annotation, ResourceLoader resourceLoader, Environment environment, BeanDefinitionRegistry registry, BeanNameGenerator generator) {
this.environment = environment;
this.beanNameGenerator = new RepositoryBeanNameGenerator(classLoader, generator);
this.registry = registry;
// 获取@EnableJpaRepositories注解的所有属性
Map<String, Object> annotationAttributes = metadata.getAnnotationAttributes(annotation.getName());
if (annotationAttributes == null) {
throw new IllegalStateException(String.format("Unable to obtain annotation attributes for %s!", annotation));
}
// @EnableJpaRepositories注解的属性信息
this.attributes = new AnnotationAttributes(annotationAttributes);
// @EnableJpaRepositories注解的元信息
this.enableAnnotationMetadata = new StandardAnnotationMetadata(annotation);
// 配置类的元信息,标注@EnableJpaRepositories的配置类元数据
this.configMetadata = metadata;
// 资源加载器
this.resourceLoader = resourceLoader;
// 是否在@EnableJpaRepositories注解中设置了includeFilters,或者includeFilters属性
this.hasExplicitFilters = hasExplicitFilters(attributes) {
return Stream.of("includeFilters", "excludeFilters").anyMatch(it -> attributes.getAnnotationArray(it).length > 0);
}
}
// 获取当前注解信息的来源
public Object getSource() {
return configMetadata;
}
// 转换为检测实现类的配置信息,用来检测Repository的实现类
public ImplementationDetectionConfiguration toImplementationDetectionConfiguration(MetadataReaderFactory factory) {
return new SpringImplementationDetectionConfiguration(this, factory);
}
}
// Repository的配置代理
class RepositoryConfigurationDelegate {
public RepositoryConfigurationDelegate(RepositoryConfigurationSource configurationSource, ResourceLoader resourceLoader, Environment environment) {
// 是否是xml开启的
// <jpa:repositories base-package="com.example.repository" />
this.isXml = configurationSource instanceof XmlRepositoryConfigurationSource;
// 是否是注解开启的@EnableJpaRepositories
boolean isAnnotation = configurationSource instanceof AnnotationRepositoryConfigurationSource;
// 保存解析好的@EnableJpaRepositories配置信息,如果是XmlRepositoryConfigurationSource,那就是xml配置的信息
this.configurationSource = configurationSource;
// 保存资源加载器
this.resourceLoader = resourceLoader;
// 获取上下文环境对象
this.environment = defaultEnvironment(environment, resourceLoader);
// 是否存在多个创建Repository的工厂类
this.inMultiStoreMode = multipleStoresDetected() {
// 从spring.factories文件中,是否存在org.springframework.data.repository.core.support.RepositoryFactorySupport作为Key的类
boolean multipleModulesFound = SpringFactoriesLoader.loadFactoryNames(RepositoryFactorySupport.class, resourceLoader.getClassLoader()).size() > 1;
// 如果数量大于1,表示找到多个创建Repository的工厂类
return multipleModulesFound;
}
}
// 注册Repository类型的所有Bean,以及处理Repository接口的Bean
public List<BeanComponentDefinition> registerRepositoriesIn(BeanDefinitionRegistry registry, RepositoryConfigurationExtension extension) {
// 使用扩展配置类注册处理Repository的Bean(后置处理器啥的)
extension.registerBeansForRoot(registry, configurationSource);
// 创建可以创建Repository类以及实现类对应的Bean的Builder
RepositoryBeanDefinitionBuilder builder = new RepositoryBeanDefinitionBuilder(registry, extension, configurationSource, resourceLoader, environment);
// 构建的RepositoryBean的BeanDefinitionHolder
List<BeanComponentDefinition> definitions = new ArrayList<>();
// 获取jpa配置的扩展类中所有解析好的Repository接口的配置信息
Collection<RepositoryConfiguration<RepositoryConfigurationSource>> configurations = extension.getRepositoryConfigurations(configurationSource, resourceLoader, inMultiStoreMode)
{
Set<RepositoryConfiguration<T>> result = new HashSet<>();
// 遍历所有符合条件的Repository接口的BD
for (BeanDefinition candidate : configSource.getCandidates(loader) {
// 创建专门用于扫描Repository的扫描器
// 设置@EnableJpaRepositories注解中的includeFilters
RepositoryComponentProvider scanner = new RepositoryComponentProvider(getIncludeFilters(), registry);
// 设置是否需要扫描嵌套Repository接口,就是在类中的内部类
scanner.setConsiderNestedRepositoryInterfaces(shouldConsiderNestedRepositories() {
// 获取@EnableJpaRepositories注解中的considerNestedRepositories的属性
return attributes.containsKey(CONSIDER_NESTED_REPOSITORIES) && attributes.getBoolean(CONSIDER_NESTED_REPOSITORIES);
});
scanner.setEnvironment(environment);
scanner.setResourceLoader(loader);
// 给扫描器添加排除过滤器
getExcludeFilters().forEach(it -> scanner.addExcludeFilter(it));
// 获取@EnableJpaRepositories注解中的basePackages,basePackageClasses对应的包名进行扫描
return Streamable.of(() -> getBasePackages().stream()//
// 使用扫描器扫描符合条件的Repository接口
.flatMap(it -> scanner.findCandidateComponents(it).stream()));
}){
// 封装Repository接口的配置信息
RepositoryConfiguration<T> configuration = getRepositoryConfiguration(candidate, configSource) {
return new DefaultRepositoryConfiguration<>(configSource, definition, this);
}
// 加载Repository接口ClassLoader信息
ClassLoader classLoader = getConfigurationInspectionClassLoader(loader) {
// 获取资源加载的ClassLoader
ClassLoader classLoader = loader.getClassLoader();
// 如果类加载器不为空,并且是活跃的,返回InspectionClassLoader类加载器
return classLoader != null && LazyJvmAgent.isActive(classLoader) ? new InspectionClassLoader(loader.getClassLoader()) {
super(parent,true);
// 排除spring内置的类
excludePackage("org.springframework.");
} : loader.getClassLoader();
}
// 使用指定的类加载器加载Repositor接口
Class<?> repositoryInterface = loadRepositoryInterface(configuration, classLoader) {
// 获取接口名
String repositoryInterface = configuration.getRepositoryInterface();
// 创建接口对应的Class
return org.springframework.util.ClassUtils.forName(repositoryInterface, classLoader);
}
// 如果没有加载到指定的Repository
if (repositoryInterface == null) {
// 保存该接口配置
result.add(configuration);
continue;
}
// 获取接口的元信息
RepositoryMetadata metadata = AbstractRepositoryMetadata.getMetadata(repositoryInterface);
// 确定有实现资格的配置
// strictMatchesOnly:开启严格模式,在Spring.factories中,不存在多个JpaRepositoryFactory的情况下为false
// usesExplicitFilters: 是否在@EnableJpaRepositories配置了includeFilters,excludeFilters过滤器
// isStrictRepositoryCandidate: 是JpaRepository类型,或者Repository对应的实体类存在@Entity或者MappedSuperClass
boolean qualifiedForImplementation = !strictMatchesOnly || configSource.usesExplicitFilters() || isStrictRepositoryCandidate(metadata);
// 如果符合上面三种情况之一,并且不能是响应式相关的配置
if (qualifiedForImplementation && useRepositoryConfiguration(metadata)) {
// 保存符合条件的配置信息
result.add(configuration);
}
}
// 返回符合条件的Repository接口的配置信息
return result;
}
// 保存Repository接口名->Repository接口配置的映射信息
Map<String, RepositoryConfiguration<?>> configurationsByRepositoryName = new HashMap<>(configurations.size());
// 遍历所有符合条件的Repository接口配置
for (RepositoryConfiguration<? extends RepositoryConfigurationSource> configuration : configurations) {
// 保存配置映射信息
configurationsByRepositoryName.put(configuration.getRepositoryInterface(), configuration);
// 上面已经构造的RepositoryBeanDefinitionBuilder来创建Repository的BeanDefinitionBuilder
// 最终通过BeanDefinitionBuilder来生成Repository的BD
BeanDefinitionBuilder definitionBuilder = builder.build(configuration);
/**
* 处理jpa配置扩展类的信息
* {@link JpaRepositoryConfigExtension#postProcess(BeanDefinitionBuilder, RepositoryConfigurationSource)}
*/
extension.postProcess(definitionBuilder, configurationSource);
/**
* 继续处理jpa配置扩展类的信息,根据xml和注解形式的处理方式不同
* {@link JpaRepositoryConfigExtension#postProcess(BeanDefinitionBuilder, AnnotationRepositoryConfigurationSource)}
*/
if (isXml) {
extension.postProcess(definitionBuilder, (XmlRepositoryConfigurationSource) configurationSource);
} else {
extension.postProcess(definitionBuilder, (AnnotationRepositoryConfigurationSource) configurationSource);
}
// 生成JpaRepositoryFactoryBean的BD对象
AbstractBeanDefinition beanDefinition = definitionBuilder.getBeanDefinition();
// 设置是否是主要的配置
beanDefinition.setPrimary(configuration.isPrimary());
// 生成beanName,使用beanName生成器生成,这里的beanName就是Repository接口的beanName,beanClass是JpaRepositoryFactoryBean
String beanName = configurationSource.generateBeanName(beanDefinition);
// 保存一个属性到BD中,就是Repository接口的名称
beanDefinition.setAttribute(FACTORY_BEAN_OBJECT_TYPE, configuration.getRepositoryInterface());
// 注册该JpaRepositoryFactoryBean的Bean
registry.registerBeanDefinition(beanName, beanDefinition);
// 保存该BeanDefinitionHolder
definitions.add(new BeanComponentDefinition(beanDefinition, beanName));
}
// 处理@EnableJpaRepositories注解设置了懒加载的Repository接口
potentiallyLazifyRepositories(configurationsByRepositoryName, registry, configurationSource.getBootstrapMode());
// 返回所有处理好的Repository的BeanDefinition
return definitions;
}
// 处理设置了懒加载的Repository接口
private static void potentiallyLazifyRepositories(Map<String, RepositoryConfiguration<?>> configurations, BeanDefinitionRegistry registry, BootstrapMode mode) {
// 只处理容器是DefaultListableBeanFactory类型以及@EnableJpaRepositories配置的Repository的加载模式是懒加载
// 其他的情况不处理
if (!DefaultListableBeanFactory.class.isInstance(registry) || mode.equals(BootstrapMode.DEFAULT)) {
return;
}
// 强转为DefaultListableBeanFactory
DefaultListableBeanFactory beanFactory = DefaultListableBeanFactory.class.cast(registry);
// 获取自动注入的解析器,默认的自动注入解析器是ContextAnnotationAutowireCandidateResolver
// 他们可以来处理@Qualifier标记的bean是否符合条件,该bean是否是lazy来执行相应处理逻辑
AutowireCandidateResolver resolver = beanFactory.getAutowireCandidateResolver();
// 如果自动注入解析器不是ContextAnnotationAutowireCandidateResolver,LazyRepositoryInjectionPointResolver两种,不处理
if (!Arrays.asList(ContextAnnotationAutowireCandidateResolver.class, LazyRepositoryInjectionPointResolver.class).contains(resolver.getClass())) {
return;
}
// 将自动注入解析器统一包装LazyRepositoryInjectionPointResolver类型了来处理
AutowireCandidateResolver newResolver = LazyRepositoryInjectionPointResolver.class.isInstance(resolver)
? LazyRepositoryInjectionPointResolver.class.cast(resolver).withAdditionalConfigurations(configurations)
: new LazyRepositoryInjectionPointResolver(configurations);
// 重新设置自动注入的解析器
beanFactory.setAutowireCandidateResolver(newResolver);
// 如果模式为延迟加载,给容器注册一个监听器的Bean
if (mode.equals(BootstrapMode.DEFERRED)) {
beanFactory.registerSingleton(DeferredRepositoryInitializationListener.class.getName(), new DeferredRepositoryInitializationListener(beanFactory));
}
}
}
// 创建Repository的Bean的Builder类
class RepositoryBeanDefinitionBuilder {
public RepositoryBeanDefinitionBuilder(BeanDefinitionRegistry registry, RepositoryConfigurationExtension extension, RepositoryConfigurationSource configurationSource, ResourceLoader resourceLoader, Environment environment) {
// Bean工厂
this.registry = registry;
// jpa配置的扩展类
this.extension = extension;
// 资源加载器
this.resourceLoader = resourceLoader;
// 加载类的元数据工厂
this.metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader);
// 符合Repository接口条件的元数据信息,所以起名为Fragment,也就是部分Repository接口信息
this.fragmentMetadata = new FragmentMetadata(metadataReaderFactory);
// 检测Repository实现类的配置信息
ImplementationDetectionConfiguration config = configurationSource.toImplementationDetectionConfiguration(metadataReaderFactory)
{
return new SpringImplementationDetectionConfiguration(this, factory);
}
// 找Repository实现类的检测器
this.implementationDetector = new CustomRepositoryImplementationDetector(environment, resourceLoader, config);
}
// 创建需要创建Repository对应BD的Builder对象
public BeanDefinitionBuilder build(RepositoryConfiguration<?> configuration) {
/**
* 设置Repository接口的class,是使用JpaRepositoryFactoryBean生成对应的Bean
* {@link JpaRepositoryConfigExtension#getRepositoryFactoryBeanClassName()}
*/
BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(configuration.getRepositoryFactoryBeanClassName());
// 获取BD,并设置Bean的来源
builder.getRawBeanDefinition().setSource(configuration.getSource());
// 调价该BD的构造函数参数,接口名
// public JpaRepositoryFactoryBean(Class<? extends T> repositoryInterface) {
// super(repositoryInterface);
// }
builder.addConstructorArgValue(configuration.getRepositoryInterface());
// 添加JpaRepositoryFactoryBean的queryLookupStrategyKey属性值
builder.addPropertyValue("queryLookupStrategyKey", configuration.getQueryLookupStrategyKey());
// 添加JpaRepositoryFactoryBean的lazyInit属性值
builder.addPropertyValue("lazyInit", configuration.isLazyInit());
// 设置BD是否懒加载
builder.setLazyInit(configuration.isLazyInit());
// 设置@EnableJpaRepositories注解中的repositoryBaseClass,接口的基类
// 如果存在,给BD添加repositoryBaseClass属性
configuration.getRepositoryBaseClassName().ifPresent(it -> builder.addPropertyValue("repositoryBaseClass", it));
// 创建命名查询的BD的Builder对象
NamedQueriesBeanDefinitionBuilder definitionBuilder = new NamedQueriesBeanDefinitionBuilder(extension.getDefaultNamedQueryLocation());
// 设置命名查询的路径
// 获取@EnableJpaRepositories注解中的namedQueriesLocation值的路径
// 默认为classpath*:META-INF/jpa-named-queries.properties
// 配置文件内容User.findAllAdultUsers=SELECT u FROM User u WHERE u.id > 1
// @Query(name = "User.findAllAdultUsers")
configuration.getNamedQueriesLocation().ifPresent(definitionBuilder::setLocations);
// 创建命名查询对应的BD,就是给一个SQL起一个名称,存在指定路径中默认为classpath*:META-INF/jpa-named-queries.properties
// 然后可以直接使用@Query注解进行引用
BeanDefinition namedQueriesBeanDefinition = definitionBuilder.build(configuration.getSource()) {
// 注册PropertiesFactoryBean这个Bean
BeanDefinitionBuilder propertiesBuilder = BeanDefinitionBuilder.rootBeanDefinition(PropertiesFactoryBean.class);
// 需要找命名查询的文件路径
// 获取@EnableJpaRepositories注解中的namedQueriesLocation值的路径
// 默认为classpath*:META-INF/jpa-named-queries.properties
String locationsToUse = StringUtils.hasText(locations) ? locations : defaultLocation;
// 给BD添加locations属性值
propertiesBuilder.addPropertyValue("locations", locationsToUse);
// 如果没有命名查询路径
if (!StringUtils.hasText(locations)) {
// 设置BD属性值ignoreResourceNotFound,为没有找该文件即忽略
propertiesBuilder.addPropertyValue("ignoreResourceNotFound", true);
}
// 生成PropertiesFactoryBean对应的BD
AbstractBeanDefinition propertiesDefinition = propertiesBuilder.getBeanDefinition();
// 将命名查询的BD设置bean的来源
propertiesDefinition.setSource(source);
// 再生成一个PropertiesBasedNamedQueries对应的Builder
BeanDefinitionBuilder namedQueries = BeanDefinitionBuilder.rootBeanDefinition(PropertiesBasedNamedQueries.class);
// 添加构造函数参数,也就是说,PropertiesBasedNamedQueries的Bean需要一个Properties的Bean作为构造函数参数
// 而Properties的Bean需要使用上面注册的PropertiesFactoryBean来生成
// 但是参数传递的是一个Bean的BeanDefinition对象,到时需要会解析这个BD,拿到最终的PropertiesBean
namedQueries.addConstructorArgValue(propertiesDefinition);
// 生成PropertiesBasedNamedQueries的BeanDefinition
AbstractBeanDefinition namedQueriesDefinition = namedQueries.getBeanDefinition();
// 设置数据来源
namedQueriesDefinition.setSource(source);
// 返回命名查询的BeanDefinition
return namedQueriesDefinition;
}
// 给JpaRepositoryFactoryBean设置命名查询的Bean属性
// 这里设置的属性值为BeanDefinition,最终会解析这个BeanDefinition,然后生成该Bean赋值给该属性
builder.addPropertyValue("namedQueries", namedQueriesBeanDefinition);
// 注册自定义实现类
registerCustomImplementation(configuration).ifPresent(it -> {
// 添加属性customImplementation,引用该实现类的beanName
builder.addPropertyReference("customImplementation", it);
// 添加依赖关系
builder.addDependsOn(it);
});
// 碎片接口: 根据XxxRepository接口,获取它继承的所有接口,只要不是标记了NoRepositoryBean注解的Bean,其他的都属于碎片接口
// 注册一个生成碎片接口处理器的FactoryBean
BeanDefinitionBuilder fragmentsBuilder = BeanDefinitionBuilder.rootBeanDefinition(RepositoryFragmentsFactoryBean.class);
// 所有碎片接口处理器RepositoryFragment对应的beanName
List<String> fragmentBeanNames =
// 注册碎片接口的实现类以及碎片接口的处理器
registerRepositoryFragmentsImplementation(configuration)
// 转换为碎片接口处理器的beanName
.map(RepositoryFragmentConfiguration::getFragmentBeanName)
.collect(Collectors.toList());
// 给生成碎片接口的FactoryBean添加构造参数,将所有的碎片接口处理器的BeanName都保存好
fragmentsBuilder.addConstructorArgValue(fragmentBeanNames);
// 给生成JpaRepositoryFactoryBean的BD设置属性repositoryFragments,并对BD设置数据来源
// 这里设置的属性值为BeanDefinition,最终会解析这个BeanDefinition,然后生成该Bean赋值给该属性
builder.addPropertyValue("repositoryFragments", ParsingUtils.getSourceBeanDefinition(fragmentsBuilder, configuration.getSource()));
// 返回生成JpaRepositoryFactoryBean的BD的Builder对象
return builder;
}
// 注册自定义实现类的Bean,并返回实现类的BeanName
private Optional<String> registerCustomImplementation(RepositoryConfiguration<?> configuration) {
// 找实现类的配置信息
ImplementationLookupConfiguration lookup = configuration.toLookupConfiguration(metadataReaderFactory) {
// 转换为Repository实现类的检测配置信息
ImplementationDetectionConfiguration config = toImplementationDetectionConfiguration(factory) {
return new SpringImplementationDetectionConfiguration(this, factory);
}
// 在转换为DefaultImplementationLookupConfiguration查找的配置信息
return config.forRepositoryConfiguration(this) {
// DefaultImplementationLookupConfiguration它是继承ImplementationDetectionConfiguration
// 重写了需要扫描的路径,默认的扫描路径是@EnableJpaRepositories注解中basePackages路径
// 实际上现在这个方法返回的扫描路径就上当前接口对应的包名路径
return new DefaultImplementationLookupConfiguration(this, config.getRepositoryInterface()) {
public Streamable<String> getBasePackages() {
return config.getImplementationBasePackages();
}
};
}
}
// 获取实现类的BeanName,就是接口的首字母小写+实现类后缀
String beanName = lookup.getImplementationBeanName();
// 当前Bean是否存在
if (registry.containsBeanDefinition(beanName)) {
return Optional.of(beanName);
}
// 使用实现类的探测器进行扫描实现类的BeanDefinition
Optional<AbstractBeanDefinition> beanDefinition = implementationDetector.detectCustomImplementation(lookup);
// 给找到的实现类BeanDefinition设置Bean来源,并且注册该bean
return beanDefinition.map(it -> {
// 设置Bean的来源
it.setSource(configuration.getSource());
// 注册该实现类的Bean
// 因此,只要我们符合Repository实现类的规范,默认就是一个Bean对象,不需要添加@Component注解
registry.registerBeanDefinition(beanName, it);
return beanName;
});
}
// 根据Repository接口配置信息转换为Repository碎片信息
private Stream<RepositoryFragmentConfiguration> registerRepositoryFragmentsImplementation(RepositoryConfiguration<?> configuration) {
// 将Repository接口信息转换为Repository实现类的配置信息
ImplementationDetectionConfiguration config = configuration.toImplementationDetectionConfiguration(metadataReaderFactory)
{
return new SpringImplementationDetectionConfiguration(this, factory);
}
// 根据Repository接口,获取它继承的所有接口,只要不是标记了NoRepositoryBean注解的Bean,其他的都属于碎片接口
return fragmentMetadata.getFragmentInterfaces(configuration.getRepositoryInterface())
// 将所有的接口碎片转换对应的接口的配置信息
.map(it -> detectRepositoryFragmentConfiguration(it, config))
.flatMap(Optionals::toStream)
// 注册碎片接口实现类的Bean
.peek(it -> potentiallyRegisterFragmentImplementation(configuration, it))
// 注册碎片接口处理器
.peek(it -> potentiallyRegisterRepositoryFragment(configuration, it));
}
// 将所有的接口碎片转换对应的接口的配置信息
private Optional<RepositoryFragmentConfiguration> detectRepositoryFragmentConfiguration(String fragmentInterface, ImplementationDetectionConfiguration config) {
// 获取碎片接口对应的实现类配置信息
ImplementationLookupConfiguration lookup = config.forFragment(fragmentInterface) {
return new DefaultImplementationLookupConfiguration(this, fragmentInterfaceName);
}
/**
* {@link CustomRepositoryImplementationDetector#detectCustomImplementation(ImplementationLookupConfiguration)}
* 找到碎片接口的实现类对应的BeanDefinition,如果没有找到符合条件的实现类,那么这个碎片接口将会被排除
* 例如 UserRepository extends JpaRepository<User, Long>, CustomUserRepository, JpaSpecificationExecutor<User>
* 则碎片接口的候选者为: CustomUserRepository和JpaSpecificationExecutor
* 就会找CustomUserRepositoryImpl和JpaSpecificationExecutorImpl的实现类
* 但是实现类又需要满足一定的规则,要满足下列情况的实现类才可用
* 1. 如果该类实现类的真实类名与 "接口名+自定义实现类后缀"不一致,直接排除
* 2. 并且需要扫描的包名(接口对应的包名)必须与当前扫描的实现类的包名一致,否则也不会处理
* 换句话说,只会处理与注解中配置的自定义后缀一样的并且实现类的包名必须在接口对应的包或者子包类才会处理这个实现类
* 3. 案例: luck.spring.jpa.repository.impl.JpaSpecificationExecutorImpl implements org.springframework.data.jpa.repository.JpaSpecificationExecutor
* 虽然JpaSpecificationExecutorImpl实现类的命名规则与JpaSpecificationExecutor规则是符合条件的
* 但是,有一点,就是JpaSpecificationExecutorImpl是自己写的类,而JpaSpecificationExecutor是spring的类,两者不在同一个包内,就说明这个实现类不可以拿来直接使用
* 因此JpaSpecificationExecutor碎片接口将会被排除,除非在Spring的JpaSpecificationExecutor包中,存在JpaSpecificationExecutorImpl的实现类才可用
*/
Optional<AbstractBeanDefinition> beanDefinition = implementationDetector.detectCustomImplementation(lookup);
// 将碎片接口实现的BeanDefinition转换为Repository接口的碎片配置信息
return beanDefinition.map(bd -> new RepositoryFragmentConfiguration(fragmentInterface, bd));
}
// 注册碎片接口实现类的Bean
private void potentiallyRegisterFragmentImplementation(RepositoryConfiguration<?> repositoryConfiguration, RepositoryFragmentConfiguration fragmentConfiguration) {
// 获取接口碎片实现类的beanName
String beanName = fragmentConfiguration.getImplementationBeanName();
// 如果已经注册,不处理
if (registry.containsBeanDefinition(beanName)) {
return;
}
// 注册碎片接口的实现类
fragmentConfiguration.getBeanDefinition().ifPresent(bd -> {
// 设置Bean的来源
bd.setSource(repositoryConfiguration.getSource());
// 注册碎片接口实现类
registry.registerBeanDefinition(beanName, bd);
});
}
// 注册碎片接口处理器
private void potentiallyRegisterRepositoryFragment(RepositoryConfiguration<?> configuration, RepositoryFragmentConfiguration fragmentConfiguration) {
// 获取碎片接口处理器的beanName
String beanName = fragmentConfiguration.getFragmentBeanName();
// 已经注册了就不处理
if (registry.containsBeanDefinition(beanName)) {
return;
}
// 创建RepositoryFragment的类的BD,它表示一个碎片接口处理器,RepositoryFragment是一个接口,会通过静态方法implemented创建对应的实现类
BeanDefinitionBuilder fragmentBuilder = BeanDefinitionBuilder.rootBeanDefinition(RepositoryFragment.class, "implemented");
// 添加构造参数,为Repository的接口名称
fragmentBuilder.addConstructorArgValue(fragmentConfiguration.getInterfaceName());
// 添加构造参数,类型为引用类型,到时候会进行构造参数解析,会将引用转换为实际的Bean
// 这个RepositoryFragment碎片接口处理器引用碎片接口的实现类
fragmentBuilder.addConstructorArgReference(fragmentConfiguration.getImplementationBeanName());
// 给RepositoryFragment碎片接口处理器的Bean设置Bean的来源,并注册到容器中
registry.registerBeanDefinition(beanName, ParsingUtils.getSourceBeanDefinition(fragmentBuilder, configuration.getSource()));
}
}
// 封装了接口继承的所有接口的信息
// 只要不是标记了NoRepositoryBean注解的Bean,其他的都属于碎片接口
class FragmentMetadata {
// 解析类元数据的工具类
private final MetadataReaderFactory factory;
// 获取接口中所有的碎片接口
public Stream<String> getFragmentInterfaces(String interfaceName) {
// 获取接口中所有继承的接口,并排除标注了NoRepositoryBean注解的Bean
// 也就是除了标记了NoRepositoryBean注解的Bean,其他的都属于碎片接口
return Arrays.stream(getClassMetadata(interfaceName).getInterfaceNames()).filter(this::isCandidate);
}
// 是否是合格的RepositoryBean
private boolean isCandidate(String interfaceName) {
// 获取接口的元数据信息
AnnotationMetadata metadata = getAnnotationMetadata(interfaceName);
// 只要接口轴不存在NoRepositoryBean这个注解,就符合条件
return !metadata.hasAnnotation(NoRepositoryBean.class.getName());
}
// 获取类中的注解元信息
private AnnotationMetadata getAnnotationMetadata(String className) {
return factory.getMetadataReader(className).getAnnotationMetadata();
}
// 获取类的元数据信息
private ClassMetadata getClassMetadata(String className) {
return factory.getMetadataReader(className).getClassMetadata();
}
}
// 自定义Repository接口的实现类的检测器
class CustomRepositoryImplementationDetector {
public CustomRepositoryImplementationDetector(Environment environment, ResourceLoader resourceLoader, ImplementationDetectionConfiguration configuration) {
this.environment = environment;
this.resourceLoader = resourceLoader;
// 符合Repository实现类的Bean
this.implementationCandidates = Lazy.of(() -> findCandidateBeanDefinitions(configuration));
}
// 实际找Repository实现类的方法
private Set<BeanDefinition> findCandidateBeanDefinitions(ImplementationDetectionConfiguration config) {
// 通过实现类配置获取实现类后缀
String postfix = config.getImplementationPostfix();
// 创建Repository实现类的扫描器,只扫描Repository的实现类
ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false, environment);
provider.setResourceLoader(resourceLoader);
// 设置资源的格式,找**/*Impl(自定义后缀).class文件
provider.setResourcePattern(String.format(CUSTOM_IMPLEMENTATION_RESOURCE_PATTERN, postfix));
provider.setMetadataReaderFactory(config.getMetadataReaderFactory());
// 添加包含过滤器,因为有默认的过滤器,扫描@Component,但是Repository不需要添加@Component注解,所以扫描不到
// 所以添加一个可以扫描所有类的过滤器,这样就可以扫描到所有**/*Impl的类,再进行过滤
provider.addIncludeFilter((reader, factory) -> true);
// 添加排除的过滤器
config.getExcludeFilters().forEach(it -> provider.addExcludeFilter(it));
// 从实现类配置中,获取需要扫描的所有包名
return config.getBasePackages().stream()
// 遍历所有的包名,然后找到符合条件的RepositoryImpl的Bean
.flatMap(it -> provider.findCandidateComponents(it).stream())
// 找到所有实现类保存起来
.collect(Collectors.toSet());
}
// 查找实现类的逻辑
public Optional<AbstractBeanDefinition> detectCustomImplementation(ImplementationLookupConfiguration lookup) {
// 使用实现类检测器开始检测实现类的Bean
// 在构造方法初始化的时候,就设置了,使用的扫描包路径是@EnableJpaRepositories配置的路径
// this.implementationCandidates = Lazy.of(() -> findCandidateBeanDefinitions(configuration));
Set<BeanDefinition> definitions = implementationCandidates.getOptional()
// 为什么还有这个呢?
// 是因为还有一个构造方法其中this.implementationCandidates = Lazy.empty();
// 这个时候,就会扫描默认的路径,也就是接口对应的包名路径扫描一次
.orElseGet(() -> findCandidateBeanDefinitions(lookup))
.stream()
// 过滤符合条件的
/**
* {@link DefaultImplementationLookupConfiguration#matches(BeanDefinition)}
*/
.filter(bd -> lookup.matches(bd))
.collect(StreamUtils.toUnmodifiableSet());
return SelectionSet
// 断言该接口实现类的个数
.of(definitions, c -> c.isEmpty() ? Optional.empty() : throwAmbiguousCustomImplementationException(c))
// 先进行过滤,根据beanName进行过滤
.filterIfNecessary(lookup::hasMatchingBeanName)
// 获取唯一的实现类
.uniqueResult() {
Optional<T> uniqueResult = findUniqueResult() {
// 如果只有一个符合条件的实现类,返回该实现类,如果有多个,返回null
return Optional.ofNullable(collection.size() == 1 ? collection.iterator().next() : null);
}
// 如果找到多个符合条件的实现类,执行回调,抛出异常
return uniqueResult.isPresent() ? uniqueResult : fallback.apply(collection);
}
// 统一强转成AbstractBeanDefinition类型
.map(AbstractBeanDefinition.class::cast);
}
}
// 专门用于扫描Repository接口的扫描器
class RepositoryComponentProvider extends ClassPathScanningCandidateComponentProvider {
public RepositoryComponentProvider(Iterable<? extends TypeFilter> includeFilters, BeanDefinitionRegistry registry) {
// 不使用默认的过滤器
super(false);
this.registry = registry;
// 设置@EnableJpaRepositories注解中的includeFilters
if (includeFilters.iterator().hasNext()) {
for (TypeFilter filter : includeFilters) {
addIncludeFilter(filter);
}
}
// 如果@EnableJpaRepositories注解中没有配置includeFilters
else {
// 添加两个默认的
// 扫描Repository接口
super.addIncludeFilter(new InterfaceTypeFilter(Repository.class));
// 扫描带有RepositoryDefinition注解的类
super.addIncludeFilter(new AnnotationTypeFilter(RepositoryDefinition.class, true, true));
}
// 添加一个排除过滤器,排除标注了NoRepositoryBean注解的类
addExcludeFilter(new AnnotationTypeFilter(NoRepositoryBean.class));
}
// 扫描所有的@Repository接口
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = super.findCandidateComponents(basePackage) {
// 如果存在spring.components,只扫描这个配置文件中符合条件的类
if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
} else {
// 扫描所有的类
return scanCandidateComponents(basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
// 获取真实的URL
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + resolveBasePackage(basePackage) + '/' + this.resourcePattern;
// 获取到class文件的资源对象
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
for (Resource resource : resources) {
// 获取该Class文件的类元信息
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
// 判断该类是否是符合条件的Bean
if (isCandidateComponent(metadataReader) {
// 使用包含过滤器和排除过滤器进行匹配
for (TypeFilter tf : this.excludeFilters) {
if (tf.match(metadataReader, getMetadataReaderFactory())) {
return false;
}
}
for (TypeFilter tf : this.includeFilters) {
if (tf.match(metadataReader, getMetadataReaderFactory())) {
// 匹配成功之后,还需要校验@Condition注解
return isConditionMatch(metadataReader);
}
}
}){
// 如果是符合条件的Bean
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
// 封装成Bean
sbd.setResource(resource);
sbd.setSource(resource);
// 再判断该BD是否符合条件
if (isCandidateComponent(sbd) {
// 不是Repository接口
boolean isNonRepositoryInterface = !ClassUtils.isGenericRepositoryInterface(beanDefinition.getBeanClassName())
{
return Repository.class.getName().equals(interfaceName);
}
// 是顶级类,不能包含在其他类内部的类
boolean isTopLevelType = !beanDefinition.getMetadata().hasEnclosingClass();
// 是否包含嵌套的类
// 获取@EnableJpaRepositories注解中的considerNestedRepositories属性
boolean isConsiderNestedRepositories = isConsiderNestedRepositoryInterfaces();
// 不能是Repository类,并且是一个顶级类或者明确开启了支持嵌套类
return isNonRepositoryInterface && (isTopLevelType || isConsiderNestedRepositories);
}){
candidates.add(sbd);
}
}
}
}
}
}
// 遍历所有的符合条件的Repository接口
for (BeanDefinition candidate : candidates) {
// 处理通用注解@Primary,@Lazy...
if (candidate instanceof AnnotatedBeanDefinition) {
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
}
return candidates;
}
}
// 找Repository实现类的扫描器
class ClassPathScanningCandidateComponentProvider {
public ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters, Environment environment) {
// 是否使用默认的过滤器
if (useDefaultFilters) {
// 注册默认的过滤器
registerDefaultFilters() {
// 扫描@Component类
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
// 扫描@ManagedBean类
this.includeFilters.add(new AnnotationTypeFilter(((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
// 扫描Named类
this.includeFilters.add(new AnnotationTypeFilter(((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
}
}
// 设置环境
setEnvironment(environment);
setResourceLoader(null);
}
// 扫描组件
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
// 如果存在spring.components,只扫描这个配置文件中符合条件的类
if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
} else {
// 扫描所有的类
return scanCandidateComponents(basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
// 获取真实的URL
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + resolveBasePackage(basePackage) + '/' + this.resourcePattern;
// 获取到class文件的资源对象
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
for (Resource resource : resources) {
// 获取该Class文件的类元信息
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
// 判断该类是否是符合条件的Bean
if (isCandidateComponent(metadataReader) {
// 使用包含过滤器和排除过滤器进行匹配
for (TypeFilter tf : this.excludeFilters) {
if (tf.match(metadataReader, getMetadataReaderFactory())) {
return false;
}
}
for (TypeFilter tf : this.includeFilters) {
if (tf.match(metadataReader, getMetadataReaderFactory())) {
// 匹配成功之后,还需要校验@Condition注解
return isConditionMatch(metadataReader);
}
}
}){
// 如果是符合条件的Bean
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
// 封装成Bean
sbd.setResource(resource);
sbd.setSource(resource);
// 再判断该BD是否符合条件
if (isCandidateComponent(sbd) {
AnnotationMetadata metadata = beanDefinition.getMetadata();
// 1. 当前类是独立的,例如静态内部类和独立类,其他类不满足
// 2. 当前类是否是具体的类,也就是非抽象类或者接口
// 3. 当前类是抽象类,但是这个抽象类中有Lookup注解,也可以当成Bean
return (metadata.isIndependent() && (metadata.isConcrete() || (metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName()))));
}){
candidates.add(sbd);
}
}
}
}
}
}
}
// Repository实现类的检测配置信息
class SpringImplementationDetectionConfiguration {
// 解析到@EnableJpaRepositories的配置信息
private final RepositoryConfigurationSource source;
// 获取元数据的工具类
private final @Getter
MetadataReaderFactory metadataReaderFactory;
// 获取实现类的后缀
public String getImplementationPostfix() {
return source.getRepositoryImplementationPostfix() {
// 获取@EnableJpaRepositories注解中的repositoryImplementationPostfix属性的值
return String attribute = attributes.getString(attributeName);
}
// 默认为: Impl
.orElse(DefaultRepositoryConfiguration.DEFAULT_REPOSITORY_IMPLEMENTATION_POSTFIX);
}
public Streamable<String> getBasePackages() {
// 获取@EnableJpaRepositories注解中的basePackages和basePackageClasses对应的包路径
return source.getBasePackages();
}
public Streamable<TypeFilter> getExcludeFilters() {
// 获取@EnableJpaRepositories注解中的excludeFilters的排除过滤器
return source.getExcludeFilters();
}
public String generateBeanName(BeanDefinition definition) {
// 使用指定的BeanNameGenerator生成beanName
// AnnotationBeanNameGenerator
return source.generateBeanName(definition);
}
}
// Repository接口的配置信息
class DefaultRepositoryConfiguration {
// 解析好的@EnableJpaRepositories的注解配置信息
private final T configurationSource;
// Repository接口的BD
private final BeanDefinition definition;
// jpa配置的扩展类
private final RepositoryConfigurationExtension extension;
// 获取@EnableJpaRepositories注解中的扫描的包名
public Streamable<String> getBasePackages() {
return configurationSource.getBasePackages();
}
// 获取实现类的包名
public Streamable<String> getImplementationBasePackages() {
return Streamable.of(ClassUtils.getPackageName(getRepositoryInterface()));
}
// 获取当前Repository的接口名
public String getRepositoryInterface() {
return ConfigurationUtils.getRequiredBeanClassName(definition);
}
// 获取当前注解的配置信息
public RepositoryConfigurationSource getConfigSource() {
return configurationSource;
}
// 获取RepositoryFactoryBean的ClassName
public String getRepositoryFactoryBeanClassName() {
// 获取@EnableJpaRepositories注解中repositoryFactoryBeanClass属性
// 用于创建Repository代理Bean的FactoryBean
return configurationSource.getRepositoryFactoryBeanClassName()
// 默认为jpa配置扩展类中设置的JpaRepositoryFactoryBean
.orElseGet(extension::getRepositoryFactoryBeanClassName);
}
// ...还有一些配置方法
}
// Repository接口继承的接口的配置信息,它称为碎片接口
class RepositoryFragmentConfiguration {
public RepositoryFragmentConfiguration(String interfaceName, AbstractBeanDefinition beanDefinition) {
// 接口名
this.interfaceName = interfaceName;
// 实现类名
this.className = ConfigurationUtils.getRequiredBeanClassName(beanDefinition);
// 实现类BeanDefinition
this.beanDefinition = Optional.of(beanDefinition);
}
// 获取实现类的beanName,就是实现类的首字母小写
public String getImplementationBeanName() {
return Introspector.decapitalize(ClassUtils.getShortName(getClassName()));
}
// 所有碎片接口的beanName,为实现类的BeanName+Fragment
// 注意: 它不是Repository的beanName,而是RepositoryFragment的beanName,它表示一个碎片接口的处理器
// 因为每一个碎片接口都会被封装成RepositoryFragment对象,通过RepositoryFragment引用对应的接口和实现类完成操作
public String getFragmentBeanName() {
return getImplementationBeanName() + "Fragment";
}
}
// 默认的实现类查找配置信息,是一个装饰模式
class DefaultImplementationLookupConfiguration implements ImplementationLookupConfiguration {
// 被装饰的实现类配置信息
private final ImplementationDetectionConfiguration config;
// 接口名
private final String interfaceName;
// 实现类的beanName
private final String beanName;
DefaultImplementationLookupConfiguration(ImplementationDetectionConfiguration config, String interfaceName) {
this.config = config;
this.interfaceName = interfaceName;
// 默认为接口的首字母小写+自定义实现类后缀
this.beanName = Introspector.decapitalize(ClassUtils.getShortName(interfaceName).concat(config.getImplementationPostfix()));
}
// 获取实现类beanName
public String getImplementationBeanName() {
return beanName;
}
// 获取实现类后缀,如果没有在@EnableJpaRepositories配置,默认为Impl
public String getImplementationPostfix() {
return config.getImplementationPostfix();
}
// 获取排除Bean的过滤器
public Streamable<TypeFilter> getExcludeFilters() {
// 在@EnableJpaRepositories配置的排除过滤器只在,再添加一个排除NoRepositoryBean注解的Bean
return config.getExcludeFilters().and(new AnnotationTypeFilter(NoRepositoryBean.class));
}
// 获取扫描的包名,就是Repository接口的包名
public Streamable<String> getBasePackages() {
return Streamable.of(ClassUtils.getPackageName(interfaceName));
}
// 获取接口的实现类名,接口名+后缀名
public String getImplementationClassName() {
return ClassUtils.getShortName(interfaceName).concat(getImplementationPostfix());
}
// 判断该实现类的BeanDefinition是否符合实现类的命名条件
public boolean matches(BeanDefinition definition) {
// 获取实现类的类名
String beanClassName = definition.getBeanClassName();
// 如果没有类名,并且该Bean已经被排除了,就不需要
if (beanClassName == null || isExcluded(beanClassName, getExcludeFilters())) {
return false;
}
// 获取实现类的包名
String beanPackage = ClassUtils.getPackageName(beanClassName);
// 获取实现类的类名,不带包名
String shortName = ClassUtils.getShortName(beanClassName);
// 获取实际的类名,如果有.,从.开始切割,获取.后的类名
String localName = shortName.substring(shortName.lastIndexOf('.') + 1);
// 如果该类实现类的真实类名与 "接口名+自定义实现类后缀"不一致,直接排除
// 并且需要扫描的包名(接口对应的包名)必须与当前扫描的实现类的包名一致,否则也不会处理
// 换句话说,只会处理与注解中配置的自定义后缀一样的并且实现类的包名必须在接口对应的包或者子包类才会处理这个实现类
// 例如,luck.spring.jpa.repository.impl.JpaSpecificationExecutorImpl implements org.springframework.data.jpa.repository.JpaSpecificationExecutor
// 虽然JpaSpecificationExecutorImpl实现类的命名规则与JpaSpecificationExecutor规则是符合条件的
// 但是,有一点,就是JpaSpecificationExecutorImpl是自己写的类,而JpaSpecificationExecutor是spring的类,两者不在同一个包内,就说明这个实现类不可以拿来直接使用
return localName.equals(getImplementationClassName() {
return ClassUtils.getShortName(interfaceName).concat(getImplementationPostfix());
}) &&
// 获取接口对应的包名,也就是实现类也必须在接口对应的包名中,从符合条件
// 例如,luck.spring.jpa.repository.impl.JpaSpecificationExecutorImpl implements org.springframework.data.jpa.repository.JpaSpecificationExecutor
// 虽然JpaSpecificationExecutorImpl实现类的命名规则与JpaSpecificationExecutor规则是符合条件的
// 但是,有一点,就是JpaSpecificationExecutorImpl是自己写的类,而JpaSpecificationExecutor是spring的类,两者不在同一个包内,就说明这个实现类不可以拿来直接使用
getBasePackages() {
return Streamable.of(ClassUtils.getPackageName(interfaceName));
}.stream() anyMatch(it -> beanPackage.startsWith(it));
}
}
// 延迟加载的RepositoryBean的监听器,在容器刷新完成触发
class DeferredRepositoryInitializationListener implements ApplicationListener<ContextRefreshedEvent>, Ordered {
public void onApplicationEvent(ContextRefreshedEvent event) {
// 初始化所有的Repository的Bean
this.beanFactory.getBeansOfType(Repository.class) {
String[] beanNames = getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
Map<String, T> result = new LinkedHashMap<>(beanNames.length);
for (String beanName : beanNames) {
// 初始化Bean
Object beanInstance = getBean(beanName);
result.put(beanName, (T) beanInstance);
}
return result;
}
}
// 该Bean的优先级最高
public int getOrder() {
return Ordered.HIGHEST_PRECEDENCE;
}
}
// 处理事务的后置处理器
class TransactionalRepositoryProxyPostProcessor {
public TransactionalRepositoryProxyPostProcessor(ListableBeanFactory beanFactory, String transactionManagerName, boolean enableDefaultTransaction) {
this.beanFactory = beanFactory;
// 事务管理器beanName,默认为transactionManager
this.transactionManagerName = transactionManagerName;
// 默认为true
this.enableDefaultTransactions = enableDefaultTransaction;
}
// 处理逻辑
public void postProcess(ProxyFactory factory, RepositoryInformation repositoryInformation) {
// 自定义事务注解解析器
CustomAnnotationTransactionAttributeSource transactionAttributeSource = new CustomAnnotationTransactionAttributeSource() {
this.publicMethodsOnly =publicMethodsOnly;
this.annotationParsers =new LinkedHashSet<>(2);
// 添加事务注解解析器
this.annotationParsers.add(new
SpringTransactionAnnotationParser());
if(jta12Present)
{
this.annotationParsers.add(new JtaTransactionAnnotationParser());
}
if(ejb3Present)
{
this.annotationParsers.add(new Ejb3TransactionAnnotationParser());
}
}
// 设置Repository接口信息
transactionAttributeSource.setRepositoryInformation(repositoryInformation);
// 设置是否开启默认事务
transactionAttributeSource.setEnableDefaultTransactions(enableDefaultTransactions);
// 设置事务拦截器
TransactionInterceptor transactionInterceptor = new TransactionInterceptor(null, transactionAttributeSource);
// 设置事务管理器
transactionInterceptor.setTransactionManagerBeanName(transactionManagerName);
transactionInterceptor.setBeanFactory(beanFactory);
transactionInterceptor.afterPropertiesSet();
// 给创建代理的工厂添加拦截器
factory.addAdvice(transactionInterceptor);
}
}
// 用于在Repository操作实体之后,会发布的事件,处理实体中@DomainEvents方法和@AfterDomainEventPublication的方法
class EventPublishingRepositoryProxyPostProcessor {
// 事件发布器
private final ApplicationEventPublisher publisher;
public void postProcess(ProxyFactory factory, RepositoryInformation repositoryInformation) {
// 获取实体类型
EventPublishingMethod method = EventPublishingMethod.of(repositoryInformation.getDomainType())
// 如果没有找到可用的@DomainEvents方法和@AfterDomainEventPublication方法,则不需要处理
if (method == null) {
return;
}
// 如果找到了,就需要添加一个事件机制拦截器,用于在目标方法执行的过程中触发这些事件方法
factory.addAdvice(new EventPublishingMethodInterceptor(method, publisher));
}
// 需要发布事件的目标方法处理类
static class EventPublishingMethod {
public static EventPublishingMethod of(Class<?> type) {
// 查询实体类型是否存在缓存
EventPublishingMethod eventPublishingMethod = CACHE.get(type);
// 如果存在缓存,直接返回
if (eventPublishingMethod != null) {
return eventPublishingMethod.orNull() {
return this == EventPublishingMethod.NONE ? null : this;
}
}
// 获取实体类中,标注了@DomainEvents的方法
AnnotationDetectionMethodCallback callback = getDetector(type, DomainEvents.class);
// 获取实体类中,标注了AfterDomainEventPublication的方法
Supplier<AnnotationDetectionMethodCallback<?>> clearing = () -> getDetector(type, AfterDomainEventPublication.class);
// 统一保存@AfterDomainEventPublication和@DomainEvents方法和方法
EventPublishingMethod result = from(callback, clearing);
// 缓存该实体对应的事件方法
CACHE.put(type, result);
// 返回对应的方法
return result.orNull();
}
// 统一保存@AfterDomainEventPublication和@DomainEvents方法
private static EventPublishingMethod from(AnnotationDetectionMethodCallback<?> publishing, Supplier<AnnotationDetectionMethodCallback<?>> clearing) {
// 如果没有找到@DomainEvents注解,直接不处理
if (!publishing.hasFoundAnnotation()) {
return EventPublishingMethod.NONE;
}
// 获取标注了DomainEvents的方法
Method eventMethod = publishing.getRequiredMethod();
// 设置方法可执行
ReflectionUtils.makeAccessible(eventMethod);
// 获取标注了@AfterDomainEventPublication注解的方法
Method clearingMethod getClearingMethod(clearing.get());
// 将@DomainEvents方法和@AfterDomainEventPublication统一保存
return new EventPublishingMethod(eventMethod, clearingMethod);
}
// 获取标注了AfterDomainEventPublication注解的方法
private static Method getClearingMethod(AnnotationDetectionMethodCallback<?> clearing) {
// 如果不存在AfterDomainEventPublication注解,不处理
if (!clearing.hasFoundAnnotation()) {
return null;
}
// 获取方法,并设置可访问
Method method = clearing.getRequiredMethod();
ReflectionUtils.makeAccessible(method);
// 返回方法
return method;
}
// 获取实体类中标注的@DomainEvents或者AfterDomainEventPublication注解信息,如果存在多个,会根据顺序选最后一个,如果设置了enforceUniqueness,表示只能允许只有一个@DomainEvents方法
private static <T extends Annotation> AnnotationDetectionMethodCallback<T> getDetector(Class<?> type, Class<T> annotation) {
// 封装@DomainEvents或者AfterDomainEventPublication注解信息,会查找所有方法上存在的@DomainEvents或者AfterDomainEventPublication注解信息
AnnotationDetectionMethodCallback<T> callback = new AnnotationDetectionMethodCallback<>(annotation) {
// 查找的回调方法
public void doWith(Method method) {
// 先校验,如果找到了有注解的方法,并且不需要校验是否存在多个@DomainEvents或者AfterDomainEventPublication的方法,直接返回foundMethod
if (foundMethod != null && !enforceUniqueness) {
return;
}
// 找方法上是否存在@DomainEvents或者AfterDomainEventPublication注解
A foundAnnotation = AnnotatedElementUtils.findMergedAnnotation(method, annotationType);
// 如果存在
if (foundAnnotation != null) {
// 校验之前已经找到了@DomainEvents或者AfterDomainEventPublication的方法,并且要求只有设置唯一的一个@DomainEvents或者AfterDomainEventPublication方法,这个时候需要抛出异常
// 如果不强制,则可以多个@DomainEvents或者AfterDomainEventPublication共存
if (foundMethod != null && enforceUniqueness) {
throw new IllegalStateException(String.format(MULTIPLE_FOUND, foundAnnotation.getClass().getName(), foundMethod, method));
}
// 保存找到的注解信息
this.annotation = foundAnnotation;
// 保存找到的方法
this.foundMethod = method;
}
}
}
//
ReflectionUtils.doWithMethods(type, callback) {
Method[] methods = getDeclaredMethods(clazz, false);
// 遍历所有的方法,执行call回调,找@DomainEvents或者AfterDomainEventPublication的方法
for (Method method : methods) {
callback.doWith(method);
}
}
// 返回回调信息,内部包含找到的@DomainEvents或者AfterDomainEventPublication方法
return callback;
}
// 发布事件,@AfterDomainEventPublication和@DomainEvents方法
public void publishEventsFrom(@Nullable Object source, ApplicationEventPublisher publisher) {
// 如果发布的事件为null,不处理
if (source == null) {
return;
}
/// 将事件封装成集合,为了兼容List,要多次发布
for (Object aggregateRoot : asCollection(source)) {
// 执行@DomainEvents方法
Object res = ReflectionUtils.invokeMethod(publishingMethod, aggregateRoot);
// 将@DomainEvents方法的返回值作为事件发布
for (Object event : asCollection(res)) {
// 发布事件
publisher.publishEvent(event);
}
// 如果存在AfterDomainEventPublication方法
if (clearingMethod != null) {
// 执行AfterDomainEventPublication方法
ReflectionUtils.invokeMethod(clearingMethod, aggregateRoot);
}
}
}
}
// 事件机制拦截器,用于在目标方法执行的过程中触发@DomainEvents方法和@AfterDomainEventPublication方法
static class EventPublishingMethodInterceptor {
// @DomainEvents方法和@AfterDomainEventPublication方法
private final EventPublishingMethod eventMethod;
// 事件发布器
private final ApplicationEventPublisher publisher;
// 拦截方法
public Object invoke(@SuppressWarnings("null") MethodInvocation invocation) throws Throwable {
// 获取到Repository接口触发的方法参数
Object[] arguments = invocation.getArguments();
// 放行到下一个拦截器执行
Object result = invocation.proceed();
// 如果方法名不是saveXXX,则不处理,所以,只有在save方法才会触发这些事件
if (!invocation.getMethod().getName().startsWith("save")) {
return result;
}
// 如果Repository操作的方法只有一个,那么使用参数作为事件的发布对象,否则使用返回值作为事件发布的对象
Object eventSource = arguments.length == 1 ? arguments[0] : result;
// 发布事件
eventMethod.publishEventsFrom(eventSource, publisher);
// 返回执行结果
return result;
}
}
}
// 创建Repository接口的Bean
class JpaRepositoryFactoryBean extends TransactionalRepositoryFactoryBeanSupport extends RepositoryFactoryBeanSupport implements FactoryBean {
// 构造方法,需要传递一个Repository接口
public JpaRepositoryFactoryBean(Class<? extends T> repositoryInterface) {
super(repositoryInterface);
}
// 给当前Repository设置EntityManager
@PersistenceContext
public void setEntityManager(EntityManager entityManager) {
this.entityManager = entityManager;
}
public void setBeanFactory(BeanFactory beanFactory) {
// 初始化事务后置处理器
this.txPostProcessor = new TransactionalRepositoryProxyPostProcessor(listableBeanFactory, transactionManagerName, enableDefaultTransactions);
// 初始化异常后置处理器
this.exceptionPostProcessor = new PersistenceExceptionTranslationRepositoryProxyPostProcessor(listableBeanFactory) {
// 添加一个异常处理拦截器
factory.addAdvice(new
PersistenceExceptionTranslationInterceptor());
}
}
public void afterPropertiesSet() {
Assert.state(entityManager != null, "EntityManager must not be null!");
// 创建Repository的Bean的工厂类,因为实际上JpaRepositoryFactoryBean的getObject生成的Bean是从JpaRepositoryFactory工厂中获取的Bean
this.factory = createRepositoryFactory() {
// 创建Repository的Bean的工厂
RepositoryFactorySupport factory = doCreateRepositoryFactory() {
return createRepositoryFactory(entityManager) {
// 实际生产Repository接口实现类Bean的工厂
JpaRepositoryFactory jpaRepositoryFactory = new JpaRepositoryFactory(entityManager);
// 给工厂设置实体路径解析器
jpaRepositoryFactory.setEntityPathResolver(entityPathResolver);
// 设置转义字符
jpaRepositoryFactory.setEscapeCharacter(escapeCharacter);
// 返回Repository工厂
return jpaRepositoryFactory;
}
}
// 设置异常后置处理器
RepositoryProxyPostProcessor exceptionPostProcessor = this.exceptionPostProcessor;
if (exceptionPostProcessor != null) {
factory.addRepositoryProxyPostProcessor(exceptionPostProcessor);
}
// 设置事务后置处理器
/**
* {@link TransactionalRepositoryProxyPostProcessor(ListableBeanFactory, String, boolean)}
*/
RepositoryProxyPostProcessor txPostProcessor = this.txPostProcessor;
if (txPostProcessor != null) {
factory.addRepositoryProxyPostProcessor(txPostProcessor);
}
return factory;
}
// 设置查找策略,这些参数都是在BeanDefinition的时机就设置进来了
this.factory.setQueryLookupStrategyKey(queryLookupStrategyKey);
// 设置命名查询器
this.factory.setNamedQueries(namedQueries);
// 设置计算上下文的提供者,其实就是找Spring中EvaluationContextExtension的Bean,在初始化期间,就注册了JpaEvaluationContextExtension,用于解析SPEL
this.factory.setEvaluationContextProvider(evaluationContextProvider.orElseGet(() -> QueryMethodEvaluationContextProvider.DEFAULT));
this.factory.setBeanClassLoader(classLoader);
this.factory.setBeanFactory(beanFactory);
// 事件发布者
if (publisher != null) {
// 添加一个事件发布的后置处理器,用于处理实体的被触发之后的事件
// 用于在Repository操作实体之后,会发布的事件,处理实体中@DomainEvents方法和@AfterDomainEventPublication的方法
this.factory.addRepositoryProxyPostProcessor(new EventPublishingRepositoryProxyPostProcessor(publisher));
}
// 设置所有Repository的基类,在@EnableJpaRepositories(repositoryBaseClass = LuckRepository.class)设置,到时候Repository实现类就是LuckRepository
repositoryBaseClass.ifPresent(this.factory::setRepositoryBaseClass);
// 将Repository接口的自定义实现类转换转换为一个RepositoryFragments碎片
RepositoryFragments customImplementationFragment = customImplementation
.map(RepositoryFragments::just)
.orElseGet(RepositoryFragments::empty);
// 将所有存在的Repository碎片接口与自定义实现进行合并成一个大的碎片接口组合
// 这样,RepositoryFragments就组合了所有实现类的功能
RepositoryFragments repositoryFragmentsToUse = this.repositoryFragments
.orElseGet(RepositoryFragments::empty)
.append(customImplementationFragment);
// 获取Repository接口的元数据信息
this.repositoryMetadata = this.factory.getRepositoryMetadata(repositoryInterface);
// 缓存实体的信息并返回
// MappingContext是用来映射实体与数据库之间关系的机制,getPersistentEntity就是在缓存实体的信息
this.mappingContext.ifPresent(it -> it.getPersistentEntity(repositoryMetadata.getDomainType()));
// 生成Repository接口的实现类,传递的是一个函数式接口,只有到需要用到才会回调
/**
* {@link JpaRepositoryFactory#getRepository(Class, RepositoryFragments)}
*/
this.repository = Lazy.of(() -> this.factory.getRepository(repositoryInterface, repositoryFragmentsToUse));
// 如果不是懒加载
if (!lazyInit) {
// 执行this.factory.getRepository回调,生成repository实现类
this.repository.get();
}
}
}
// 实际生产Repository接口实现类Bean的工厂
class JpaRepositoryFactory {
// 创建代理的后置处理器,就是给要给代理添加拦截器
private final List<RepositoryProxyPostProcessor> postProcessors;
// Repository的基类
private Optional<Class<?>> repositoryBaseClass;
// 命名查询器
private NamedQueries namedQueries = new PropertiesBasedNamedQueries(new Properties());
public JpaRepositoryFactory(EntityManager entityManager) {
// 实体管理器
this.entityManager = entityManager;
// 查询的提取器的提供商,不同提供商的提取方式不一样,,可能是Hibernate persistence provider,EclipseLink persistence provider,Use standard JPA
this.extractor = PersistenceProvider.fromEntityManager(entityManager);
// crud方法的元数据后置处理器
this.crudMethodMetadataPostProcessor = new CrudMethodMetadataPostProcessor();
// 实体路径解析器
this.entityPathResolver = SimpleEntityPathResolver.INSTANCE;
// 添加RepositoryProxy代理的后置处理器
addRepositoryProxyPostProcessor(crudMethodMetadataPostProcessor);
// 添加RepositoryProxy代理的后置处理器
addRepositoryProxyPostProcessor((factory, repositoryInformation) -> {
// 如果有Repository中的方法,返回Stream,则需要添加一个代理方法拦截器
// SurroundingTransactionDetectorMethodInterceptor,它是一个枚举
if (hasMethodReturningStream(repositoryInformation.getRepositoryInterface())) {
SurroundingTransactionDetectorMethodInterceptor advice = SurroundingTransactionDetectorMethodInterceptor.INSTANCE
{
private final ThreadLocal<Boolean> SURROUNDING_TX_ACTIVE = new ThreadLocal<>();
// 保存当前线程是否真实获取到事务信息标记
SURROUNDING_TX_ACTIVE.set(TransactionSynchronizationManager.isActualTransactionActive());
// 放行
Object res = invocation.proceed();
// 删除标记
SURROUNDING_TX_ACTIVE.remove();
return res;
}
// 添加拦截器
factory.addAdvice(advice);
}
});
// 如果持久化机制的提供商是EclipseLink
if (extractor.equals(PersistenceProvider.ECLIPSELINK)) {
// 添加查询创建监听器
addQueryCreationListener(new EclipseLinkProjectionQueryCreationListener(entityManager));
}
}
// 获取Repository的实现
public <T> T getRepository(Class<T> repositoryInterface, RepositoryFragments fragments) {
// 获取Repository接口的元数据信息
RepositoryMetadata metadata = getRepositoryMetadata(repositoryInterface);
// 将所有碎片接口进行组合,返回一个Repository组合类
RepositoryComposition composition = getRepositoryComposition(metadata, fragments);
// 获取Repository接口信息
RepositoryInformation information = getRepositoryInformation(metadata, composition);
// 校验接口是否存在实现类
validate(information, composition);
// 生成Repository实现类
Object target = getTargetRepository(information);
// 准备给Repository创建代理对象
ProxyFactory result = new ProxyFactory();
// 设置目标类
result.setTarget(target);
// 设置需要实现的接口
result.setInterfaces(repositoryInterface, Repository.class, TransactionalProxy.class);
// 如果支持拦截该接口,添加一个拦截器
if (MethodInvocationValidator.supports(repositoryInterface)) {
result.addAdvice(new MethodInvocationValidator());
}
// 添加一个切面它只负责保存当前正在执行的MethodInvocation对象
result.addAdvisor(ExposeInvocationInterceptor.ADVISOR);
// 执行所有的后置处理器
/**
* {@link TransactionalRepositoryProxyPostProcessor#postProcess(ProxyFactory, RepositoryInformation)}
* {@link JpaRepositoryFactory(EntityManager entityManager)}
*/
postProcessors.forEach(processor -> processor.postProcess(result, information));
// 该接口是否存在默认方法,如果存在,需要添加拦截器
if (DefaultMethodInvokingMethodInterceptor.hasDefaultMethods(repositoryInterface)) {
// 添加默认方法拦截器
result.addAdvice(new DefaultMethodInvokingMethodInterceptor());
}
// 创建映射信息
ProjectionFactory projectionFactory = getProjectionFactory(classLoader, beanFactory);
// 添加查询方法执行拦截器,包含命名查询,普通查询等等
result.addAdvice(new QueryExecutorMethodInterceptor(information, projectionFactory));
// 将当前接口自动生成的实现类也进行组合
composition = composition.append(RepositoryFragment.implemented(target));
// 添加实现类方法执行器的拦截器
result.addAdvice(new ImplementationMethodExecutionInterceptor(composition));
// 获取Repository接口实现类的代理对象
T repository = (T) result.getProxy(classLoader);
// 返回代理对象
return repository;
}
// 生成Repository实现类
protected final JpaRepositoryImplementation<?, ?> getTargetRepository(RepositoryInformation information) {
// 获取Repository实现类
JpaRepositoryImplementation<?, ?> repository = getTargetRepository(information, entityManager) {
// 获取实体信息
JpaEntityInformation<?, Serializable> entityInformation = getEntityInformation(information.getDomainType());
// 创建实现类对象
Object repository = getTargetRepositoryViaReflection(information, entityInformation, entityManager) {
// 获取Repository的基类
Class<?> baseClass = information.getRepositoryBaseClass();
// 获取实现类对象
return getTargetRepositoryViaReflection(baseClass, constructorArguments);
}
// 生成的实现类必须是JpaRepositoryImplementation类型
Assert.isInstanceOf(JpaRepositoryImplementation.class, repository);
// 返回生成的实现类
return (JpaRepositoryImplementation<?, ?>) repository;
}
// 给实现类设置CRUD的元数据信息,就是生成一个CrudMethodMetadata的元数据对象
repository.setRepositoryMethodMetadata(crudMethodMetadataPostProcessor.getCrudMethodMetadata());
// 设置转义字符
repository.setEscapeCharacter(escapeCharacter);
// 返回实现类
return repository;
}
// 获取Repository接口信息
private RepositoryInformation getRepositoryInformation(RepositoryMetadata metadata, RepositoryComposition composition) {
// 生成缓存Key
RepositoryInformationCacheKey cacheKey = new RepositoryInformationCacheKey(metadata, composition);
// 缓存Repository的信息
return repositoryInformationCache.computeIfAbsent(cacheKey, key -> {
// 获取Repository接口的实现类基类
Class<?> baseClass = repositoryBaseClass.orElse(getRepositoryBaseClass(metadata));
// 返回默认的接口实现
return new DefaultRepositoryInformation(metadata, baseClass, composition);
});
}
// 将所有碎片接口进行组合,返回一个Repository组合类
private RepositoryComposition getRepositoryComposition(RepositoryMetadata metadata, RepositoryFragments fragments) {
RepositoryComposition composition = getRepositoryComposition(metadata) {
// 创建一个空组合
RepositoryComposition composition = RepositoryComposition.empty();
// 是响应式的Repository
if (metadata.isReactiveRepository()) {
return composition.withMethodLookup(MethodLookups.forReactiveTypes(metadata)).withArgumentConverter(REACTIVE_ARGS_CONVERTER);
}
// 创建Repository类型的方法查找器
MethodLookup lookup = MethodLookups.forRepositoryTypes(metadata) {
MethodPredicate direct = direct() {
// 获取一个匹配器,将可执行的方法与给定的候选方法比较,参数个数,参数类型,方法名称进行对比
MethodPredicate direct = (invoked, candidate) -> candidate.getName().equals(invoked.getName())
&& candidate.getParameterCount() == invoked.getParameterCount()
&& Arrays.equals(candidate.getParameterTypes(), invoked.getParameterTypes());
// 返回一个Lookup
return () -> Collections.singletonList(direct);
}
// 将该查找器与给定查找器的匹配器进行合并
return direct.and(new RepositoryAwareMethodLookup(repositoryMetadata) {
}) {
// getLookups:List<MethodPredicate>,获取所有的匹配器
// 返回一个新的Lookup
return () -> Stream.concat(getLookups().stream(), other.getLookups().stream()).collect(Collectors.toList());
}
}
// 根据方法查找器,已经原有的碎片接口实现类集合创建一个新的组合
return composition.withMethodLookup(lookup) {
return new RepositoryComposition(fragments, methodLookup, argumentConverter);
}
}
// 获取queryDsl碎片接口实现集合
RepositoryFragments repositoryAspects = getRepositoryFragments(metadata);
// 将原有的碎片接口实现类集合与queryDsl碎片接口实现进行组合
return composition.append(fragments).append(repositoryAspects);
}
// 获取queryDsl碎片接口实现集合
protected RepositoryComposition.RepositoryFragments getRepositoryFragments(RepositoryMetadata metadata) {
// 创建空的碎片集合
RepositoryComposition.RepositoryFragments fragments = RepositoryComposition.RepositoryFragments.empty();
// 是否存在dslRepository查询
boolean isQueryDslRepository = QUERY_DSL_PRESENT && QuerydslPredicateExecutor.class.isAssignableFrom(metadata.getRepositoryInterface());
// 如果存在dsl查询
if (isQueryDslRepository) {
// dsl与响应式不兼容
if (metadata.isReactiveRepository()) {
throw new InvalidDataAccessApiUsageException("Cannot combine Querydsl and reactive repository support in a single interface");
}
// 获取jpa的实体信息
JpaEntityInformation<?, Serializable> entityInformation = getEntityInformation(metadata.getDomainType());
// 获取CRUD方法的元数据信息
CrudMethodMetadata crudMethodMetadata = crudMethodMetadataPostProcessor.getCrudMethodMetadata() {
// 获取一个CrudMethodMetadata代理对象
ProxyFactory factory = new ProxyFactory();
factory.addInterface(CrudMethodMetadata.class);
// 在crudMethodMetadataPostProcessor中,会添加一个拦截器,CrudMethodMetadataPopulatingMethodInterceptor
// 会将当前MethodInvocation保存
factory.setTargetSource(new ThreadBoundTargetSource());
return (CrudMethodMetadata) factory.getProxy(this.classLoader);
}
// 获取queryDsl的接口碎片实现
Object querydslFragment = getTargetRepositoryViaReflection(QuerydslJpaPredicateExecutor.class, entityInformation, entityManager, entityPathResolver, crudMethodMetadata);
// 拼接dsl碎片接口实现
fragments = fragments.append(RepositoryFragment.implemented(querydslFragment));
}
// 返回接口碎片实现集合
return fragments;
}
// 获取queryDsl的接口碎片实现
protected final <R> R getTargetRepositoryViaReflection(Class<?> baseClass, Object... constructorArguments) {
// 查找基类QuerydslJpaPredicateExecutor的构造方法
Optional<Constructor<?>> constructor = ReflectionUtils.findConstructor(baseClass, constructorArguments);
// 实例化QuerydslJpaPredicateExecutor实现类
return constructor.map(it -> (R) BeanUtils.instantiateClass(it, constructorArguments))
.orElseThrow(() -> new IllegalStateException(String.format("No suitable constructor found on %s to match the given arguments: %s. Make sure you implement a constructor taking these", baseClass, Arrays.stream(constructorArguments).map(Object::getClass).collect(Collectors.toList()))));
}
// 获取JPA实体信息
public <T, ID> JpaEntityInformation<T, ID> getEntityInformation(Class<T> domainClass) {
return (JpaEntityInformation<T, ID>) JpaEntityInformationSupport.getEntityInformation(domainClass, entityManager)
{
// 它提供对持久化单元中实体元模型的访问
Metamodel metamodel = entityManager.getMetamodel();
// 如果实体类是Persistable类型,返回JpaPersistableEntityInformation实体信息
if (Persistable.class.isAssignableFrom(domainClass)) {
return new JpaPersistableEntityInformation(domainClass, metamodel);
}
// 否则返回Jpa元模型实体信息
return new JpaMetamodelEntityInformation(domainClass, metamodel);
}
}
// 校验接口的自定义方法是否给定了实现
private void validate(RepositoryInformation repositoryInformation, RepositoryComposition composition) {
/**
* {@link DefaultRepositoryInformation#hasCustomMethod()}
*/
// 如果存在自定义的方法
if (repositoryInformation.hasCustomMethod()) {
// 但是没有找的对应自定义方法的实现,抛出异常
// 碎片接口对应的实现类为空,也就是没有实现类
if (composition.isEmpty()) {
throw new IllegalArgumentException(String.format("You have custom methods in %s but not provided a custom implementation!", repositoryInformation.getRepositoryInterface()));
}
// 存在是实现类,校验实现类
composition.validateImplementation();
}
// 空实现,校验Repository接口信息
validate(repositoryInformation);
}
}
// 默认的Repository接口信息
class DefaultRepositoryInformation {
// 方法缓存,调用的方法->实际执行的方法
private final Map<Method, Method> methodCache = new ConcurrentHashMap<>();
// Repository接口的元数据
private final RepositoryMetadata metadata;
// 接口的实现类基类
private final Class<?> repositoryBaseClass;
// 所有碎片接口实现类组合
private final RepositoryComposition composition;
// Repository实现类基类的碎片组合
private final RepositoryComposition baseComposition;
public DefaultRepositoryInformation(RepositoryMetadata metadata, Class<?> repositoryBaseClass, RepositoryComposition composition) {
// 接口的元数据信息
this.metadata = metadata;
// 接口的实现类基类
this.repositoryBaseClass = repositoryBaseClass;
// 所有碎片接口实现类组合
this.composition = composition;
// Repository实现类基类的碎片组合,内部只包含基类的方法
this.baseComposition = RepositoryComposition.of(RepositoryFragment.structural(repositoryBaseClass)).withArgumentConverter(composition.getArgumentConverter()).withMethodLookup(composition.getMethodLookup());
}
public Class<?> getDomainType() {
return metadata.getDomainType();
}
public Class<?> getIdType() {
return metadata.getIdType();
}
public Class<?> getRepositoryBaseClass() {
return this.repositoryBaseClass;
}
// 获取目标类方法
public Method getTargetClassMethod(Method method) {
// 是否存在缓存
if (methodCache.containsKey(method)) {
return methodCache.get(method);
}
// 从所有的碎片组合中找实现方法,如果没有找到,直接返回调用的方法
Method result = composition.findMethod(method)
.orElse(method);
// 如果找到了实现方法
if (!result.equals(method)) {
// 缓存并返回实现方法
return cacheAndReturn(method, result);
}
// 没有找到方法,从基类的碎片组合中中找实现方法并返回,内部只包含基类的方法
result = baseComposition.findMethod(method).orElse(method);
return cacheAndReturn(method, result);
}
// 缓存对应的实现方法并返回
private Method cacheAndReturn(Method key, Method value) {
// 如果找到了实现方法
if (value != null) {
// 设置方法可访问
makeAccessible(value);
}
// 缓存方法
methodCache.put(key, value);
// 返回
return value;
}
// 获取查询的方法
public Streamable<Method> getQueryMethods() {
Set<Method> result = new HashSet<>();
// 获取Repository接口的所有方法
for (Method method : getRepositoryInterface().getMethods()) {
// 获取最终执行的方法,可能是接口的,也可能是实现类的(如果调用的实现类中存在该方法)
method = ClassUtils.getMostSpecificMethod(method, getRepositoryInterface());
// 是否是查询方法
if (isQueryMethodCandidate(method)) {
// 如果是查询方法,保存
result.add(method);
}
}
return Streamable.of(Collections.unmodifiableSet(result));
}
// 是否是查询方法
private boolean isQueryMethodCandidate(Method method) {
// 不是桥接方法,不是接口的默认方法,不是静态方法的前提下
// 如果方法上存在@QueryAnnotation注解表示就是查询方法
// 或者该方法不是自定义方法并且不是基类中的方法
return !method.isBridge()
&& !method.isDefault()
&& !Modifier.isStatic(method.getModifiers())
&& (isQueryAnnotationPresentOn(method) || !isCustomMethod(method) && !isBaseClassMethod(method));
}
// 是否是自定义方法
public boolean isCustomMethod(Method method) {
return composition.getMethod(method) != null;
}
// 基类中是否存在该方法
public boolean isBaseClassMethod(Method method) {
return baseComposition.getMethod(method) != null;
}
// 是否存在自定义方法
public boolean hasCustomMethod() {
// 获取Repository接口
Class<?> repositoryInterface = getRepositoryInterface();
// 接口是不是Repository类
if (isGenericRepositoryInterface(repositoryInterface)) {
return false;
}
// 找到接口中所有的方法
for (Method method : repositoryInterface.getMethods()) {
// 是自定义方法,并且不是基类中的方法
if (isCustomMethod(method) && !isBaseClassMethod(method)) {
return true;
}
}
return false;
}
}
// Repository方法的查找器
class RepositoryAwareMethodLookup {
// Repository接口的元信息
public RepositoryAwareMethodLookup(RepositoryMetadata repositoryMetadata) {
// 查找到实体的类型
this.entityType = ResolvableType.forClass(repositoryMetadata.getDomainType());
// 查找到ID的类型
this.idType = ResolvableType.forClass(repositoryMetadata.getIdType());
// 获取到Repository接口的类型
this.repositoryInterface = repositoryMetadata.getRepositoryInterface();
}
// 返回符合条件方法的匹配器
public List<MethodPredicate> getLookups() {
// 候选的方法名称需要与执行方法的名称一样,参数个数一样,参数类型,泛型需要一样才能匹配成功
MethodPredicate detailedComparison = (invoked, candidate) -> Optional.of(candidate)
.filter(baseClassMethod -> baseClassMethod.getName().equals(invoked.getName()))
.filter(baseClassMethod -> baseClassMethod.getParameterCount() == invoked.getParameterCount())
.filter(baseClassMethod -> parametersMatch(invoked.getMethod(), baseClassMethod))
.isPresent();
// 返回匹配器
return Collections.singletonList(detailedComparison);
}
}
// 一个Repository对应所有碎片实现的组合
class RepositoryComposition {
// 参数转换器,其实就是原样返回
private static final BiFunction<Method, Object[], Object[]> PASSTHRU_ARG_CONVERTER = (methodParameter, o) -> o;
// 空组合对象
private static final RepositoryComposition EMPTY = new RepositoryComposition(RepositoryFragments.empty(), MethodLookups.direct(), PASSTHRU_ARG_CONVERTER);
// 方法缓存,接口->实现类方法的缓存
private final Map<Method, Method> methodCache = new ConcurrentReferenceHashMap<>();
// 所有Repository接口的碎片接口实现
private final @Getter
RepositoryFragments fragments;
// 查找可用方法的类
private final @Getter
MethodLookup methodLookup;
// 参数类型转换器
private final @Getter
BiFunction<Method, Object[], Object[]> argumentConverter;
// 执行接口实现的目标方法
public Object invoke(Method method, Object... args) throws Throwable {
// 根据调用的方法从缓存中找到对应的实现方法
Method methodToCall = getMethod(method);
// 如果没有找到实现方法,抛出异常
if (methodToCall == null) {
throw new IllegalArgumentException(String.format("No fragment found for method %s", method));
}
// 设置可访问
ReflectionUtils.makeAccessible(methodToCall);
/**
* 直接接口方法
* {@link RepositoryFragments#invoke(Method, Object[])}
*/
return fragments.invoke(methodToCall, argumentConverter.apply(methodToCall, args));
}
// 根据调用的方法从缓存中找到对应的实现方法
public Method getMethod(Method method) {
/**
* {@link RepositoryFragments#findMethod(InvokedMethod, MethodLookup, Supplier)}
*/
return methodCache.computeIfAbsent(method, key -> RepositoryFragments.findMethod(InvokedMethod.of(key), methodLookup, fragments::methods));
}
// 校验实现类,将所有的碎片接口遍历,如果碎片中没有保存实现类信息,就是没有找到实现类,抛出异常
public void validateImplementation() {
fragments.stream().forEach(it -> it.getImplementation()
.orElseThrow(() -> new IllegalStateException(String.format("Fragment %s has no implementation.", ClassUtils.getQualifiedName(it.getSignatureContributor())))));
}
}
// 封装了某一个碎片接口对应的实现类信息
interface RepositoryFragment<I> {
public static <T> RepositoryFragment<T> implemented(T implementation) {
return new ImplementedRepositoryFragment<T>(Optional.empty(), implementation);
}
public static <T> RepositoryFragment<T> implemented(Class<T> interfaceClass, T implementation) {
return new ImplementedRepositoryFragment<>(Optional.of(interfaceClass), implementation);
}
public static <T> RepositoryFragment<T> structural(Class<T> interfaceOrImplementation) {
return new StructuralRepositoryFragment<>(interfaceOrImplementation);
}
// Repository实现类碎片
static class ImplementedRepositoryFragment<T> implements RepositoryFragment<T> {
// Repository接口
private final Optional<Class<T>> interfaceClass;
// 接口对应的实现类
private final T implementation;
// 接口对应的实现类
private final Optional<T> optionalImplementation;
public ImplementedRepositoryFragment(Optional<Class<T>> interfaceClass, T implementation) {
// Repository接口
this.interfaceClass = interfaceClass;
// 接口对应的实现类
this.implementation = implementation;
// 接口对应的实现类
this.optionalImplementation = Optional.of(implementation);
}
// 设置接口的实现类
public RepositoryFragment<T> withImplementation(T implementation) {
return new ImplementedRepositoryFragment<>(interfaceClass, implementation);
}
}
// Repository实现类碎片
static class StructuralRepositoryFragment<T> implements RepositoryFragment<T> {
// 接口或者实现类
private final Class<T> interfaceOrImplementation;
// 设置接口的实现类
public RepositoryFragment<T> withImplementation(T implementation) {
return new ImplementedRepositoryFragment<>(Optional.of(interfaceOrImplementation), implementation);
}
}
}
// 封装了所有Repository碎片的实现类信息
class RepositoryFragments implements Streamable<RepositoryFragment<?>> {
// 空的Repository实现类碎片集合
static final RepositoryFragments EMPTY = new RepositoryFragments(Collections.emptyList());
// 方法缓存,每一个方法都应哪一个碎片(实现类的方法)
private final Map<Method, RepositoryFragment<?>> fragmentCache = new ConcurrentReferenceHashMap<>();
// 该Repository接口的所有碎片接口的实现类集合
private final List<RepositoryFragment<?>> fragments;
// 执行目标方法对应的实现类方法
public Object invoke(Method method, Object[] args) throws Throwable {
// 从获取中方法对应的接口碎片实现类
RepositoryFragment<?> fragment = fragmentCache.computeIfAbsent(method, this::findImplementationFragment);
// 获取实现类
Optional<?> optional = fragment.getImplementation();
// 如果不存在实现类,表示该方法没用提供实现方法,抛出异常
if (!optional.isPresent()) {
throw new IllegalArgumentException(String.format("No implementation found for method %s", method));
}
// 通过实现类执行该方法
return method.invoke(optional.get(), args);
}
// 找调用方法的实现类方法
private RepositoryFragment<?> findImplementationFragment(Method key) {
// 先过滤当前Repository碎片中是否包含此方法
return stream().filter(it -> it.hasMethod(key))
// 如果存在,则获取实现类
.filter(it -> it.getImplementation().isPresent()) //
.findFirst()
.orElseThrow(() -> new IllegalArgumentException(String.format("No fragment found for method %s", key)));
}
// 根据调用的方法找实现方法
private static Method findMethod(InvokedMethod invokedMethod, MethodLookup lookup, Supplier<Stream<Method>> methodStreamSupplier) {
// 获取方法匹配器
for (MethodPredicate methodPredicate : lookup.getLookups()) {
// 获取实现类中符合条件的方法
Optional<Method> resolvedMethod = methodStreamSupplier.get()
// 条件匹配
.filter(it -> methodPredicate.test(invokedMethod, it)) //
.findFirst();
// 如果找到了实现方法,返回
if (resolvedMethod.isPresent()) {
return resolvedMethod.get();
}
}
// 否则返回null
return null;
}
}
// 用于生成碎片接口处理器RepositoryFragment的FactoryBean
// 碎片接口是Repository接口中所有继承的接口,并排除标注了NoRepositoryBean注解的Bean
// 也就是除了标记了NoRepositoryBean注解的Bean,Repository接口中所有继承的接口都属于碎片接口
class RepositoryFragmentsFactoryBean implements FactoryBean<RepositoryFragments> {
// 该Repository接口对应的所有碎片接口实现对应的beanName
private final List<String> fragmentBeanNames;
// 该Repository接口对应的所有碎片实现类Bean的集合封装
private RepositoryFragments repositoryFragments = RepositoryFragments.empty();
public void afterPropertiesSet() {
// 保存所有碎片接口处理器
List<RepositoryFragment<?>> fragments =
// 获取在构造方法中传入的所有的碎片接口处理器的名称
fragmentBeanNames.stream()
// 根据名称初始化该接口碎片处理器的Bean对象
.map(it -> beanFactory.getBean(it, RepositoryFragment.class))
.collect(Collectors.toList());
// 封装成RepositoryFragments对象
this.repositoryFragments = RepositoryFragments.from(fragments) {
return new RepositoryFragments(new ArrayList<>(fragments));
}
}
// 返回一个封装了所有RepositoryFragment碎片接口的类
public RepositoryFragments getObject() throws Exception {
return this.repositoryFragments;
}
}
// 命名查询器
class PropertiesBasedNamedQueries implements NamedQueries {
// 对应这命名查询的配置文件属性
// 它是作为一个Bean传入的,是通过PropertiesFactoryBean生成的Bean
// User.findAllAdultUsers = SELECT u FROM User u WHERE u.id > 1
private final @NonNull
Properties properties;
// 命名查询配置文件jpa-named-queries.properties中是否存在该方法
// User.findAllAdultUsers=SELECT u FROM User u WHERE u.id > 1
public boolean hasQuery(String queryName) {
return properties.containsKey(queryName);
}
// 查找命名查询的sql
// User.findAllAdultUsers=SELECT u FROM User u WHERE u.id > 1
public String getQuery(String queryName) {
// 获取到命名查询的sql
String query = properties.getProperty(queryName);
// 如果没有找到对应的命名查询,抛出异常
if (query == null) {
throw new IllegalArgumentException(String.format(NO_QUERY_FOUND, queryName));
}
// 返回命名查询对应的sql
return query;
}
}
// 创建Properties的Bean实例
class PropertiesFactoryBean extends PropertiesLoaderSupport implements FactoryBean<Properties> {
// 需要加载的资源文件路径
private Resource[] locations;
// 本身存在的本地变量数据
protected Properties[] localProperties;
// Properties单实例
private Properties singletonInstance;
if(this.singleton)
{
// 所以这个配置就是FactoryBean本身存在的属性变量,与当前需要加载的路径对应的配置进行合并的属性
this.singletonInstance = createProperties();
}
// 创建Properties对象
protected Properties createProperties() throws IOException {
return mergeProperties();
}
// 合并原有的Properties属性
protected Properties mergeProperties() throws IOException {
Properties result = new Properties();
// 是否允许覆盖本地的配置,默认为false,就是一个执行时机的问题
// 如果允许覆盖,那么需要先加载当前配置文件,在进行本地合并覆盖
// 如果不允许覆盖,那么先保存所有的本地变量,然后在记载最新的属性
if (this.localOverride) {
// 加载属性
loadProperties(result);
}
// 如果存在本地配置信息,进行覆盖
if (this.localProperties != null) {
// 遍历所有的本地配置
for (Properties localProp : this.localProperties) {
// 将加载的配置与本地的配置进行合并,重复的进行覆盖
CollectionUtils.mergePropertiesIntoMap(localProp, result);
}
}
// 是否覆盖本地的配置,默认为false
if (!this.localOverride) {
loadProperties(result);
}
return result;
}
// 加载属性
protected void loadProperties(Properties props) throws IOException {
// 是否设置需要加载的属性文件路径
if (this.locations != null) {
// 如果存在
for (Resource location : this.locations) {
// 加载属性到props中
PropertiesLoaderUtils.fillProperties(props, new EncodedResource(location, this.fileEncoding), this.propertiesPersister)
{
// 获取流数据
InputStream stream = location.getInputStream();
// 加载对Properties中
props.load(reader);
}
}
}
}
}
// 查询方法执行拦截器,包含命名查询,普通查询,以及按照jpa命名规范都在这里完成的
class QueryExecutorMethodInterceptor {
public QueryExecutorMethodInterceptor(RepositoryInformation repositoryInformation, ProjectionFactory projectionFactory) {
// 结果查询的处理器,使用类型转换器对返回结果进行转换
this.resultHandler = new QueryExecutionResultHandler(CONVERSION_SERVICE);
// 创建一个查询方法的策略
Optional<QueryLookupStrategy> lookupStrategy = getQueryLookupStrategy(queryLookupStrategyKey, RepositoryFactorySupport.this.evaluationContextProvider);
// 如果不存在查找策略,但是存在查询方法,抛出异常
if (!lookupStrategy.isPresent() && repositoryInformation.hasQueryMethods()) {
throw new IllegalStateException("You have defined query method in the repository but");
}
// 使用查找策略查找查询方法,将方法对应映射成RepositoryQuery可执行的query对象
this.queries = lookupStrategy.map(it -> mapMethodsToQuery(repositoryInformation, it, projectionFactory)).orElse(Collections.emptyMap());
}
// 根据标注@EnableJpaRepositories的queryLookupStrategy方法查询方法查找策略
// 根据不同的策略处理目标方法
protected Optional<QueryLookupStrategy> getQueryLookupStrategy(@Nullable Key key, QueryMethodEvaluationContextProvider evaluationContextProvider) {
return Optional.of(JpaQueryLookupStrategy.create(entityManager, key, extractor, evaluationContextProvider, escapeCharacter)
{
// 默认策略为,如果方法不存在,则创建查询
switch (key != null ? key : Key.CREATE_IF_NOT_FOUND) {
// 直接创建查询
case CREATE:
return new CreateQueryLookupStrategy(em, extractor, escape);
// 使用@Query注解创建查询
case USE_DECLARED_QUERY:
return new DeclaredQueryLookupStrategy(em, extractor, evaluationContextProvider);
// 上面两者的兼容版本,先使用@Query注解查找,如果不存在,在使用方法名创建
case CREATE_IF_NOT_FOUND:
return new CreateIfNotFoundQueryLookupStrategy(em, extractor,
new CreateQueryLookupStrategy(em, extractor, escape),
new DeclaredQueryLookupStrategy(em, extractor, evaluationContextProvider));
default:
throw new IllegalArgumentException(String.format("Unsupported query lookup strategy %s!", key));
}
});
}
// 将方法映射成RepositoryQuery对象
private Map<Method, RepositoryQuery> mapMethodsToQuery(RepositoryInformation repositoryInformation, QueryLookupStrategy lookupStrategy, ProjectionFactory projectionFactory) {
/**
* {@link DefaultRepositoryInformation#getQueryMethods()}
*/
// 获取找的的查询方法
return repositoryInformation.getQueryMethods().stream()
// 解析查询方法中的查询注解,参数,查询等信息
// 封装成可执行的Query对象
.map(method -> lookupQuery(method, repositoryInformation, lookupStrategy, projectionFactory)) //
// 执行监听器
.peek(pair -> invokeListeners(pair.getSecond())) //
.collect(Pair.toMap());
}
// 查找查询方法的信息
private Pair<Method, RepositoryQuery> lookupQuery(Method method, RepositoryInformation information, QueryLookupStrategy strategy, ProjectionFactory projectionFactory) {
/**
* {@link JpaQueryLookupStrategy}
*/
// 使用查询策略,解析查询方法,将查询的信息封装为可执行的Query方法
return Pair.of(method, strategy.resolveQuery(method, information, projectionFactory, namedQueries));
}
// 查询查询创建监听器
private void invokeListeners(RepositoryQuery query) {
// 在构造方法中
// QueryCollectingQueryCreationListener collectingListener = new QueryCollectingQueryCreationListener();
// this.queryPostProcessors.add(collectingListener);
class QueryCollectingQueryCreationListener implements QueryCreationListener<RepositoryQuery> {
private final List<QueryMethod> queryMethods = new ArrayList<>();
// 创建的回调方法
public void onCreation(RepositoryQuery query) {
// 保存query中可执行的方法
this.queryMethods.add(query.getQueryMethod());
}
}
// 执行QueryCollectingQueryCreationListener监听器,在创建了方法对应的Query对象之后执行对应回调
for (QueryCreationListener listener : queryPostProcessors) {
// 解析该类的泛型信息,也就是RepositoryQuery
ResolvableType typeArgument = ResolvableType.forClass(QueryCreationListener.class, listener.getClass()).getGeneric(0);
// 如果解析到了泛型类
if (typeArgument != null && typeArgument.isAssignableFrom(ResolvableType.forClass(query.getClass()))) {
// 回调监听器的创建方法
/**
* {@link QueryCollectingQueryCreationListener#onCreation(RepositoryQuery)}
*/
listener.onCreation(query);
}
}
}
}
// JPA查询方法的查找策略
public class JpaQueryLookupStrategy {
// 抽象的查询策略
private abstract static class AbstractQueryLookupStrategy implements QueryLookupStrategy {
// 实体管理器
private final EntityManager em;
// 查询提取器,不同的厂商实现提取方式不一样
private final QueryExtractor provider;
public AbstractQueryLookupStrategy(EntityManager em, QueryExtractor extractor) {
this.em = em;
this.provider = extractor;
}
// 解析查询方法
public final RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, ProjectionFactory factory, NamedQueries namedQueries) {
// 解析查询方法,将参数封装成JpaQueryMethod
return resolveQuery(new JpaQueryMethod(method, metadata, factory, provider), em, namedQueries);
}
protected abstract RepositoryQuery resolveQuery(JpaQueryMethod method, EntityManager em, NamedQueries namedQueries);
}
// 查找@Query注解的策略
private static class DeclaredQueryLookupStrategy extends AbstractQueryLookupStrategy {
// 负责提供查询方法的上下文信息，以便框架能够正确地解析和执行这些查询方法
private final QueryMethodEvaluationContextProvider evaluationContextProvider;
public DeclaredQueryLookupStrategy(EntityManager em, QueryExtractor extractor, QueryMethodEvaluationContextProvider evaluationContextProvider) {
super(em, extractor);
this.evaluationContextProvider = evaluationContextProvider;
}
// 解析查询语句
protected RepositoryQuery resolveQuery(JpaQueryMethod method, EntityManager em, NamedQueries namedQueries) {
// 解析Query注解,返回可执行的Query类
RepositoryQuery query = JpaQueryFactory.INSTANCE.fromQueryAnnotation(method, em, evaluationContextProvider)
{
// 通过Query中的SQL进行解析
return fromMethodWithQueryString(method, em, method.getAnnotatedQuery() {
// 查询Query注解的value值SQL
return getMergedOrDefaultAnnotationValue(attribute, Query.class, type);
},evaluationContextProvider){
if (queryString == null) {
return null;
}
// 如果是SQL查询,创建一个SQL的执行器
return method.isNativeQuery() ? new NativeJpaQuery(method, em, queryString, evaluationContextProvider, PARSER)
// 否则,使用默认的JPA查询器
: new SimpleJpaQuery(method, em, queryString, evaluationContextProvider, PARSER);
}
}
// 如果存在Query注解,直接返回
if (null != query) {
return query;
}
// 找存储过程@Procedure注解
query = JpaQueryFactory.INSTANCE.fromProcedureAnnotation(method, em) {
// 如果不存在@Procedure注解,直接返回
if (!method.isProcedureQuery()) {
return null;
}
// 返回存储过程的查询类
return new StoredProcedureJpaQuery(method, em);
}
// 如果存在@Procedure注解,直接返回
if (null != query) {
return query;
}
// 其他情况,@Query中不存在SQL语句
String name = method.getNamedQueryName() {
// 先获取Query注解的名称
String annotatedName = getAnnotationValue("name", String.class);
// 没有写name属性,返回类名.方法名
return StringUtils.hasText(annotatedName) ? annotatedName : super.getNamedQueryName() {
return String.format("%s.%s", getDomainClass().getSimpleName(), method.getName());
}
}
// 如果命名查询中已经定义了该方法
if (namedQueries.hasQuery(name)) {
// 获取对应的查询语句
String queryString = namedQueries.getQuery(name);
// 上面有解释,又到了@Query的环节,上面找的是@Query的SQL,现在找的是@Query的name,然后在通过name到命名查询(jpa-named-queries.properties配置文件)中找到对应的SQL
return JpaQueryFactory.INSTANCE.fromMethodWithQueryString(method, em, queryString, evaluationContextProvider);
}
// 如果命名查询中也不存在该方法
query = NamedQuery.lookupFrom(method, em) {
// 获取到查询名称,上面也有解释
// 先获取Query注解的名称
// 没有写name属性,返回类名.方法名
final String queryName = method.getNamedQueryName();
// 是否存在命名查询
if (!hasNamedQuery(em, queryName) {
// 新建一个实体管理器
EntityManager lookupEm = em.getEntityManagerFactory().createEntityManager();
try {
// 尝试用EntityManager创建命名查询,只有在实体类中定义了命名查询才能通过,否则抛出异常
// @NamedQuery(name = "User.findUserByName", query = "select u FROM User u where u.name ='luck'")
// public class User {}
// 提示: 这种存在一种特殊情况,如果命名查询的名称正好符合默认的规则"类名.方法名"
// 那么,没有加@Query和加了@Query但没有设置name的作用是一样的
lookupEm.createNamedQuery(queryName);
return true;
} catch (IllegalArgumentException e) {
// 没有定义该命名查询
return false;
} finally {
// 关闭连接
lookupEm.close();
}
}){
// 返回空,@Query注解的情况处理不了这个方法
return null;
}
// 如果在实体中定义了该命名查询,返回NamedQuery
RepositoryQuery query = new NamedQuery(method, em);
return query;
}
// 如果处理@Query情况成功,直接返回对应的可执行的Query对象
if (null != query) {
return query;
}
// 返回null,表示无法处理Query注解命名查询的逻辑,抛出异常
throw new IllegalStateException(String.format("Did neither find a NamedQuery nor an annotated query for method %s!", method));
}
}
// 根据方法命按照命名规则创建查询
private static class CreateQueryLookupStrategy extends AbstractQueryLookupStrategy {
// 负责提供查询方法的上下文信息，以便框架能够正确地解析和执行这些查询方法
private final PersistenceProvider persistenceProvider;
// 转义字符处理器
private final EscapeCharacter escape;
public CreateQueryLookupStrategy(EntityManager em, QueryExtractor extractor, EscapeCharacter escape) {
super(em, extractor);
this.persistenceProvider = PersistenceProvider.fromEntityManager(em);
this.escape = escape;
}
// 创建一个Query对象,也就是按照SpringDataJpa的命名规则,解析方法名为树,提取字段和关键字
protected RepositoryQuery resolveQuery(JpaQueryMethod method, EntityManager em, NamedQueries namedQueries) {
return new PartTreeJpaQuery(method, em, persistenceProvider, escape) {
}
}
}
// 上面两种的兼容版本
private static class CreateIfNotFoundQueryLookupStrategy extends AbstractQueryLookupStrategy {
// 处理@Query注解的策略
private final DeclaredQueryLookupStrategy lookupStrategy;
// 直接创建名称树查询的策略
private final CreateQueryLookupStrategy createStrategy;
public CreateIfNotFoundQueryLookupStrategy(EntityManager em, QueryExtractor extractor, CreateQueryLookupStrategy createStrategy, DeclaredQueryLookupStrategy lookupStrategy) {
super(em, extractor);
this.createStrategy = createStrategy;
this.lookupStrategy = lookupStrategy;
}
// 解析查询
protected RepositoryQuery resolveQuery(JpaQueryMethod method, EntityManager em, NamedQueries namedQueries) {
// 先处理@Query,如果处理不成功则创建
try {
return lookupStrategy.resolveQuery(method, em, namedQueries);
} catch (IllegalStateException e) {
return createStrategy.resolveQuery(method, em, namedQueries);
}
}
}
}
// JPA命名规范解析树查询
class PartTreeJpaQuery {
PartTreeJpaQuery(JpaQueryMethod method, EntityManager em, PersistenceProvider persistenceProvider, EscapeCharacter escape) {
super(method, em);
this.em = em;
this.escape = escape;
// 实体类型
Class<?> domainClass = method.getEntityInformation().getJavaType();
// 方法参数
this.parameters = method.getParameters();
// 可能是用于检查查询方法是否包含动态投影
// 动态投影是指在查询中根据条件动态选择要返回的字段或属性
// 或者特殊的参数分页或者排序
boolean recreationRequired = parameters.hasDynamicProjection() || parameters.potentiallySortsDynamically();
try {
// 构建一个方法树
this.tree = new PartTree(method.getName(), domainClass) {
+
String KEYWORD_TEMPLATE = "(%s)(?=(\\p{Lu}|\\P{InBASIC_LATIN}))";
+
String QUERY_PATTERN = "find|read|get|query|stream";
+
String COUNT_PATTERN = "count";
+
String EXISTS_PATTERN = "exists";
+
String DELETE_PATTERN = "delete|remove";
+
Pattern PREFIX_TEMPLATE = Pattern.compile("^(" + QUERY_PATTERN + "|" + COUNT_PATTERN + "|" + EXISTS_PATTERN + "|" + DELETE_PATTERN + ")((\\p{Lu}.*?))??By");
// 主题,就是需要执行的最终操作,是查询,删除...操作
private final Subject subject;
// 运算到主题中的条件
private final Predicate predicate;
// 匹配上面的关键字
Matcher matcher = PREFIX_TEMPLATE.matcher(source);
// 如果方法名没有匹配到
if(!matcher.find())
{
// 指定空主题
this.subject = new Subject(Optional.empty());
// 方法名作为条件
this.predicate = new Predicate(source, domainClass);
}
// 方法名匹配到了关键字
else
{
// 使用匹配到的第一处关键字作为主题
this.subject = new Subject(Optional.of(matcher.group(0))) {
// 主题为去查
this.distinct =subject.map(it ->it.contains(DISTINCT)).
orElse(false);
// 主题为查询数量
this.count =
matches(subject, COUNT_BY_TEMPLATE);
// 是否存在
this.exists =
matches(subject, EXISTS_BY_TEMPLATE);
// 删除
this.delete =
matches(subject, DELETE_BY_TEMPLATE);
// 分页结果
this.maxResults =
returnMaxResultsIfFirstKSubjectOrNull(subject);
}
// 截取条件
this.predicate = new Predicate(source.substring(matcher.group().length()), domainClass) {
// 截取排序字段条件和普通字段
// 例如: AgeAndNameOrderByAgeDesc -> AgeAndName AgeDesc
String[] parts = split(detectAndSetAllIgnoreCase(predicate), ORDER_BY);
// 先通过OR条件进行切割,再将两边的条件使用And进行连接,最终返回这些字段的节点树
this.nodes =Arrays.stream(
split(parts[0], "Or"))
.
filter(StringUtils::hasText)
// 再将两边的条件使用And进行连接
.
map(part ->new
OrPart(part, domainClass, alwaysIgnoreCase) {
String[] split = split(source, "And");
// 保存And的字段
this.children = Arrays.stream(split)
.filter(StringUtils::hasText)
.map(part -> new Part(part, domainClass, alwaysIgnoreCase))//
.collect(Collectors.toList());
})
.
collect(Collectors.toList());
}
}
}
// 参数个数和解析到的字段条件进行校验
validate(tree, parameters, method.toString());
// 创建一个count查询,主要是处理分页
this.countQuery = new CountQueryPreparer(persistenceProvider, recreationRequired);
// 如果没有进行分页处理,创建一个QueryPreparer
// 内部是创建一个CriteriaQuery查询,并设置查询参数
this.query = tree.isCountProjection() ? countQuery : new QueryPreparer(persistenceProvider, recreationRequired);
} catch (Exception o_O) {
throw new IllegalArgumentException(String.format("Failed to create query for method %s! %s", method, o_O.getMessage()), o_O);
}
}
}
// 共享的EntityManger创建器
class SharedEntityManagerCreator {
private static final Map<Class<?>, Class<?>[]> cachedQueryInterfaces = new ConcurrentReferenceHashMap<>(4);
// 必须要事务的方法
private static final Set<String> transactionRequiringMethods = new HashSet<>(8);
// 查询终止的方法
private static final Set<String> queryTerminatingMethods = new HashSet<>(8);
static {
transactionRequiringMethods.add("joinTransaction");
transactionRequiringMethods.add("flush");
transactionRequiringMethods.add("persist");
transactionRequiringMethods.add("merge");
transactionRequiringMethods.add("remove");
transactionRequiringMethods.add("refresh");
queryTerminatingMethods.add("execute");
queryTerminatingMethods.add("executeUpdate");
queryTerminatingMethods.add("getSingleResult");
queryTerminatingMethods.add("getResultStream");
queryTerminatingMethods.add("getResultList");
queryTerminatingMethods.add("list");
}
/**
* 创建EntityManager的代理对象
*/
public static EntityManager createSharedEntityManager(EntityManagerFactory emf, @Nullable Map<?, ?> properties, boolean synchronizedWithTransaction) {
Class<?> emIfc = (emf instanceof EntityManagerFactoryInfo ? ((EntityManagerFactoryInfo) emf).getEntityManagerInterface() : EntityManager.class);
return createSharedEntityManager(emf, properties, synchronizedWithTransaction, (emIfc == null ? NO_ENTITY_MANAGER_INTERFACES : new Class<?>[]{emIfc}));
}
/**
* 创建EntityManager
*
* @param EntityManagerFactory工厂
* @param properties jpa提供给供应商优化的属性
* @param synchronizedWithTransaction 是否开启事务同步
* @param entityManagerInterfaces 给EntityManager创建代理需要实现的接口
* @return EntityManager代理对象
*/
public static EntityManager createSharedEntityManager(EntityManagerFactory emf, @Nullable Map<?, ?> properties, boolean synchronizedWithTransaction, Class<?>... entityManagerInterfaces) {
// 获取EntityManagerFactory类加载器
ClassLoader cl = null;
// 为什么这个判断成立?
// 因为在创建当前Bean的时候,设置的builder.addConstructorArgReference(getEntityManagerBeanRef(config))
// config.getAttribute("entityManagerFactoryRef");
// 此时EntityManagerFactory是一个代理对象,这个代理对象实现了EntityManagerFactory
// 而他真实的对象是 LocalContainerEntityManagerFactoryBean,生成EntityManagerFactory的FactoryBean
if (emf instanceof EntityManagerFactoryInfo) {
cl = ((EntityManagerFactoryInfo) emf).getBeanClassLoader();
}
// 需要实现的接口
Class<?>[] ifcs = new Class<?>[entityManagerInterfaces.length + 1];
System.arraycopy(entityManagerInterfaces, 0, ifcs, 0, entityManagerInterfaces.length);
// 再添加一个EntityManagerProxy,用于获取原始EntityManager
ifcs[entityManagerInterfaces.length] = EntityManagerProxy.class;
// 创建EntityManager代理对象
return (EntityManager) Proxy.newProxyInstance((cl != null ? cl : SharedEntityManagerCreator.class.getClassLoader()), ifcs, new SharedEntityManagerInvocationHandler(emf, properties, synchronizedWithTransaction));
}
// JDK动态代理的拦截器,拦截EntityManager方法
public static class SharedEntityManagerInvocationHandler implements InvocationHandler {
// 创建EntityManager工厂
private final EntityManagerFactory targetFactory;
// jpa提供给供应商优化的属性
private final Map<?, ?> properties;
// 是否开启事务同步
private final boolean synchronizedWithTransaction;
// 代理类使用的类加载器
private transient volatile ClassLoader proxyClassLoader;
public SharedEntityManagerInvocationHandler(EntityManagerFactory target, @Nullable Map<?, ?> properties, boolean synchronizedWithTransaction) {
// 创建EntityManager的EntityManagerFactory
this.targetFactory = target;
this.properties = properties;
this.synchronizedWithTransaction = synchronizedWithTransaction;
// 初始化代理的类加载器
initProxyClassLoader();
}
private void initProxyClassLoader() {
// 为什么这个判断成立?
// 因为在创建当前Bean的时候,设置的builder.addConstructorArgReference(getEntityManagerBeanRef(config))
// config.getAttribute("entityManagerFactoryRef");
// 此时EntityManagerFactory是一个代理对象,这个代理对象实现了EntityManagerFactory
// 而他真实的对象是 LocalContainerEntityManagerFactoryBean,生成EntityManagerFactory的FactoryBean
if (this.targetFactory instanceof EntityManagerFactoryInfo) {
this.proxyClassLoader = ((EntityManagerFactoryInfo) this.targetFactory).getBeanClassLoader();
} else {
this.proxyClassLoader = this.targetFactory.getClass().getClassLoader();
}
}
// 代理拦截逻辑
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 如果执行的方法是getEntityManagerFactory,返回EntityManagerFactory的代理对象
if (method.getName().equals("getEntityManagerFactory")) {
return this.targetFactory;
}
// 执行的方法是getCriteriaBuilder,或者getMetamodel
if (method.getName().equals("getCriteriaBuilder") || method.getName().equals("getMetamodel")) {
// 执行代理对象的方法
return EntityManagerFactory.class.getMethod(method.getName()).invoke(this.targetFactory);
}
// unwrap,如果是EntityManager代理实例,直接返回代理对象
if (method.getName().equals("unwrap")) {
Class<?> targetClass = (Class<?>) args[0];
if (targetClass != null && targetClass.isInstance(proxy)) {
return proxy;
}
}
// 被Spring管理,都是返回true
if (method.getName().equals("isOpen")) {
return true;
}
// 不执行null
if (method.getName().equals("close")) {
return null;
}
// 获取事务,不能在共享的EntityManager新建事务,只能使用Spring事务或者EJB事务
if (method.getName().equals("getTransaction")) {
throw new IllegalStateException("Not allowed to create transaction on shared EntityManager - " + "use Spring transactions or EJB CMT instead");
}
// 获取一个带有事务的EntityManager
EntityManager target = EntityManagerFactoryUtils.doGetTransactionalEntityManager(this.targetFactory, this.properties, this.synchronizedWithTransaction);
// 如果是getTargetEntityManager
if (method.getName().equals("getTargetEntityManager")) {
// 当没有获取到可以操作事务的EntityManager,抛出异常
// 因为Spring管理的EntityManager是共享的,这个对象是不能创建事务,所以需要新创建一个独立EntityManager
if (target == null) {
throw new IllegalStateException("No transactional EntityManager available");
}
return target;
}
// 如果是必须要在事务中执行的方法
if (transactionRequiringMethods.contains(method.getName())) {
// 如果不存在支持事务的EntityManager,并且没有实际事务,并且事务不是活跃的,抛出异常
if (target == null || (!TransactionSynchronizationManager.isActualTransactionActive() && !target.getTransaction().isActive())) {
throw new TransactionRequiredException("No EntityManager with actual transaction available " +
"for current thread - cannot reliably process '" + method.getName() + "' call");
}
}
// EntityManager的常规操作
boolean isNewEm = false;
if (target == null) {
// 其他方法,如果存在给定供应商的配置,根据创建创建一个EntityManager
target = (!CollectionUtils.isEmpty(this.properties) ?
this.targetFactory.createEntityManager(this.properties) :
this.targetFactory.createEntityManager());
// 表示当前EntityManager为新建的
isNewEm = true;
}
try {
// 执行目标方法
Object result = method.invoke(target, args);
// 如果返回值是Query对象
if (result instanceof Query) {
Query query = (Query) result;
// 新建的EntityManager
if (isNewEm) {
// 缓存Query接口信息,Query接口类->Query接口继承的所有接口
Class<?>[] ifcs = cachedQueryInterfaces.computeIfAbsent(query.getClass(), key ->
ClassUtils.getAllInterfacesForClass(key, this.proxyClassLoader));
// 再创建Query接口的代理类,就是处理一些接口的特殊方法返回的对象,如果返回的值是Query对象,直接返回代理对象
// 如果返回的是其他类型的值,就直接返回结果,然后关闭entityManager
result = Proxy.newProxyInstance(this.proxyClassLoader, ifcs, new DeferredQueryInvocationHandler(query, target));
// 执行完毕,标记该EntityManager不为新的
isNewEm = false;
} else {
// 给Query对应设置查询超时属性
EntityManagerFactoryUtils.applyTransactionTimeout(query, this.targetFactory);
}
}
return result;
} catch (InvocationTargetException ex) {
throw ex.getTargetException();
} finally {
// 如果是新建的EntityManager,表示不是返回Query对象的情况,不需要延迟加载,执行完目标方法直接关闭EntityManager
// 如果是Query,那么需要延迟加载,还没获取到结果的时候不能关闭EntityManager
if (isNewEm) {
EntityManagerFactoryUtils.closeEntityManager(target);
}
}
}
}
}
// JPA的上下文,提供有关当前JPA设置的有用信息
// 内部保存了受管实体->对应操作这个实体的EntityManager的映射
class DefaultJpaContext {
// 当前JPA上下文中所有的EntityManager的信息
private final MultiValueMap<Class<?>, EntityManager> entityManagers;
public DefaultJpaContext(Set<EntityManager> entityManagers) {
// 保存所有托管实体类型->的EntityManager的映射信息
this.entityManagers = new LinkedMultiValueMap<Class<?>, EntityManager>();
// 遍历所有的EntityManager
for (EntityManager em : entityManagers) {
// 获取到元模型中,所有托管的实体信息
for (ManagedType<?> managedType : em.getMetamodel().getManagedTypes()) {
// 保存实体->EntityManager的映射信息
this.entityManagers.add(managedType.getJavaType(), em);
}
}
}
/**
* 通过受管的实体类型获取对应的EntityManager
*/
public EntityManager getEntityManagerByManagedType(Class<?> type) {
// 如果给定的实体没有被指定的EntityManager托管,抛出异常
if (!entityManagers.containsKey(type)) {
throw new IllegalArgumentException(String.format("%s is not a managed type!", type));
}
// 获取到实体对应的EntityManager
List<EntityManager> candidates = this.entityManagers.get(type);
// 只有一个,直接返回,如果存在多个,抛出异常
if (candidates.size() == 1) {
return candidates.get(0);
}
throw new IllegalArgumentException(String.format("%s managed by more than one EntityManagers: %s!", type.getName(), candidates));
}
}
// 产生EntityManagerFactoryBean的 FactoryBean
class LocalContainerEntityManagerFactoryBean extends AbstractEntityManagerFactoryBean implements FactoryBean<EntityManagerFactory> {
// 持久化单元管理器
private PersistenceUnitManager persistenceUnitManager;
// 默认的持久化单元管理器
private final DefaultPersistenceUnitManager internalPersistenceUnitManager = new DefaultPersistenceUnitManager();
// 持久化单元信息
private PersistenceUnitInfo persistenceUnitInfo;
public void afterPropertiesSet() throws PersistenceException {
// 没有指定persistenceUnitManager,默认就是空的
PersistenceUnitManager managerToUse = this.persistenceUnitManager;
// 如果没有设置
if (this.persistenceUnitManager == null) {
// 使用默认的持久化单元管理器来初始化
this.internalPersistenceUnitManager.afterPropertiesSet() {
// 清空持久化单元名称
this.persistenceUnitInfoNames.clear();
// 亲空持久化单元信息
this.persistenceUnitInfos.clear();
// 读取持久化单元信息
List<SpringPersistenceUnitInfo> puis = readPersistenceUnitInfos() {
List<SpringPersistenceUnitInfo> infos = new LinkedList<>();
// 默认的持久化单元名称
String defaultName = this.defaultPersistenceUnitName;
// 需要扫描的实体的路径,需要构建默认的持久化单元
boolean buildDefaultUnit = (this.packagesToScan != null || this.mappingResources != null);
// 找到默认的持久化单元
boolean foundDefaultUnit = false;
// 创建持久化单元解析器,解析persistenceXmlLocations("META-INF/persistence.xml")文件的持久化单元配置
PersistenceUnitReader reader = new PersistenceUnitReader(this.resourcePatternResolver, this.dataSourceLookup);
// 读取到的持久化单元配置
SpringPersistenceUnitInfo[] readInfos = reader.readPersistenceUnitInfos(this.persistenceXmlLocations);
// 遍历,保存
for (SpringPersistenceUnitInfo readInfo : readInfos) {
infos.add(readInfo);
}
// 如果设置了需要扫描的包名,即使persistence配置了,也要创建新的持久化单元
if (buildDefaultUnit) {
// 构建持久化单元信息
infos.add(buildDefaultPersistenceUnitInfo());
}
return infos;
}
// 上面创建好了持久化单元,对持久化单元进行一一配置
for (SpringPersistenceUnitInfo pui : puis) {
if (pui.getPersistenceUnitRootUrl() == null) {
pui.setPersistenceUnitRootUrl(determineDefaultPersistenceUnitRootUrl());
}
if (pui.getJtaDataSource() == null && this.defaultJtaDataSource != null) {
pui.setJtaDataSource(this.defaultJtaDataSource);
}
if (pui.getNonJtaDataSource() == null && this.defaultDataSource != null) {
pui.setNonJtaDataSource(this.defaultDataSource);
}
// ...还有其他配置
// 后置处理PersistenceUnitPostProcessor类型的处理器
postProcessPersistenceUnitInfo(pui) {
// 在只有在LocalContainerEntityManagerFactoryBean中添加了才会执行
PersistenceUnitPostProcessor[] postProcessors = getPersistenceUnitPostProcessors();
if (postProcessors != null) {
for (PersistenceUnitPostProcessor postProcessor : postProcessors) {
// 其中包含ClasspathScanningPersistenceUnitPostProcessor
postProcessor.postProcessPersistenceUnitInfo(pui) {
// 类扫描器
ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false);
provider.setEnvironment(environment);
provider.setResourceLoader(resourceLoader);
// 添加扫描的注解
provider.addIncludeFilter(new AnnotationTypeFilter(Entity.class));
provider.addIncludeFilter(new AnnotationTypeFilter(MappedSuperclass.class));
// 找到这些标注了注解的类
for (BeanDefinition definition : provider.findCandidateComponents(basePackage)) {
if (definition.getBeanClassName() != null) {
// 保存实体类到持久化单元中
pui.addManagedClassName(definition.getBeanClassName());
}
}
}
}
}
}
// 获取持久化单元名称
String name = pui.getPersistenceUnitName();
// 保存持久化单元信息
this.persistenceUnitInfos.put(name, pui);
}
}
// 标记内置默认的持久化单元管理器可以使用
managerToUse = this.internalPersistenceUnitManager;
}
// 确定持久化单元名称
this.persistenceUnitInfo = determinePersistenceUnitInfo(managerToUse) {
// 如果存在多个持久化单元,并且存在default默认的持久化单元名称
if (this.persistenceUnitInfos.size() > 1 && this.defaultPersistenceUnitName != null) {
// 使用默认的持久化单元,并清空持久化单元信息的缓存
return obtainPersistenceUnitInfo(this.defaultPersistenceUnitName) {
retrun this.persistenceUnitInfos.remove(persistenceUnitName);
}
}
// 如果只有一个或者多个不存在default持久化单元,那么直接使用第一个持久化单元
PersistenceUnitInfo pui = this.persistenceUnitInfos.values().iterator().next();
// 清空持久化单元信息缓存
this.persistenceUnitInfos.clear();
return pui;
}
// 获取到JPA供应商的是配置
JpaVendorAdapter jpaVendorAdapter = getJpaVendorAdapter();
// 设置供应商的配置
if (jpaVendorAdapter != null && this.persistenceUnitInfo instanceof SmartPersistenceUnitInfo) {
// 获取供应商持久化提供着的包名(org.hibernate)
String rootPackage = jpaVendorAdapter.getPersistenceProviderRootPackage();
// 设置对应的包名
if (rootPackage != null) {
((SmartPersistenceUnitInfo) this.persistenceUnitInfo).setPersistenceProviderPackageName(rootPackage);
}
}
// 开始进行配置
super.afterPropertiesSet() {
// 获取到JPA供应商的是配置
JpaVendorAdapter jpaVendorAdapter = getJpaVendorAdapter();
// 如果存在
if (jpaVendorAdapter != null) {
// 获取到供应商的提供者信息
if (this.persistenceProvider == null) {
this.persistenceProvider = jpaVendorAdapter.getPersistenceProvider();
}
// 获取持久化单元信息
PersistenceUnitInfo pui = getPersistenceUnitInfo();
// 获取到供应商对应的配置信息
Map<String, ?> vendorPropertyMap = (pui != null ? jpaVendorAdapter.getJpaPropertyMap(pui) : jpaVendorAdapter.getJpaPropertyMap());
// 如果不为空,将在LocalContainerEntityManagerFactoryBean设置的属性一一拷贝到vendorPropertyMap中
if (!CollectionUtils.isEmpty(vendorPropertyMap)) {
vendorPropertyMap.forEach((key, value) -> {
if (!this.jpaPropertyMap.containsKey(key)) {
this.jpaPropertyMap.put(key, value);
}
});
}
// 如果entityManagerFactoryInterface为空,设置entityManagerFactoryInterface为EntityManagerFactory
// 对于HibernateJpaVendorAdapter厂商指定了类型
// this.entityManagerFactoryInterface = org.hibernate.jpa.HibernateEntityManagerFactory.class;
// this.entityManagerInterface = org.hibernate.jpa.HibernateEntityManager.class;
if (this.entityManagerFactoryInterface == null) {
this.entityManagerFactoryInterface = jpaVendorAdapter.getEntityManagerFactoryInterface();
if (!ClassUtils.isVisible(this.entityManagerFactoryInterface, this.beanClassLoader)) {
this.entityManagerFactoryInterface = EntityManagerFactory.class;
}
}
// 设置entityManagerInterface为EntityManager
if (this.entityManagerInterface == null) {
this.entityManagerInterface = jpaVendorAdapter.getEntityManagerInterface();
if (!ClassUtils.isVisible(this.entityManagerInterface, this.beanClassLoader)) {
this.entityManagerInterface = EntityManager.class;
}
}
// 如果不存在jpa方言,从供应商配置中获取jpa方言
if (this.jpaDialect == null) {
this.jpaDialect = jpaVendorAdapter.getJpaDialect();
}
}
// 获取系统执行器线程池
AsyncTaskExecutor bootstrapExecutor = getBootstrapExecutor();
// 如果系统线程池不为空
if (bootstrapExecutor != null) {
// 使用异步来创建EntityManagerFactory对像
this.nativeEntityManagerFactoryFuture = bootstrapExecutor.submit(this::buildNativeEntityManagerFactory);
} else {
// 使用同步方式创建
this.nativeEntityManagerFactory = buildNativeEntityManagerFactory() {
// 创建EntityManagerFactory
EntityManagerFactory emf = createNativeEntityManagerFactory() {
// 获取持久化供应商
PersistenceProvider provider = getPersistenceProvider();
// 如果没有
if (provider == null) {
// 从持久化单元中获取,是不是配置的类名
String providerClassName = this.persistenceUnitInfo.getPersistenceProviderClassName();
// 如果类名也没配置,直接抛出异常
if (providerClassName == null) {
throw new IllegalArgumentException("No PersistenceProvider specified in EntityManagerFactory configuration");
}
// 将类名解析成Class
Class<?> providerClass = ClassUtils.resolveClassName(providerClassName, getBeanClassLoader());
// 实例化
provider = (PersistenceProvider) BeanUtils.instantiateClass(providerClass);
}
// 通过供应商的createContainerEntityManagerFactory创建EntityManagerFactory
// 在Spring环境,如果没有指定,默认就是SpringHibernateJpaPersistenceProvider
// SpringHibernateJpaPersistenceProvider extends HibernatePersistenceProvider
EntityManagerFactory emf = provider.createContainerEntityManagerFactory(this.persistenceUnitInfo, getJpaPropertyMap())
{
// 获取托管的所有实体类名
final List<String> mergedClassesAndPackages = new ArrayList<>(info.getManagedClassNames());
// 与设置需要托管实体的包名合并
// 这个包名为: .package-info配置的
if (info instanceof SmartPersistenceUnitInfo) {
mergedClassesAndPackages.addAll(((SmartPersistenceUnitInfo) info).getManagedPackages());
}
// 调用Hibernate的EntityManagerFactoryBuilder创建EntityManagerFactory
return new EntityManagerFactoryBuilderImpl(
// 指定需要托管的类名为上面解析到的类或者包名
new PersistenceUnitInfoDescriptor(info) {
public List<String> getManagedClassNames() {
return mergedClassesAndPackages;
}
}, properties)
.build();
}
// 扩展功能,后置处理,默认空实现,给子类扩展
postProcessEntityManagerFactory(emf, this.persistenceUnitInfo);
return emf;
}
// 获取JPA的供应商适配器
JpaVendorAdapter jpaVendorAdapter = getJpaVendorAdapter();
if (jpaVendorAdapter != null) {
// 执行供应商提供的创建EntityManagerFactory之后的回调
jpaVendorAdapter.postProcessEntityManagerFactory(emf);
}
return emf;
}
}
// 创建EntityManagerFactory的代理对象
this.entityManagerFactory = createEntityManagerFactoryProxy(this.nativeEntityManagerFactory) {
// 需要代理的接口
Set<Class<?>> ifcs = new LinkedHashSet<>();
Class<?> entityManagerFactoryInterface = this.entityManagerFactoryInterface;
// 如果自己指定了接口(如果没有指定,供应商会提供自己默认的)
if (entityManagerFactoryInterface != null) {
ifcs.add(entityManagerFactoryInterface);
}
// 如果没有指定,获取到entityManagerFactory对象实现的所有接口
else if (emf != null) {
ifcs.addAll(ClassUtils.getAllInterfacesForClassAsSet(emf.getClass(), this.beanClassLoader));
}
// 如果都没有,直接实现EntityManagerFactory接口
else {
ifcs.add(EntityManagerFactory.class);
}
// 并且实现EntityManagerFactoryInfo接口
ifcs.add(EntityManagerFactoryInfo.class);
// 创建代理对象
return (EntityManagerFactory) Proxy.newProxyInstance(this.beanClassLoader, ClassUtils.toClassArray(ifcs),
// 拦截逻辑
new ManagedEntityManagerFactoryInvocationHandler(this) {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 就是LocalContainerEntityManagerFactoryBean
return this.entityManagerFactoryBean.invokeProxyMethod(method, args) {
// 如果是EntityManagerFactoryInfo方法,直接执行
if (method.getDeclaringClass().isAssignableFrom(EntityManagerFactoryInfo.class)) {
return method.invoke(this, args);
}
// 如果是创建EntityManager
else if (method.getName().equals("createEntityManager") && args != null && args.length > 0 && args[0] == SynchronizationType.SYNCHRONIZED) {
// 创建根据属性创建EntityManager
EntityManager rawEntityManager = (args.length > 1 ?
getNativeEntityManagerFactory().createEntityManager((Map<?, ?>) args[1]) :
getNativeEntityManagerFactory().createEntityManager());
// 上面创建的是普通的EntityManager,要包装代理成被容器管理的EntityManager
// 拦截部分方法逻辑,例如: isOpen:返回true,getTransaction: 默认共享的EntityManager抛出异常
/**
* 和{@link SharedEntityManagerCreator.SharedEntityManagerInvocationHandler}创建代理对象类似
*/
return ExtendedEntityManagerCreator.createApplicationManagedEntityManager(rawEntityManager, this, true);
}
// 如果方法存在参数
if (args != null) {
for (int i = 0; i < args.length; i++) {
Object arg = args[i];
// 如果参数是Proxy,JDK代理
if (arg instanceof Query && Proxy.isProxyClass(arg.getClass())) {
// 拆包
args[i] = ((Query) arg).unwrap(null);
}
}
}
// 使用原EntityManagerFactory执行目标方法
Object retVal = method.invoke(getNativeEntityManagerFactory(), args);
// 如果返回值为EntityManager,表示调用了createEntityManager
if (retVal instanceof EntityManager) {
// 和上面执行createEntityManager方法一样的逻辑,要包装代理成被容器管理的EntityManager
// 拦截部分方法逻辑,例如: isOpen:返回true,getTransaction: 默认共享的EntityManager抛出异常
EntityManager rawEntityManager = (EntityManager) retVal;
retVal = ExtendedEntityManagerCreator.createApplicationManagedEntityManager(rawEntityManager, this, false);
}
// 返回结果
return retVal;
}
}
});
}
}
}
}
// 注册SharedEntityManagerCreator类,用于创建EntityManager对象的后置处理器
class EntityManagerBeanDefinitionRegistrarPostProcessor {
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
// 只处理ConfigurableListableBeanFactory类型的容器
if (!ConfigurableListableBeanFactory.class.isInstance(beanFactory)) {
return;
}
ConfigurableListableBeanFactory factory = (ConfigurableListableBeanFactory) beanFactory;
// 从容器中获取所有EntityManagerFactory,AbstractEntityManagerFactoryBean的Bean
Set<EntityManagerFactoryBeanDefinition> definitions = getEntityManagerFactoryBeanDefinitions(factory) {
Set<EntityManagerFactoryBeanDefinition> definitions = new HashSet<EntityManagerFactoryBeanDefinition>();
// types.add(EntityManagerFactory.class);
// types.add(AbstractEntityManagerFactoryBean.class);
for (Class<?> type : EMF_TYPES) {
for (String name : beanFactory.getBeanNamesForType(type, true, false)) {
// 将EntityManagerFactory的信息封装成EntityManagerFactoryBeanDefinition
registerEntityManagerFactoryBeanDefinition(transformedBeanName(name), beanFactory, definitions);
}
}
return definitions;
}
// 遍历找到的所有EntityManagerFactory,AbstractEntityManagerFactoryBean的Bean
for (EntityManagerFactoryBeanDefinition definition : definitions) {
// 获取对应的Bean工厂
BeanFactory definitionFactory = definition.getBeanFactory();
// 如果不是BeanDefinitionRegistry,不处理
if (!(definitionFactory instanceof BeanDefinitionRegistry)) {
continue;
}
BeanDefinitionRegistry definitionRegistry = (BeanDefinitionRegistry) definitionFactory;
// 注册一个Bean org.springframework.orm.jpa.SharedEntityManagerCreator
// 上面有解释,这个Bean是用来创建EntityManager的对象
BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition("org.springframework.orm.jpa.SharedEntityManagerCreator");
builder.setFactoryMethod("createSharedEntityManager");
// 当前SharedEntityManagerCreator通过构造方法引用EntityManagerFactory对象
builder.addConstructorArgReference(definition.getBeanName());
// 生成BeanDefinition
AbstractBeanDefinition emBeanDefinition = builder.getRawBeanDefinition();
// 设置限定符
emBeanDefinition.addQualifier(new AutowireCandidateQualifier(Qualifier.class, definition.getBeanName()));
// 设置作用域
emBeanDefinition.setScope(definition.getBeanDefinition().getScope());
// 设置Bean来源
emBeanDefinition.setSource(definition.getBeanDefinition().getSource());
// 设置懒加载
emBeanDefinition.setLazyInit(true);
// 生成BeanName,并且注册Bean
BeanDefinitionReaderUtils.registerWithGeneratedName(emBeanDefinition, definitionRegistry);
}
}
}
// 执行实现方法的拦截器
class ImplementationMethodExecutionInterceptor implements MethodInterceptor {
// 一个Repository对应所有碎片实现的组合
RepositoryComposition composition;
public Object invoke(MethodInvocation invocation) throws Throwable {
// 获取方法
Method method = invocation.getMethod();
// 获取参数
Object[] arguments = invocation.getArguments();
// 在Repository所有碎片实现类中找对应的实现类进行执行
return composition.invoke(method, arguments);
}
}
5万+
“相关推荐”对你有帮助么？
-
非常没帮助 -
没帮助 -
一般 -
有帮助 -
非常有帮助
提交
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
