SpringBoot 自动配置：Spring Data JPA

前言

不知道从啥时候开始项目上就一直用MyBatis，其实我个人更新JPA些，因为JPA看起来OO的思想更强烈些，所以这才最近把JPA拿出来再看一看，使用起来也很简单，除了定义Entity实体外，声明自己的业务接口继承JpaRepository接口，什么逻辑也不用写，基本的增删改查，分页，排序就都搞定了。

我在实现JpaRepository接口时就有个疑问，那么实现类是什么？如果用过MyBatis肯定也知道，是接口和实现类之间有一个代理类专门来处理这块的业务，那么JPA这块是否也会有一个代理类来处理同样的业务呢？ 总体来说我们有两个疑问，关键字分别是：接口实现类，代理类是什么。

工作原理分析

首先从spring-boot-autoconfiguration.jar中下的spring.factories中我们可以看到JPA的自动配置需要从JpaRepositoriesAutoConfiguration开始着手。 我先画了一张总的Spring Data JPA自动配置流程图，可以有个大概的认识，下面会从源代码层面再来读一读其工作原理，和关键代码都分布在那里。

JpaRepositoriesAutoConfiguration 自动配置

因为我们在pom中导入了spring-data-jpa.jar，数据库驱动jar包为系统默认jar，也就是说他们会出现在程序运行的classpath上，并且我们在yml文件中配置了数据源，所以在springboot程序启动中，springboot自动配置中关于JPA的自动配置就已经开始工作了，具体的自动配置类会从JpaRepositoriesAutoConfiguration开始。

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3307/readinglist?serverTimezone=UTC&useSSL=false&allowPublicKeyRetrieval\
  =true
spring.datasource.username=root
spring.datasource.password=000
spring.jpa.generate-ddl=false
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

从代码中可以看到JPA的默认实现是Hibernate，所以会先配置HibernateJpaAutoConfiguration，并且是在DataSource bean已经存在的情况下。

@Configuration(proxyBeanMethods = false)
@ConditionalOnBean(DataSource.class)
@ConditionalOnClass(JpaRepository.class)
@ConditionalOnMissingBean({ JpaRepositoryFactoryBean.class, JpaRepositoryConfigExtension.class })
@ConditionalOnProperty(prefix = "spring.data.jpa.repositories", name = "enabled", havingValue = "true",
		matchIfMissing = true)
//导入JpaRepositoriesRegistrar
@Import(JpaRepositoriesRegistrar.class)
//先自动配置HibernateJpaAutoConfiguration, TaskExecutionAutoConfiguration
@AutoConfigureAfter({ HibernateJpaAutoConfiguration.class, TaskExecutionAutoConfiguration.class })
public class JpaRepositoriesAutoConfiguration {
}

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ LocalContainerEntityManagerFactoryBean.class, EntityManager.class, SessionImplementor.class })
@EnableConfigurationProperties(JpaProperties.class)
@AutoConfigureAfter({ DataSourceAutoConfiguration.class })
@Import(HibernateJpaConfiguration.class)
public class HibernateJpaAutoConfiguration {

}

这里你首先会看到必须是DataSource bean存在的情况下，其次还有一个关键信息就是不存在JpaRepositoryFactoryBean bean的情况下才会执行该自动配置，也就是说如果你想根据自己的业务重新实现一个FactoryBean，那么该自动配置则不会执行。 那么看起来JpaRepositoryFactoryBean可能看起来有点眼熟哦。

JpaRepositoryFactoryBean位于org.springframework.data.jpa.repository.support包下

用户自定义的JpaRepository作为bean注入Spring容器中

JpaRepositoriesRegistrar中静态内部类使用了@EnableJpaRepositories开启JPA。如果不是SpringBoot项目中该注解是需要手动开启。

class JpaRepositoriesRegistrar extends AbstractRepositoryConfigurationSourceSupport {

	@EnableJpaRepositories
	private static class EnableJpaRepositoriesConfiguration {

	}

}

JpaRepositoriesRegistrar又继承了抽象类AbstractRepositoryConfigurationSourceSupport类。这是一个ImportBeanDefinitionRegistrar，设计目的就是在SpringBoot自动发现机制中发现用户自定义的JpaRepository。在Spring容器启动中，该ImportBeanDefinitionRegistrar就会执行。

