JpaRepository动态代理执行原理

本文基于spring-boot-starter-data-jpa:2.7.17分析

SpringBoot 里集成Jpa自动配置是如何处理的

通过分析SpringBoot 自动配置核心源码可以找到JpaRepositoriesRegistrar类，这个类的父类是抽象类AbstractRepositoryConfigurationSourceSupport。 抽象类AbstractRepositoryConfigurationSourceSupport 上面写了一段注释：用来自动配置Spring Data Repositories

1. class JpaRepositoriesRegistrar extends AbstractRepositoryConfigurationSourceSupport {
2.        
3. }

复制代码

这个类同时实现了4个Spring核心接口
ImportBeanDefinitionRegistrar
BeanFactoryAware
ResourceLoaderAware
EnvironmentAware
这4个接口里面，最核心的接口是ImportBeanDefinitionRegistrar， 经常看Spring源码对这个接口肯定不陌生，Spring容器启动时会调用该接口，用于动态注册BeanDefintion，允许你在应用程序上下文启动时以编程的方式定义BeanDefinition。 当实现ImportBeanDefinitionRegistrar时，需要实现其中的registerBeanDefinitions方法，这个方法允许以编程的方式注册BeanDefintion，可以根据条件、配置或者其他逻辑来动态决定要注册那些Bean。
ImportBeanDefinitionRegistrar通常和Import注解一起使用，可以在一个配置类上使用Import注解，将一个实现了ImportBeanDefinitionRegistrar接口的类指定为要注册为Bean定义的来源，在ImportBeanDefinitionRegistrar实现类中，你可以根据需要注册一个或多个BeanDefintion，然后这些Bean就可以在Spring容器中使用。

1. public abstract class AbstractRepositoryConfigurationSourceSupport
2.                 implements ImportBeanDefinitionRegistrar, BeanFactoryAware, ResourceLoaderAware, EnvironmentAware {
4.     //这里我删除了成员变量和其他方法，留下这两个核心方法       
5.         @Override
6.         public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry,
7.                         BeanNameGenerator importBeanNameGenerator) {
8.                 RepositoryConfigurationDelegate delegate = new RepositoryConfigurationDelegate(
9.                                 getConfigurationSource(registry, importBeanNameGenerator), this.resourceLoader, this.environment);
10.                 //这里声明了委托类 RepositoryConfigurationDelegate,
11.                 //进一步调用了其 registerRepositoriesIn 方法
12.                 delegate.registerRepositoriesIn(registry, getRepositoryConfigurationExtension());
13.         }
15.         @Override
16.         public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
17.                 registerBeanDefinitions(importingClassMetadata, registry, null);
18.         }
19. }

复制代码

接下来看RepositoryConfigurationDelegate类的核心方法registerRepositoriesIn

1. /**
2. * registry也就是这里用到的是Spring容器DefaultListableBeanFactory
3. * extension 也就是实现类JpaRepositoryConfigExtension实例
4. * **/
5. public List<BeanComponentDefinition> registerRepositoriesIn(BeanDefinitionRegistry registry, RepositoryConfigurationExtension extension) {       
6.         extension.registerBeansForRoot(registry, configurationSource);
8.         RepositoryBeanDefinitionBuilder builder = new RepositoryBeanDefinitionBuilder(registry, extension,
9.                         configurationSource, resourceLoader, environment);
11.         List<BeanComponentDefinition> definitions = new ArrayList<>();
13.         ApplicationStartup startup = getStartup(registry);
14.         StartupStep repoScan = startup.start("spring.data.repository.scanning");
15.         repoScan.tag("dataModule", extension.getModuleName());
16.         repoScan.tag("basePackages",
17.                         () -> configurationSource.getBasePackages().stream().collect(Collectors.joining(", ")));
19.         //关键代码1： 这里会找到所有的自定义的Repository， 比如我这个demo里的BookRepository, FilmRepository
20.         Collection<RepositoryConfiguration<RepositoryConfigurationSource>> configurations = extension
21.                         .getRepositoryConfigurations(configurationSource, resourceLoader, inMultiStoreMode);
23.         Map<String, RepositoryConfiguration<?>> configurationsByRepositoryName = new HashMap<>(configurations.size());
25.         for (RepositoryConfiguration<? extends RepositoryConfigurationSource> configuration : configurations) {
27.                 configurationsByRepositoryName.put(configuration.getRepositoryInterface(), configuration);
29.         //关键代码2： 这个builder.build方法里就要产生JpqRepositoryFactoryBean这个对象了
30.                 BeanDefinitionBuilder definitionBuilder = builder.build(configuration);
32.                 extension.postProcess(definitionBuilder, configurationSource);
34.                 if (isXml) {
35.                         extension.postProcess(definitionBuilder, (XmlRepositoryConfigurationSource) configurationSource);
36.                 } else {
37.                         extension.postProcess(definitionBuilder, (AnnotationRepositoryConfigurationSource) configurationSource);
38.                 }
40.                 //关键代码3： 创建出来beanDefinition
41.                 //1. 这里的beanDefinition的实例化对象类型是RootBeanDefinition
42.                 //2. beanDefinition对象的beanClass是JpaRepositoryFactoryBean 这一步很重要，因为后面从Spring容器中提取时就是这个类
43.                 AbstractBeanDefinition beanDefinition = definitionBuilder.getBeanDefinition();
44.                 beanDefinition.setResourceDescription(configuration.getResourceDescription());
46.                 //beanName也就是自定义的repository， 比如bookRepository
47.                 String beanName = configurationSource.generateBeanName(beanDefinition);
49.                 //给当前beanDefinition设置一个属性，key是常量字符串"factoryBeanObjectType"，value值是repository接口全限定名com.codingbetter.jpa.bookRepository
50.                 beanDefinition.setAttribute(FACTORY_BEAN_OBJECT_TYPE, configuration.getRepositoryInterface());
52.                 //关键代码4: 这里会把自定义的Repository注册到Spring容器中
53.                 registry.registerBeanDefinition(beanName, beanDefinition);
54.                 definitions.add(new BeanComponentDefinition(beanDefinition, beanName));
55.         }
57.         potentiallyLazifyRepositories(configurationsByRepositoryName, registry, configurationSource.getBootstrapMode());
59.         repoScan.tag("repository.count", Integer.toString(configurations.size()));
60.         repoScan.end();
62.         return definitions;
63. }

