SpringDataJPA+Hibernate框架源码剖析（五）框架整合 之 SpringBoot整合JPA剖析

SpringDataJPA+Hibernate框架源码剖析系列文章：

1. SpringDataJPA+Hibernate框架源码剖析（一）框架介绍
2. SpringDataJPA+Hibernate框架源码剖析（二）框架整合 之 EntityManagerFactory的构建
3. SpringDataJPA+Hibernate框架源码剖析（三）框架整合 之 Repository接口实现的生成
4. SpringDataJPA+Hibernate框架源码剖析（四）框架整合 之 事务管理器的构建（包括spring的事务机制）
5. SpringDataJPA+Hibernate框架源码剖析（五）框架整合 之 SpringBoot整合JPA剖析
6. SpringDataJPA+Hibernate框架源码剖析（六）@PersistenceContext和@Autowired注入EntityManager的区别

---

注：spring是采用注解式配置；为了控制篇幅本系列主要分析JPA和hibernate相关源码，需要配置过程和pom依赖的同学请自行百度。

SpringBoot整合JPA剖析

SpringBoot 设计的目的是为了让你尽可能快的跑起来 Spring 应用程序并且尽可能减少你的配置文件。SpringBoot相对Spring的优点主要有两个:起步依赖和自动装配。在使用springboot整合jap时只要引入spring-boot-starter-data-jpa依赖再添加几个注解即可完成配置。其实spring帮我们无非完成EntityManagerFactory的构建、Repository接口实现的生成、事务管理器的构建这三点，具体构建原理前面篇章已经讲解了。springboot的自动装配原理我们不过多讲解，只是验证一下我们猜想看在何处完成上述三点构建的。（springboot的自动装配原理可以参见SpringBoot启动流程原理+自动装配原理）

首先看spring-boot-autoconfigure下面的spring.factories中，存在于jpa相关的配置类JpaRepositoriesAutoConfiguration和HibernateJpaAutoConfiguration

JpaRepositoriesAutoConfiguration和HibernateJpaAutoConfiguration类将会被springboot自动装配

首先看JpaRepositoriesAutoConfiguration，这里可以知道得到两个消息

1. 注入JpaRepositoriesImportSelector
2. 在解析JpaRepositoriesAutoConfiguration类前先解析HibernateJpaAutoConfiguration

我们先看下JpaRepositoriesImportSelector，这个类的selectImports方法会在spring后置处理器中被调用，其返回值都会被注入容器中，这里发现了它的返回值有JpaRepositoriesRegistrar。这就等同于@EnableJpaRepositories注解的作用了，@EnableJpaRepositories的目的也是向容器中注入JpaRepositoriesRegistrar。所以说@EnableJpaRepositories注解是默认开启的。这里完成Repository接口实现的生成。

接下来再看下第二个配置类HibernateJpaAutoConfiguration，其实看到这个类也证明了springdatajap的默认实现是Hibernate。

这个类会注入HibernateJpaConfiguration，HibernateJpaConfiguration的父类是JpaBaseConfiguration如下，在这个类中可以看到PlatformTransactionManager、EntityManagerFactoryBuilder、JpaVendorAdapter、LocalContainerEntityManagerFactoryBean等核心组件的注入，在这里完成了EntityManagerFactory的构建和事务管理器的构建。值得关注的是他们的构建方法都带有@ConditionalOnMissingBean注解，这个注解的意思是只有当前容器中不存在指定类型Bean和BeanDefinition时才会注入，所以我们可以通过自定义构建LocalContainerEntityManagerFactoryBean等组件替换掉HibernateJpaConfiguration中的注入。

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(JpaProperties.class)
public abstract class JpaBaseConfiguration implements BeanFactoryAware {

	private final DataSource dataSource;

	private final JpaProperties properties;

	private final JtaTransactionManager jtaTransactionManager;

	private ConfigurableListableBeanFactory beanFactory;

	protected JpaBaseConfiguration(DataSource dataSource, JpaProperties properties,
			ObjectProvider<JtaTransactionManager> jtaTransactionManager) {
		this.dataSource = dataSource;
		this.properties = properties;
		this.jtaTransactionManager = jtaTransactionManager.getIfAvailable();
	}
	// 构建事务管理器
	@Bean
	@ConditionalOnMissingBean(TransactionManager.class)
	public PlatformTransactionManager transactionManager(
			ObjectProvider<TransactionManagerCustomizers> transactionManagerCustomizers) {
		JpaTransactionManager transactionManager = new JpaTransactionManager();
		transactionManagerCustomizers.ifAvailable((customizers) -> customizers.customize(transactionManager));
		return transactionManager;
	}

	@Bean
	@ConditionalOnMissingBean
	public JpaVendorAdapter jpaVendorAdapter() {
		AbstractJpaVendorAdapter adapter = createJpaVendorAdapter();
		adapter.setShowSql(this.properties.isShowSql());
		if (this.properties.getDatabase() != null) {
			adapter.setDatabase(this.properties.getDatabase());
		}
		if (this.properties.getDatabasePlatform() != null) {
			adapter.setDatabasePlatform(this.properties.getDatabasePlatform());
		}
		adapter.setGenerateDdl(this.properties.isGenerateDdl());
		return adapter;
	}