public abstract class AbstractRepositoryConfigurationSourceSupport
    implements ImportBeanDefinitionRegistrar, BeanFactoryAware, ResourceLoaderAware, EnvironmentAware {
}

  在AbstractRepositoryConfigurationSourceSupport类中重写了registerBeanDefinitions方法，这个方法里又把实例化的任务交给了RepositoryConfigurationDelegate#registerRepositoriesIn()。

AbstractRepositoryConfigurationSourceSupport#registerBeanDefinitions

@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry,
			BeanNameGenerator importBeanNameGenerator) {
   RepositoryConfigurationDelegate delegate = new RepositoryConfigurationDelegate(
				getConfigurationSource(registry, importBeanNameGenerator), this.resourceLoader, this.environment);
   delegate.registerRepositoriesIn(registry, getRepositoryConfigurationExtension());
}

@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		registerBeanDefinitions(importingClassMetadata, registry, null);
}

RepositoryConfigurationDelegate#registerRepositoriesIn

public class RepositoryConfigurationDelegate {

    public List<BeanComponentDefinition> registerRepositoriesIn(BeanDefinitionRegistry registry, RepositoryConfigurationExtension extension) {

        extension.registerBeansForRoot(registry, this.configurationSource);
        RepositoryBeanDefinitionBuilder builder = new RepositoryBeanDefinitionBuilder(registry, extension, this.configurationSource, this.resourceLoader, this.environment);
        List<BeanComponentDefinition> definitions = new ArrayList();
        StopWatch watch = new StopWatch();

        watch.start();
        //extension.getRepositoryConfigurations() 会扫描相应的包并找到用户自定义JpaRepository接口
        Collection<RepositoryConfiguration<RepositoryConfigurationSource>> configurations = extension.getRepositoryConfigurations(this.configurationSource, this.resourceLoader, this.inMultiStoreMode);
        Map<String, RepositoryConfiguration<?>> configurationsByRepositoryName = new HashMap(configurations.size());
        Iterator var8 = configurations.iterator();

        while(var8.hasNext()) {
            RepositoryConfiguration<? extends RepositoryConfigurationSource> configuration = (RepositoryConfiguration)var8.next();
            configurationsByRepositoryName.put(configuration.getRepositoryInterface(), configuration);

            //对于每个扫描找到的用户自定义JpaRepository，构建一个BeanDefinitionBuilder，
		    //就是在这个步骤中将该BeanDefinition同JpaRepositoryFactoryBean建立关系
            BeanDefinitionBuilder definitionBuilder = builder.build(configuration);
            extension.postProcess(definitionBuilder, this.configurationSource);
            if (this.isXml) {
                extension.postProcess(definitionBuilder, (XmlRepositoryConfigurationSource)this.configurationSource);
            } else {
                extension.postProcess(definitionBuilder, (AnnotationRepositoryConfigurationSource)this.configurationSource);
            }

            //这里根据所发现的用户自定义JpaRepository接口的名字构造一个bean名称
            AbstractBeanDefinition beanDefinition = definitionBuilder.getBeanDefinition();
            beanDefinition.setResourceDescription(configuration.getResourceDescription());
            String beanName = this.configurationSource.generateBeanName(beanDefinition);
            if (logger.isTraceEnabled()) {
                logger.trace(LogMessage.format("Spring Data %s - Registering repository: %s - Interface: %s - Factory: %s", extension.getModuleName(), beanName, configuration.getRepositoryInterface(), configuration.getRepositoryFactoryBeanClassName()));
            }

            //设置当前BeanDefinition的属性factoryBeanObjectType为用户自定义JpaRepository接口的全限定名
            beanDefinition.setAttribute("factoryBeanObjectType", configuration.getRepositoryInterface());

            // 现在把这个bean注册到容器
            registry.registerBeanDefinition(beanName, beanDefinition);
            definitions.add(new BeanComponentDefinition(beanDefinition, beanName));
        }

        potentiallyLazifyRepositories(configurationsByRepositoryName, registry, this.configurationSource.getBootstrapMode());
        watch.stop();

        return definitions;
    }

}