复制代码

OK,  看了这几个代码片段后，也就能回答上面第二个问题了。

那些JpaRepository里没有实现的查询方法，仅靠约定就能实现的是什么原理？

1. /**
2. * RepositoryFactoryBeanSupport#afterPropertiesSet
3. */
4. public void afterPropertiesSet() {
5.         //创建RepositoryFactorySupport， 这个方法在子类JpaRepositoryFactoryBean中实现，父类中只声明了抽象方法名称，交给子类实现
6.         //子类创建并返回JpaRepositoryFactory类
7.         //也就是this.factory就是JpaRepositoryFactory实例化类型
8.         this.factory = createRepositoryFactory();
9.         this.factory.setQueryLookupStrategyKey(queryLookupStrategyKey);
10.         this.factory.setNamedQueries(namedQueries);
11.         this.factory.setEvaluationContextProvider(
12.                         evaluationContextProvider.orElseGet(() -> QueryMethodEvaluationContextProvider.DEFAULT));
13.         this.factory.setBeanClassLoader(classLoader);
14.         this.factory.setBeanFactory(beanFactory);
16.         if (publisher != null) {
17.                 this.factory.addRepositoryProxyPostProcessor(new EventPublishingRepositoryProxyPostProcessor(publisher));
18.         }
20.         repositoryBaseClass.ifPresent(this.factory::setRepositoryBaseClass);
22.         this.repositoryFactoryCustomizers.forEach(customizer -> customizer.customize(this.factory));
24.         RepositoryFragments customImplementationFragment = customImplementation //
25.                         .map(RepositoryFragments::just) //
26.                         .orElseGet(RepositoryFragments::empty);
28.         RepositoryFragments repositoryFragmentsToUse = this.repositoryFragments //
29.                         .orElseGet(RepositoryFragments::empty) //
30.                         .append(customImplementationFragment);
32.         this.repositoryMetadata = this.factory.getRepositoryMetadata(repositoryInterface);
34.         //关键代码： 这里就会创建SimpleJpaRepository
35.         //Lazy.of()的参数是委托java.util.function.Supplier
36.         //这里会调用JpaRepositoryFactory#getRepository()
37.         this.repository = Lazy.of(() -> this.factory.getRepository(repositoryInterface, repositoryFragmentsToUse));
39.         this.mappingContext.ifPresent(it -> it.getPersistentEntity(repositoryMetadata.getDomainType()));
41.         if (!lazyInit) {
42.         //这里的repository是一个Lazy类型，而在上面Lazy中，入参，通过factory.getRepsitory中保存了
43.         //SimpleJpaRepository引用，所以这里的this.repository.get就是返回SimpleJpaRepository
44.                 this.repository.get();
45.         }
46. }

复制代码

当我们在repo接口里按照契约定义这两个方法，那么jpa就帮我们实现了，那么jpa是怎么帮我们实现呢，答案是AbstractJpaQuery在做。
AbstractJpaQuery抽象类相关实现类

