SpringDataJPA+Hibernate框架源码剖析（五）框架整合 之 SpringBoot整合JPA剖析_spring boot整合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);
				}

			};
		}

	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169