RepositoryBeanDefinitionBuilder#build

public BeanDefinitionBuilder build(RepositoryConfiguration<?> configuration) {
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(configuration.getRepositoryFactoryBeanClassName());
    builder.getRawBeanDefinition().setSource(configuration.getSource());
    builder.addConstructorArgValue(configuration.getRepositoryInterface());
    builder.addPropertyValue("queryLookupStrategyKey", configuration.getQueryLookupStrategyKey());
    builder.addPropertyValue("lazyInit", configuration.isLazyInit());
    builder.setLazyInit(configuration.isLazyInit());
    builder.setPrimary(configuration.isPrimary());
    configuration.getRepositoryBaseClassName().ifPresent((it) -> {
        builder.addPropertyValue("repositoryBaseClass", it);
    });
    NamedQueriesBeanDefinitionBuilder definitionBuilder = new NamedQueriesBeanDefinitionBuilder(this.extension.getDefaultNamedQueryLocation());
    configuration.getNamedQueriesLocation().ifPresent(definitionBuilder::setLocations);
    builder.addPropertyValue("namedQueries", definitionBuilder.build(configuration.getSource()));
    this.registerCustomImplementation(configuration).ifPresent((it) -> {
        builder.addPropertyReference("customImplementation", it);
        builder.addDependsOn(it);
    });
    BeanDefinitionBuilder fragmentsBuilder = BeanDefinitionBuilder.rootBeanDefinition(RepositoryFragmentsFactoryBean.class);
    List<String> fragmentBeanNames = (List)this.registerRepositoryFragmentsImplementation(configuration).map(RepositoryFragmentConfiguration::getFragmentBeanName).collect(Collectors.toList());
    fragmentsBuilder.addConstructorArgValue(fragmentBeanNames);
    builder.addPropertyValue("repositoryFragments", ParsingUtils.getSourceBeanDefinition(fragmentsBuilder, configuration.getSource()));
    return builder;
}

我在builder()里调试了一下代码，程序执行到该方法倒数第二行代码时，可以BeanDefinitionBuilder#beanClass就是org.springframework.data.jpa.repository.support.JpaRepositoryFactoryBean。



从上面两段代码分析来看，不管用户创建多少个JpaRepository，最终注入Spring容器的bean都是来自JpaRepositoryFactoryBean工厂来创建。每个开发人员自定义的JpqRepository又都是针对不同的领域模型的，比如说UserRepository，OrderRepository，OrderLineItemRepository。

使用用户自定义的JpaRepository

@Autowired
private BookRepository bookRepository;

当你定义了的BookRepository后，在使用时又是如何从Spring容器中获取bean的。上面既然说了BeanDefinitionBuilder会和JpaRepositoryFactoryBean建立联系，那我们还是从JpaRepositoryFactoryBean入手。

public class JpaRepositoryFactoryBean<T extends Repository<S, ID>, S, ID>
		extends TransactionalRepositoryFactoryBeanSupport<T, S, ID> {

	//构造函数，这里repositoryInter就是你自定义的JpaRepository
	public JpaRepositoryFactoryBean(Class<? extends T> repositoryInterface) {
		super(repositoryInterface);
	}

	@Override
	protected RepositoryFactorySupport doCreateRepositoryFactory() {

		Assert.state(entityManager != null, "EntityManager must not be null!");

		return createRepositoryFactory(entityManager);
	}

    //这个方法会返回JpaRepositoryFactory
	protected RepositoryFactorySupport createRepositoryFactory(EntityManager entityManager) {

		JpaRepositoryFactory jpaRepositoryFactory = new JpaRepositoryFactory(entityManager);
		jpaRepositoryFactory.setEntityPathResolver(entityPathResolver);
		jpaRepositoryFactory.setEscapeCharacter(escapeCharacter);

		if (queryMethodFactory != null) {
			jpaRepositoryFactory.setQueryMethodFactory(queryMethodFactory);
		}

		return jpaRepositoryFactory;
	}

}

这段代码我们会关注两个地方，一个是构造函数，构造函数的参数repositoryInterface就是用户自定义的接口，一个是createRepositoryFactory()，Spring要创建JpaRepository的实现类，会先创建一个JpaRepositoryFactory，然后具体接口的实现类，或者叫做代理会交给该工厂类实现。