前面注入SimpleJpaRepository类时， RepositoryFactorySupport.getRepository方法里注入了两个关键的拦截器和查询有关，分别是QueryExecutorMethodInterceptor和ImplementationMethodExecutionInterceptor

1. /**
2. * RepositoryFactorySupport#getRepository
3. * 第一个参数也就是我们自定义的bookRepository全路径
4. */
5. public <T> T getRepository(Class<T> repositoryInterface, RepositoryFragments fragments) {
6.         ApplicationStartup applicationStartup = getStartup();
8.         StartupStep repositoryInit = onEvent(applicationStartup, "spring.data.repository.init", repositoryInterface);
10.         repositoryBaseClass.ifPresent(it -> repositoryInit.tag("baseClass", it.getName()));
12.         StartupStep repositoryMetadataStep = onEvent(applicationStartup, "spring.data.repository.metadata",
13.                         repositoryInterface);
14.         RepositoryMetadata metadata = getRepositoryMetadata(repositoryInterface);
15.         repositoryMetadataStep.end();
17.         StartupStep repositoryCompositionStep = onEvent(applicationStartup, "spring.data.repository.composition",
18.                         repositoryInterface);
19.         repositoryCompositionStep.tag("fragment.count", String.valueOf(fragments.size()));
21.         RepositoryComposition composition = getRepositoryComposition(metadata, fragments);
22.         //关键代码1：这一步指定了repositoryBaseClass为SimpleJpaRepository
23.         RepositoryInformation information = getRepositoryInformation(metadata, composition);
25.         repositoryCompositionStep.tag("fragments", () -> {
27.                 StringBuilder fragmentsTag = new StringBuilder();
29.                 for (RepositoryFragment<?> fragment : composition.getFragments()) {
31.                         if (fragmentsTag.length() > 0) {
32.                                 fragmentsTag.append(";");
33.                         }
35.                         fragmentsTag.append(fragment.getSignatureContributor().getName());
36.                         fragmentsTag.append(fragment.getImplementation().map(it -> ":" + it.getClass().getName()).orElse(""));
37.                 }
39.                 return fragmentsTag.toString();
40.         });
42.         repositoryCompositionStep.end();
44.         StartupStep repositoryTargetStep = onEvent(applicationStartup, "spring.data.repository.target", repositoryInterface);
45.        
46.         //关键代码2：看到这句代码是不是很熟悉，这里target就是SimpleJpaRepository
47.         //getTargetRepository方法在子类JpaRepositoryFactory中实现
48.         Object target = getTargetRepository(information);
50.         repositoryTargetStep.tag("target", target.getClass().getName());
51.         repositoryTargetStep.end();
53.         RepositoryComposition compositionToUse = composition.append(RepositoryFragment.implemented(target));
54.         validate(information, compositionToUse);
56.         StartupStep repositoryProxyStep = onEvent(applicationStartup, "spring.data.repository.proxy", repositoryInterface);
57.        
58.         //关键代码3：创建代理，设置Target和Interface
59.         ProxyFactory result = new ProxyFactory();
60.         result.setTarget(target);
61.         result.setInterfaces(repositoryInterface, Repository.class, TransactionalProxy.class);
63.         if (MethodInvocationValidator.supports(repositoryInterface)) {
64.                 result.addAdvice(new MethodInvocationValidator());
65.         }
67.         result.addAdvisor(ExposeInvocationInterceptor.ADVISOR);
69.         if (!postProcessors.isEmpty()) {
70.                 StartupStep repositoryPostprocessorsStep = onEvent(applicationStartup, "spring.data.repository.postprocessors",
71.                                 repositoryInterface);
72.                 postProcessors.forEach(processor -> {
74.                         StartupStep singlePostProcessor = onEvent(applicationStartup, "spring.data.repository.postprocessor",
75.                                         repositoryInterface);
76.                         singlePostProcessor.tag("type", processor.getClass().getName());
77.                         processor.postProcess(result, information);
78.                         singlePostProcessor.end();
79.                 });
80.                 repositoryPostprocessorsStep.end();
81.         }
83.         if (DefaultMethodInvokingMethodInterceptor.hasDefaultMethods(repositoryInterface)) {
84.                 result.addAdvice(new DefaultMethodInvokingMethodInterceptor());
85.         }
87.         Optional<QueryLookupStrategy> queryLookupStrategy = getQueryLookupStrategy(queryLookupStrategyKey,
88.                         evaluationContextProvider);
89.         result.addAdvice(new QueryExecutorMethodInterceptor(information, getProjectionFactory(), queryLookupStrategy,
90.                         namedQueries, queryPostProcessors, methodInvocationListeners));
92.         result.addAdvice(new ImplementationMethodExecutionInterceptor(information, compositionToUse, methodInvocationListeners));
94.         //关键代码4：从代理里获取repository， 也就是SimpleJpaRepository
95.         T repository = (T) result.getProxy(classLoader);
96.         repositoryProxyStep.end();
97.         repositoryInit.end();
99.         return repository;
100. }