	@Bean
	@ConditionalOnMissingBean
	public EntityManagerFactoryBuilder entityManagerFactoryBuilder(JpaVendorAdapter jpaVendorAdapter,
			ObjectProvider<PersistenceUnitManager> persistenceUnitManager,
			ObjectProvider<EntityManagerFactoryBuilderCustomizer> customizers) {
		EntityManagerFactoryBuilder builder = new EntityManagerFactoryBuilder(jpaVendorAdapter,
				this.properties.getProperties(), persistenceUnitManager.getIfAvailable());
		customizers.orderedStream().forEach((customizer) -> customizer.customize(builder));
		return builder;
	}
	// 构建EntityManagerFactory
	@Bean
	@Primary
	@ConditionalOnMissingBean({ LocalContainerEntityManagerFactoryBean.class, EntityManagerFactory.class })
	public LocalContainerEntityManagerFactoryBean entityManagerFactory(EntityManagerFactoryBuilder factoryBuilder) {
		Map<String, Object> vendorProperties = getVendorProperties();
		customizeVendorProperties(vendorProperties);
		return factoryBuilder.dataSource(this.dataSource).packages(getPackagesToScan()).properties(vendorProperties)
				.mappingResources(getMappingResources()).jta(isJta()).build();
	}

	protected abstract AbstractJpaVendorAdapter createJpaVendorAdapter();

	protected abstract Map<String, Object> getVendorProperties();

	/**
	 * Customize vendor properties before they are used. Allows for post processing (for
	 * example to configure JTA specific settings).
	 * @param vendorProperties the vendor properties to customize
	 */
	protected void customizeVendorProperties(Map<String, Object> vendorProperties) {
	}

	protected String[] getPackagesToScan() {
		List<String> packages = EntityScanPackages.get(this.beanFactory).getPackageNames();
		if (packages.isEmpty() && AutoConfigurationPackages.has(this.beanFactory)) {
			packages = AutoConfigurationPackages.get(this.beanFactory);
		}
		return StringUtils.toStringArray(packages);
	}

	private String[] getMappingResources() {
		List<String> mappingResources = this.properties.getMappingResources();
		return (!ObjectUtils.isEmpty(mappingResources) ? StringUtils.toStringArray(mappingResources) : null);
	}

	/**
	 * Return the JTA transaction manager.
	 * @return the transaction manager or {@code null}
	 */
	protected JtaTransactionManager getJtaTransactionManager() {
		return this.jtaTransactionManager;
	}

	/**
	 * Returns if a JTA {@link PlatformTransactionManager} is being used.
	 * @return if a JTA transaction manager is being used
	 */
	protected final boolean isJta() {
		return (this.jtaTransactionManager != null);
	}

	/**
	 * Return the {@link JpaProperties}.
	 * @return the properties
	 */
	protected final JpaProperties getProperties() {
		return this.properties;
	}

	/**
	 * Return the {@link DataSource}.
	 * @return the data source
	 */
	protected final DataSource getDataSource() {
		return this.dataSource;
	}

	@Override
	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
		this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
	}

	@Configuration(proxyBeanMethods = false)
	@ConditionalOnWebApplication(type = Type.SERVLET)
	@ConditionalOnClass(WebMvcConfigurer.class)
	@ConditionalOnMissingBean({ OpenEntityManagerInViewInterceptor.class, OpenEntityManagerInViewFilter.class })
	@ConditionalOnMissingFilterBean(OpenEntityManagerInViewFilter.class)
	@ConditionalOnProperty(prefix = "spring.jpa", name = "open-in-view", havingValue = "true", matchIfMissing = true)
	protected static class JpaWebConfiguration {

		private static final Log logger = LogFactory.getLog(JpaWebConfiguration.class);

		private final JpaProperties jpaProperties;

		protected JpaWebConfiguration(JpaProperties jpaProperties) {
			this.jpaProperties = jpaProperties;
		}

		@Bean
		public OpenEntityManagerInViewInterceptor openEntityManagerInViewInterceptor() {
			if (this.jpaProperties.getOpenInView() == null) {
				logger.warn("spring.jpa.open-in-view is enabled by default. "
						+ "Therefore, database queries may be performed during view "
						+ "rendering. Explicitly configure spring.jpa.open-in-view to disable this warning");
			}
			return new OpenEntityManagerInViewInterceptor();
		}

		@Bean
		public WebMvcConfigurer openEntityManagerInViewInterceptorConfigurer(
				OpenEntityManagerInViewInterceptor interceptor) {
			return new WebMvcConfigurer() {

				@Override
				public void addInterceptors(InterceptorRegistry registry) {
					registry.addWebRequestInterceptor(interceptor);
				}

			};
		}

	}

}