public class JpaRepositoryFactory extends RepositoryFactorySupport {

}

JpaRepositoryFactory继承了抽象类RepositoryFactorySupport，而RepositoryFactorySupport又实现了两个Spring接口BeanClassLoaderAware，BeanFactoryAware。

RepositoryFactorySupport位于spring-data-common.jar内。

RepositoryFactorySupport#getRepository

 public <T> T getRepository(Class<T> repositoryInterface, RepositoryFragments fragments) {

     //repositoryInterface为用户自定义的JpaRepository，这里为BookRepository。
     RepositoryMetadata metadata = this.getRepositoryMetadata(repositoryInterface);
     RepositoryComposition composition = this.getRepositoryComposition(metadata, fragments);
     RepositoryInformation information = this.getRepositoryInformation(metadata, composition);
     this.validate(information, composition);
     //target为SimpleJpaRepository。
     Object target = this.getTargetRepository(information);
     ProxyFactory result = new ProxyFactory();
     result.setTarget(target);
     result.setInterfaces(new Class[]{repositoryInterface, Repository.class, TransactionalProxy.class});
     if (MethodInvocationValidator.supports(repositoryInterface)) {
         result.addAdvice(new MethodInvocationValidator());
     }

     result.addAdvisor(ExposeInvocationInterceptor.ADVISOR);
     this.postProcessors.forEach((processor) -> {
         processor.postProcess(result, information);
     });
     if (DefaultMethodInvokingMethodInterceptor.hasDefaultMethods(repositoryInterface)) {
         result.addAdvice(new DefaultMethodInvokingMethodInterceptor());
     }

     ProjectionFactory projectionFactory = this.getProjectionFactory(this.classLoader, this.beanFactory);
     Optional<QueryLookupStrategy> queryLookupStrategy = this.getQueryLookupStrategy(this.queryLookupStrategyKey, this.evaluationContextProvider);
     result.addAdvice(new QueryExecutorMethodInterceptor(information, projectionFactory, queryLookupStrategy, this.namedQueries, this.queryPostProcessors, this.methodInvocationListeners));
     composition = composition.append(RepositoryFragment.implemented(target));
     result.addAdvice(new RepositoryFactorySupport.ImplementationMethodExecutionInterceptor(information, composition, this.methodInvocationListeners));
     //repository为SimpleJpaRepository
     T repository = result.getProxy(this.classLoader);

     return repository;
 }

这是一个关键方法，this.getTargetRepository会创建一个SimpleJpaRepository对象。该对象知道自己具体操作那个领域对象，随后又基于此类创建一个代理对象，设置Interceptor对象后返回该代理对象。 当真正的SimpleJpaRepository代理对象被创建之后，包裹该对象的JpaRepositoryFactoryBean对象就是我们最终要使用bean的FactoryBean，Spring容器中，用户自定义的bean保存的实际上是一个JpaRepositoryFactoryBean。

@Repository
@Transactional(readOnly = true)
public class SimpleJpaRepository<T, ID> implements JpaRepositoryImplementation<T, ID> {
     //这里就是我们常用的CURD方法了，终于看到了庐山真面目。
}

综上所述，注入bean实例化过程就结束了，可以进行注入了，根据上面的分析，每个用户自定义的JpaRepository实际上在Spring容器中保存的是一个JpaRepositoryFactoryBean，这是一个FactoryBean。当对JpaRepository进行注入并调用时会FactoryBean#getObject()获取要调用SimpleJpaRepository的代理对象。

总结

上面我自己提到的两个问题，到了这里我们就有一个明确的答案了，首先回答代理是什么，从上面调试代码可以看出来repository的h属性是JdkDynamicAopProxy对象。当程序执行的时候会通过调用JdkDynamicAopProxy.invoke()，比如说调用JpaRepository.findAll(), 代理对象的创建逻辑都隐藏在JdkDynamicAopProxy中，而在这里这个代理对象就是SimpleJpaRepository对象，也是你的自定义JpaRepository的实现类。

SimpleJpaRepository对象位于 org.springframework.data.jpa.repository.support包下。