复制代码

QueryExecutorMethodInterceptor拦截器的构造函数

1. /***
2. * RepositoryFactorySupport#getRepositoryInformation
3. */
4. private RepositoryInformation getRepositoryInformation(RepositoryMetadata metadata,
5.                         RepositoryComposition composition) {
7.         RepositoryInformationCacheKey cacheKey = new RepositoryInformationCacheKey(metadata, composition);
9.         return repositoryInformationCache.computeIfAbsent(cacheKey, key -> {
10.                 //这一步调用getRepositoryBaseClass, 而这个方法会由子类重写
11.                 Class<?> baseClass = repositoryBaseClass.orElse(getRepositoryBaseClass(metadata));
12.                 return new DefaultRepositoryInformation(metadata, baseClass, composition);
13.         });
14. }
16. /**
17. * JpaRepositoryFactory#getRepositoryBaseClass
18. * 这一步创建了SimpleJpaRepository
19. */
20. protected Class<?> getRepositoryBaseClass(RepositoryMetadata metadata) {
21.         return SimpleJpaRepository.class;
22. }

复制代码

这里PartTreeJpaQuery类里有个关键类PartTree， 在这个类里会看到根据契约find, count, exists去查询数据， 会根据正则表达式去匹配查询方法， 对吧，看到这些方法是不是就很熟悉了。

PartTreeJpaQuery

1. public interface BookRepository extends JpaRepository<Book, Integer> {
2.     List<Book> findByName(String name);
4.     List<Book> findByAuthor(String author);
5. }

复制代码

PartTree

1. public <T> T getRepository(Class<T> repositoryInterface, RepositoryFragments fragments) {
3.         Optional<QueryLookupStrategy> queryLookupStrategy = getQueryLookupStrategy(queryLookupStrategyKey,
4.                         evaluationContextProvider);
6.         result.addAdvice(new QueryExecutorMethodInterceptor(information, getProjectionFactory(), queryLookupStrategy, namedQueries, queryPostProcessors, methodInvocationListeners));
8.         result.addAdvice(new ImplementationMethodExecutionInterceptor(information, compositionToUse, methodInvocationListeners));
10.         T repository = (T) result.getProxy(classLoader);
11.         repositoryProxyStep.end();
12.         repositoryInit.end();
14.         return repository;
15. }

复制代码

AbstractJpaQuery#execute

1. private final Map<Method, RepositoryQuery> queries;
3. public QueryExecutorMethodInterceptor(RepositoryInformation repositoryInformation,
4.                         ProjectionFactory projectionFactory,
5.                         Optional<QueryLookupStrategy> queryLookupStrategy,
6.                         NamedQueries namedQueries,
7.                         List<QueryCreationListener<?>> queryPostProcessors,
8.                         List<RepositoryMethodInvocationListener> methodInvocationListeners) {
10.         this.repositoryInformation = repositoryInformation;
11.         this.namedQueries = namedQueries;
12.         this.queryPostProcessors = queryPostProcessors;
13.         this.invocationMulticaster = methodInvocationListeners.isEmpty() ? NoOpRepositoryInvocationMulticaster.INSTANCE
14.                         : new DefaultRepositoryInvocationMulticaster(methodInvocationListeners);
16.         this.resultHandler = new QueryExecutionResultHandler(RepositoryFactorySupport.CONVERSION_SERVICE);
17.        
18.         /***
19.         **这个queries是一个map数组，保存了你的自定义查询方法。
20.     **这里也就能明白RepositoryQuery的设计， 一个自定义方法就代表一个RepositoryQuery
21.         */
22.         this.queries = queryLookupStrategy
23.                                 .map(it -> mapMethodsToQuery(repositoryInformation, it, projectionFactory)) //
24.                                 .orElse(Collections.emptyMap());
25. }

复制代码

OK 看到这里第三个问题也就知道来龙去脉了，再说一句，PartTreeJpaQuery是针对在方法头上未标注Query注解的方法，它是用jpa根据方法去识别并转化成SQL方法去执行。

总结

接触jpa时间不长，里面一些来龙去脉还在研究和摸索中，如果有描述不正确的地方，可以留言讨论哦。

参考链接

https://xie.infoq.cn/article/24c7c7874e31f9f057f80ff40
https://www.cnblogs.com/sword-successful/p/14337507.html
https://zhuanlan.zhihu.com/p/344630578

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！