JPA on F嘉阳

GraphQL实践2——Spring-GraphQL集成JPA与MySQL

Mon, 15 Nov 2021 15:38:00 +0800

介绍

上一篇介绍到用第三方库集成GraphQL，目前spring-graphql项目已经出到1.0.0-M3版本，属于内部预览版，此处尝鲜验证

引入依赖

由于SpringBoot 2.6.0还未发布，因此需要引入较多依赖

<dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <optional>true</optional>
 </dependency>
 <dependency>
 <groupId>org.springframework.experimental</groupId>
 <artifactId>graphql-spring-boot-starter</artifactId>
 <version>1.0.0-M3</version>
 </dependency>
 <!--升级到Spring Boot 2.6后可以移除-->
 <dependency>
 <groupId>org.springframework.data</groupId>
 <artifactId>spring-data-commons</artifactId>
 <version>2.6.0-RC1</version>
 </dependency>
 <dependency>
 <groupId>org.springframework.data</groupId>
 <artifactId>spring-data-jpa</artifactId>
 <version>2.6.0-RC1</version>
 </dependency>
 <!-- https://mvnrepository.com/artifact/org.hibernate.javax.persistence/hibernate-jpa-2.1-api -->
 <dependency>
 <groupId>org.hibernate.javax.persistence</groupId>
 <artifactId>hibernate-jpa-2.1-api</artifactId>
 <version>1.0.2.Final</version>
 </dependency>
 <!-- https://mvnrepository.com/artifact/com.querydsl/querydsl-jpa -->
 <dependency>
 <groupId>com.querydsl</groupId>
 <artifactId>querydsl-jpa</artifactId>
 <version>4.4.0</version>
 </dependency>
 <!-- https://mvnrepository.com/artifact/com.querydsl/querydsl-apt -->
 <dependency>
 <groupId>com.querydsl</groupId>
 <artifactId>querydsl-apt</artifactId>
 <version>4.4.0</version>
 </dependency>
 <!-- https://mvnrepository.com/artifact/javax.annotation/javax.annotation-api -->
 <dependency>
 <groupId>javax.annotation</groupId>
 <artifactId>javax.annotation-api</artifactId>
 </dependency>
 <dependency>
 <groupId>com.querydsl</groupId>
 <artifactId>querydsl-core</artifactId>
 </dependency>
 <dependency>
 <groupId>com.querydsl</groupId>
 <artifactId>querydsl-jpa</artifactId>
 </dependency>
 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <scope>runtime</scope>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 </dependency>
</dependencies>

引入里程碑仓库

由于还没有GA，所以要引入里程碑仓库

<repositories>
 <repository>
 <id>spring-milestones</id>
 <name>Spring Milestones</name>
 <url>https://repo.spring.io/milestone</url>
 </repository>
 <repository>
 <id>spring-snapshots</id>
 <name>Spring Snapshots</name>
 <url>https://repo.spring.io/snapshot</url>
 <snapshots>
 <enabled>true</enabled>
 </snapshots>
 </repository>
</repositories>

引入插件

由于使用了dsl动态生成，还要引入注解处理器

<build>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 <configuration>
 <excludes>
 <exclude>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 </exclude>
 </excludes>
 </configuration>
 </plugin>
 <!-- added for QueryDsl-->
 <plugin>
 <groupId>com.mysema.maven</groupId>
 <artifactId>apt-maven-plugin</artifactId>
 <version>1.1.3</version>
 <executions>
 <execution>
 <goals>
 <goal>process</goal>
 </goals>
 <configuration>
 <outputDirectory>target/generated-sources/java</outputDirectory>
 <processor>com.querydsl.apt.jpa.JPAAnnotationProcessor</processor>
 </configuration>
 </execution>
 </executions>
 </plugin>
 </plugins>
</build>

SpringBoot 配置

编写配置文件

spring:
 datasource:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: root
 password: "****"
 url: jdbc:mysql://localhost:3306/sakila?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
 jpa:
 hibernate:
 ddl-auto: none
 show-sql: true
 database-platform: org.hibernate.dialect.MySQL55Dialect
 properties:
 hibernate:
 format_sql: true
 use_sql_comments: true
 graphql:
 path: /graphql
 schema:
 locations: classpath:graphql/
 fileExtensions: .graphqls, .gqls
 printer:
 enabled: true
server:
 port: 8080

实体类

package top.fjy8018.graphsqldemo.entity;

import lombok.Data;

import javax.persistence.*;
import java.sql.Timestamp;
import java.util.Objects;

/**
 * 演员表实体类
 *
 * @author F嘉阳
 * @date 2021/11/5 10:34
 */
@Data
@Entity
@Table(name = "actor", schema = "sakila")
public class ActorEntity {
 @Id
 @Column(name = "actor_id", nullable = false)
 private Integer actorId;

 @Column(name = "first_name", nullable = false, length = 45)
 private String firstName;

 @Column(name = "last_name", nullable = false, length = 45)
 private String lastName;

 @Column(name = "last_update", nullable = false)
 private Date lastUpdate;

}

DAO

DAO直接继承dsl相关处理器，可自动配对增删改查方法，相比第三方库更加简便

package top.fjy8018.graphsqldemo.repository;

import org.springframework.data.querydsl.QuerydslPredicateExecutor;
import org.springframework.data.repository.CrudRepository;
import org.springframework.graphql.data.GraphQlRepository;
import top.fjy8018.graphsqldemo.entity.ActorEntity;

/**
 * 演员表DAO
 *
 * @author F嘉阳
 * @date 2021/11/5 10:35
 */
@GraphQlRepository
public interface ActorEntityRepository extends
 CrudRepository<ActorEntity, Integer>, QuerydslPredicateExecutor<ActorEntity> {
}

Graphql资源定义

在resources/graphql下定义接口和实体文件

接口声明和实体定义schema.graphqls

type Query {
 findOneActor(actorId : ID!): ActorEntity
 actorList: [ActorEntity]
}

type ActorEntity {
 actorId: ID!
 firstName: String!
 lastName: String!
 lastUpdate: String
}

接口定义acotrEntity.graphql

query findOneActor($id: ID!) {
 findOneActor(actorId: $id) {
 actorId
 firstName
 lastName
 lastUpdate
 }
}

query actorList {
 actorList{
 actorId
 }
}

启动测试

Spring-Graphql默认不包含可视化界面，此处使用postman进行测试

唯一查询

列表查询

总结

使用Spring官方组件好处在于和Spring生态集成度很高，如果本身就采用Jpa方式进行业务开发，迁移更加方便，需要开发的代码也很少。

样例源码地址

FJiayang/graphql-demo

GraphQL实践1——集成JPA与MySQL

Fri, 05 Nov 2021 17:41:00 +0800

介绍

官方定义：

GraphQL 既是一种用于 API 的查询语言也是一个满足你数据查询的运行时。 GraphQL 对你的 API 中的数据提供了一套易于理解的完整描述，使得客户端能够准确地获得它需要的数据，而且没有任何冗余，也让 API 更容易地随着时间推移而演进，还能用于构建强大的开发者工具。

中文官网：

GraphQL — A query language for your API

集成方案选择

GraphQL经过近几年的发展，SpringBoot官方、第三方都提供了starter

SpringBoot官方提供的starter

Spring GraphQL

第三方提供的starter

graphql-spring-boot

两者活跃度都还不错，但考虑到SpringBoot官方的依赖库还未GA，而且使用起来与Spring家族耦合过大，最终决定采用第三方的starter

集成过程

数据库配置

此处采用MySQL数据库，数据内容采用MySQL官方样例sakila数据，表结构和数据地址如下

sakila database下载地址

导入后如下

工程配置

引入最新的SpringBoot框架，依赖如下

<dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>

 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <optional>true</optional>
 </dependency>

 <!-- https://mvnrepository.com/artifact/com.graphql-java-kickstart/graphql-spring-boot-starter -->
 <dependency>
 <groupId>com.graphql-java-kickstart</groupId>
 <artifactId>graphql-spring-boot-starter</artifactId>
 <version>12.0.0</version>
 </dependency>

 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <scope>runtime</scope>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 </dependency>
</dependencies>

增加数据库配置

spring:
 datasource:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: root
 password: "****"
 url: jdbc:mysql://localhost:3306/sakila?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
 jpa:
 hibernate:
 ddl-auto: update
 show-sql: true
 database-platform: org.hibernate.dialect.MySQL55Dialect
 properties:
 hibernate:
 format_sql: true
 use_sql_comments: true
server:
 port: 8080
graphql:
 tools:
 schema-location-pattern: graphql/*.graphqls
 graphiql:
 # 开启可交互页面，用于调试
 enabled: true

实体映射

新增实体映射，此处只映射Actor表作为样例

package top.fjy8018.graphsqldemo.entity;

import lombok.Data;

import javax.persistence.*;
import java.sql.Timestamp;
import java.util.Objects;

/**
 * 演员表实体映射
 *
 * @author F嘉阳
 * @date 2021/11/5 10:34
 */
@Data
@Entity
@Table(name = "actor", schema = "sakila")
public class ActorEntity {
 @Id
 @Column(name = "actor_id", nullable = false)
 private Integer actorId;

 @Column(name = "first_name", nullable = false, length = 45)
 private String firstName;

 @Column(name = "last_name", nullable = false, length = 45)
 private String lastName;

 @Column(name = "last_update", nullable = false)
 private Timestamp lastUpdate;
}

新增DAO

package top.fjy8018.graphsqldemo.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import top.fjy8018.graphsqldemo.entity.ActorEntity;

/**
 * 演员表DAO
 *
 * @author F嘉阳
 * @date 2021/11/5 10:35
 */
public interface ActorEntityRepository extends JpaRepository<ActorEntity, Integer> {
}

新增查询接口配置

在resources/graphql下新增文件actor.graphqls

type Query {
 actorList: [ActorEntity]
 findOneActor(id : ID!): ActorEntity
}

type ActorEntity {
 actorId: ID!
 firstName: String!
 lastName: String!
 lastUpdate: String
}

新增查询解析器

package top.fjy8018.graphsqldemo.resolver;

import graphql.kickstart.tools.GraphQLQueryResolver;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Component;
import top.fjy8018.graphsqldemo.entity.ActorEntity;
import top.fjy8018.graphsqldemo.repository.ActorEntityRepository;

import java.util.Collection;

/**
 * 演员表GraphQL查询解析器
 *
 * @author F嘉阳
 * @date 2021/11/5 16:27
 */
@Component
@AllArgsConstructor
public class ActorGraphQLQueryResolver implements GraphQLQueryResolver {

 private final ActorEntityRepository actorRepository;

 public Collection<ActorEntity> actorList() {
 return actorRepository.findAll();
 }

 public ActorEntity findOneActor(Integer id) {
 return actorRepository.findById(id).orElse(null);
 }
}

启动验证

启动工程后，浏览器打开http://localhost:8080/graphiql

列表查询

由于采用交互式页面，输入也会有语法提示，比较方便

唯一查询

优缺点分析

优点

接口定义清晰，配置即接口
前端按需获取字段，减少数据传输量
接口整合、演进更加便利

缺点

减少字段个数对后端实现没有变化，并不能提升数据库性能

样例源码地址

FJiayang/graphql-demo

PXC系列学习笔记（六）——Java千万数据量导入和查询优化

Mon, 30 Dec 2019 08:49:04 +0800

一、介绍

通用导入方法：数据量大应当使用load data方式导入，而不是使用source sql文件的方式

此处为了验证PXC集群性能，需要创造一千万条数据进行SQL语句性能测试

二、数据生成

若对数据内容无要求，则可使用通用工具生成随机数据，此处面向具体业务场景，故使用Java应用程序生成数据

1. 创建SpringBoot工程

使用SpringBoot快速创建数据导入工程，引入jdbc和jpa依赖

...
<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.2.2.RELEASE</version>
 <relativePath/> <!-- lookup parent from repository -->
</parent>
...
<dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>

 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <scope>runtime</scope>
 </dependency>
 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <optional>true</optional>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 <exclusions>
 <exclusion>
 <groupId>org.junit.vintage</groupId>
 <artifactId>junit-vintage-engine</artifactId>
 </exclusion>
 </exclusions>
 </dependency>
</dependencies>

2. 编写实体类

package top.fjy8018.jdbcbench;

/**
 * @author F嘉阳
 * @date 2019-12-28 13:08
 */
@Entity(name = "tb_test")
@Data
public class DBTest {

 @Id
 private Integer id;

 private String name;
}

实现JPA接口

package top.fjy8018.jdbcbench;

/**
 * @author F嘉阳
 * @date 2019-12-28 13:09
 */
public interface DBTestRepository extends JpaRepository<DBTest,Integer> {}

3. 配置JDBC连接

此处有个重要配置，就是rewriteBatchedStatements=true，加上该配置，批量写入数据的性能能提升数百倍。

参考资料：jdbcTemplate.batchUpdate在批量执行的时候，性能差没有效果，看看怎么解决的。

spring:
 datasource:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: admin
 password: password
 url: jdbc:mysql://192.168.1.9:13306/test?useSSL=false&useUnicode=true&characterEncoding=UTF-8&rewriteBatchedStatements=true&serverTimezone=Asia/Shanghai
 jpa:
 properties:
 hibernate:
 jdbc:
 batch_size: 10000
 order_inserts: true
 generate_statistics: true

4.准备数据库

每个PXC分片只开启一个节点，导入一个节点中则不会产生限流，导入完成后拷贝数据文件到其他节点再启动即可

修改PXC节点文件，然后重启PXC服务

## 不等待事务提交先写入硬盘
innodb_flush_log_at_trx_commit = 0
## 日志数据直接写入磁盘，不进入日志缓冲区
innodb_flush_method = O_DIRECT
## 缓存越大越好
innodb_buffer_pool_size = 200M

创建t_test数据表

CREATE TABLE tb_test(
	id INT UNSIGNED PRIMARY KEY,
 name VARCHAR(200) NOT NULL
);

配置MyCat

<table name="t_test" dataNode="dn1,dn2" rule="mod-long" />

<?xml version="1.0"?>
<!DOCTYPE mycat:schema SYSTEM "schema.dtd">
<mycat:schema xmlns:mycat="http://io.mycat/">
 <!--配置虚拟逻辑数据表-->
 <schema name="test" checkSQLschema="false" sqlMaxLimit="100">
 <table name="t_user" dataNode="dn1,dn2" rule="mod-long" />
 <table name="tb_test" dataNode="dn1,dn2" rule="mod-long" />
 <table name="t_customer" dataNode="dn1,dn2" rule="sharding-customer">
 <childTable name="t_orders" primaryKey="ID" joinKey="customer_id" parentKey="id"/>
 </table>
 </schema>
 <!--配置分片关系-->
 <dataNode name="dn1" dataHost="cluster1" database="test" />
 <dataNode name="dn2" dataHost="cluster2" database="test" />
 <!--配置连接信息-->
 <dataHost name="cluster1" maxCon="1000" minCon="10" balance="0"
 writeType="0" dbType="mysql" dbDriver="native" switchType="1"
 slaveThreshold="100">
 <heartbeat>select user()</heartbeat>
 <!--多数情况 读多写少-->
 <writeHost host="W1" url="pxc4:3306" user="admin"
 password="admin">
 </writeHost>
 </dataHost>
 <dataHost name="cluster2" maxCon="1000" minCon="10" balance="0"
 writeType="0" dbType="mysql" dbDriver="native" switchType="1"
 slaveThreshold="100">
 <heartbeat>select user()</heartbeat>
 <!--多数情况 读多写少-->
 <writeHost host="W1" url="pxc7:3306" user="admin"
 password="admin">
 </writeHost>
 </dataHost>
</mycat:schema>

5.编写单元测试

package top.fjy8018.jdbcbench;

@Slf4j
@Component
class JdbcBenchTest extends JdbcBenchApplicationTests{

 @Autowired
 private DBTestRepository repository;

 @Autowired
 private JdbcTemplate jdbcTemplate;

 @Test
 public void insertTest(){
 DBTest t = new DBTest();
 t.setId(1);
 t.setName(1+"，测试实体");
 DBTest save = repository.save(t);
 Assert.notNull(save,"保存测试失败");
 }

 @Test
 public void insertData() throws Exception {
 for (int i = 1; i <= 10000000;) {
 List<DBTest> tests = new LinkedList<>();
 for (int j = 1; j <= 50000; j++) {
 DBTest t = new DBTest();
 t.setId(j+i);
 t.setName(j+i+"，测试实体");
 tests.add(t);
 }
 i = i+50000;
 log.info("插入{}条数据",i);
 batchInsert(tests);
 tests.clear();
 }
 }

 @Transactional
 public void batchInsert(List<DBTest> dbTestList) {
 String sql = "insert into tb_test(id,name) values(?,?)";
 log.info("批次大小：{}",dbTestList.size());
 jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
 public void setValues(PreparedStatement ps, int i) throws SQLException {
 String name = dbTestList.get(i).getName();
 int id = dbTestList.get(i).getId();
 ps.setInt(1, id);
 ps.setString(2, name);
 }
 public int getBatchSize() {
 return dbTestList.size();
 }
 });
 }
}

执行单元测试，大约1小时写入完成，不同服务器配置写入性能差距明显，应当以实际为准

三、数据导入后的操作

关闭PXC节点(还原配置文件)
拷贝数据文件到其他PXC节点
关闭 MyCat(还原配置文件)
启动PC和 MyCat

四、大数据性能测试——limit关键字

SELECT id, name FROM tb_test LIMIT 100, 100;
SELECT id, name FROM tb_test LIMIT 10000, 100;
SELECT id, name FROM tb_test LIMIT 1000000, 100;
SELECT id, name From tb_test LIMIT 5000000, 100;

现象：执行最后一条sql语句时速度慢，且cpu和内存占用率极大，主要对mycat节点内存占用一直居高不下

分析索引使用情况，rows字段显示其操作了4746302条数据，走全表扫描

id	select_type	table	partitions	type	possible_keys	key	key_len	ref	rows	filtered	Extra
1	SIMPLE	tb_test		ALL					4746302	100

原因：

全表扫描,速度极慢
limit语句的查询时间与起始记录的位置成正比
mysql limit的语句是很方便,但是对记录很多的表并不适合直接使用

SpringBoot2.x Data JPA 多数据源爬坑

Sat, 30 Mar 2019 10:44:00 +0800

JPA 官方文档

官方文档

5.1.2. Annotation-based Configuration

The Spring Data JPA repositories support can be activated not only through an XML namespace but also by using an annotation through JavaConfig, as shown in the following example:

Example 51. Spring Data JPA repositories using JavaConfig

@Configuration
@EnableJpaRepositories
@EnableTransactionManagement
class ApplicationConfig {

 @Bean
 public DataSource dataSource() {

 EmbeddedDatabaseBuilder builder = new EmbeddedDatabaseBuilder();
 return builder.setType(EmbeddedDatabaseType.HSQL).build();
 }

 @Bean
 public LocalContainerEntityManagerFactoryBean entityManagerFactory() {

 HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
 vendorAdapter.setGenerateDdl(true);

 LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
 factory.setJpaVendorAdapter(vendorAdapter);
 factory.setPackagesToScan("com.acme.domain");
 factory.setDataSource(dataSource());
 return factory;
 }

 @Bean
 public PlatformTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {

 JpaTransactionManager txManager = new JpaTransactionManager();
 txManager.setEntityManagerFactory(entityManagerFactory);
 return txManager;
 }
}

文档中说明，基于注解的配置包含三个关键Bean：

PlatformTransactionManager——事务管理
LocalContainerEntityManagerFactoryBean——实体类管理
DataSource——数据源

同时还有一个关键注解@EnableJpaRepositories

SpringBoot官方文档

官方文档

多数据源使用@Primary指明优先级

You can even go further by leveraging what DataSourceProperties does for you — that is, by providing a default embedded database with a sensible username and password if no URL is provided. You can easily initialize a DataSourceBuilder from the state of any DataSourceProperties object, so you could also inject the DataSource that Spring Boot creates automatically. However, that would split your configuration into two namespaces: url, username, password, type, and driver on spring.datasource and the rest on your custom namespace (app.datasource). To avoid that, you can redefine a custom DataSourceProperties on your custom namespace, as shown in the following example:
@Bean
@Primary
@ConfigurationProperties("app.datasource")
public DataSourceProperties dataSourceProperties() {
	return new DataSourceProperties();
}

@Bean
@ConfigurationProperties("app.datasource.configuration")
public HikariDataSource dataSource(DataSourceProperties properties) {
	return properties.initializeDataSourceBuilder().type(HikariDataSource.class)
			.build();
}
84.2 Configure Two DataSources
If you need to configure multiple data sources, you can apply the same tricks that are described in the previous section. You must, however, mark one of the DataSource instances as @Primary, because various auto-configurations down the road expect to be able to get one by type.

If you create your own DataSource, the auto-configuration backs off. In the following example, we provide the exact same feature set as the auto-configuration provides on the primary data source:
@Bean
@Primary
@ConfigurationProperties("app.datasource.first")
public DataSourceProperties firstDataSourceProperties() {
	return new DataSourceProperties();
}

@Bean
@Primary
@ConfigurationProperties("app.datasource.first.configuration")
public HikariDataSource firstDataSource() {
	return firstDataSourceProperties().initializeDataSourceBuilder()
			.type(HikariDataSource.class).build();
}

@Bean
@ConfigurationProperties("app.datasource.second")
public BasicDataSource secondDataSource() {
	return DataSourceBuilder.create().type(BasicDataSource.class).build();
}

或者使用两个EntityManagers，并结合@EnableJpaRepositories进行配置

84.10 Use Two EntityManagers
Even if the default EntityManagerFactory works fine, you need to define a new one. Otherwise, the presence of the second bean of that type switches off the default. To make it easy to do, you can use the convenient EntityManagerBuilder provided by Spring Boot. Alternatively, you can just theLocalContainerEntityManagerFactoryBean directly from Spring ORM, as shown in the following example:
// add two data sources configured as above

@Bean
public LocalContainerEntityManagerFactoryBean customerEntityManagerFactory(
		EntityManagerFactoryBuilder builder) {
	return builder
			.dataSource(customerDataSource())
			.packages(Customer.class)
			.persistenceUnit("customers")
			.build();
}

@Bean
public LocalContainerEntityManagerFactoryBean orderEntityManagerFactory(
		EntityManagerFactoryBuilder builder) {
	return builder
			.dataSource(orderDataSource())
			.packages(Order.class)
			.persistenceUnit("orders")
			.build();
}
The configuration above almost works on its own. To complete the picture, you need to configure TransactionManagers for the two EntityManagers as well. If you mark one of them as @Primary, it could be picked up by the default JpaTransactionManager in Spring Boot. The other would have to be explicitly injected into a new instance. Alternatively, you might be able to use a JTA transaction manager that spans both.

If you use Spring Data, you need to configure @EnableJpaRepositories accordingly, as shown in the following example:
@Configuration
@EnableJpaRepositories(basePackageClasses = Customer.class,
		entityManagerFactoryRef = "customerEntityManagerFactory")
public class CustomerConfiguration {
	...
}

@Configuration
@EnableJpaRepositories(basePackageClasses = Order.class,
		entityManagerFactoryRef = "orderEntityManagerFactory")
public class OrderConfiguration {
	...
}

源码分析

自动装配类中声明了配置Bean和条件装配顺序

package org.springframework.boot.autoconfigure.data.jpa;

/**
 * {@link EnableAutoConfiguration Auto-configuration} for Spring Data's JPA Repositories.
 * <p>
 * Activates when there is a bean of type {@link javax.sql.DataSource} configured in the
 * context, the Spring Data JPA
 * {@link org.springframework.data.jpa.repository.JpaRepository} type is on the classpath,
 * and there is no other, existing
 * {@link org.springframework.data.jpa.repository.JpaRepository} configured.
 * <p>
 * Once in effect, the auto-configuration is the equivalent of enabling JPA repositories
 * using the {@link org.springframework.data.jpa.repository.config.EnableJpaRepositories}
 * annotation.
 * <p>
 * This configuration class will activate <em>after</em> the Hibernate auto-configuration.
 *
 * @author Phillip Webb
 * @author Josh Long
 * @see EnableJpaRepositories
 */
@Configuration
@ConditionalOnBean(DataSource.class)
@ConditionalOnClass(JpaRepository.class)
@ConditionalOnMissingBean({ JpaRepositoryFactoryBean.class,
		JpaRepositoryConfigExtension.class })
@ConditionalOnProperty(prefix = "spring.data.jpa.repositories", name = "enabled", havingValue = "true", matchIfMissing = true)
@Import(JpaRepositoriesAutoConfigureRegistrar.class)
@AutoConfigureAfter({ HibernateJpaAutoConfiguration.class,
		TaskExecutionAutoConfiguration.class })
public class JpaRepositoriesAutoConfiguration {

	@Bean
	@Conditional(BootstrapExecutorCondition.class)
	public EntityManagerFactoryBuilderCustomizer entityManagerFactoryBootstrapExecutorCustomizer(
			Map<String, AsyncTaskExecutor> taskExecutors) {
		return (builder) -> {
			AsyncTaskExecutor bootstrapExecutor = determineBootstrapExecutor(
					taskExecutors);
			if (bootstrapExecutor != null) {
				builder.setBootstrapExecutor(bootstrapExecutor);
			}
		};
	}

	private AsyncTaskExecutor determineBootstrapExecutor(
			Map<String, AsyncTaskExecutor> taskExecutors) {
		if (taskExecutors.size() == 1) {
			return taskExecutors.values().iterator().next();
		}
		return taskExecutors
				.get(TaskExecutionAutoConfiguration.APPLICATION_TASK_EXECUTOR_BEAN_NAME);
	}

	private static final class BootstrapExecutorCondition extends AnyNestedCondition {

		BootstrapExecutorCondition() {
			super(ConfigurationPhase.REGISTER_BEAN);
		}

		@ConditionalOnProperty(prefix = "spring.data.jpa.repositories", name = "bootstrap-mode", havingValue = "deferred", matchIfMissing = false)
		static class DeferredBootstrapMode {

		}

		@ConditionalOnProperty(prefix = "spring.data.jpa.repositories", name = "bootstrap-mode", havingValue = "lazy", matchIfMissing = false)
		static class LazyBootstrapMode {

		}

	}
}

引入的配置类中声明了EnableJpaRepositories注解

package org.springframework.boot.autoconfigure.data.jpa;

class JpaRepositoriesAutoConfigureRegistrar
		extends AbstractRepositoryConfigurationSourceSupport {

	private BootstrapMode bootstrapMode = null;

	@Override
	protected Class<? extends Annotation> getAnnotation() {
		return EnableJpaRepositories.class;
	}

	@Override
	protected Class<?> getConfiguration() {
		return EnableJpaRepositoriesConfiguration.class;
	}

	@Override
	protected RepositoryConfigurationExtension getRepositoryConfigurationExtension() {
		return new JpaRepositoryConfigExtension();
	}

	@Override
	protected BootstrapMode getBootstrapMode() {
		return (this.bootstrapMode == null) ? super.getBootstrapMode()
				: this.bootstrapMode;
	}

	@Override
	public void setEnvironment(Environment environment) {
		super.setEnvironment(environment);
		configureBootstrapMode(environment);
	}

	private void configureBootstrapMode(Environment environment) {
		String property = environment
				.getProperty("spring.data.jpa.repositories.bootstrap-mode");
		if (StringUtils.hasText(property)) {
			this.bootstrapMode = BootstrapMode
					.valueOf(property.toUpperCase(Locale.ENGLISH));
		}
	}
 
	@EnableJpaRepositories
	private static class EnableJpaRepositoriesConfiguration {}
}

EnableJpaRepositories注解定义

package org.springframework.data.jpa.repository.config;

/**
 * Annotation to enable JPA repositories. Will scan the package of the annotated configuration class for Spring Data
 * repositories by default.
 *
 * @author Oliver Gierke
 * @author Thomas Darimont
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(JpaRepositoriesRegistrar.class)
public @interface EnableJpaRepositories {

	String[] value() default {};

	String[] basePackages() default {};

	Class<?>[] basePackageClasses() default {};

	Filter[] includeFilters() default {};

	Filter[] excludeFilters() default {};

	String repositoryImplementationPostfix() default "Impl";

	String namedQueriesLocation() default "";

	Key queryLookupStrategy() default Key.CREATE_IF_NOT_FOUND;

	Class<?> repositoryFactoryBeanClass() default JpaRepositoryFactoryBean.class;

	Class<?> repositoryBaseClass() default DefaultRepositoryBaseClass.class;

	/**
	 * 实体管理工厂
	 * @return
	 */
	String entityManagerFactoryRef() default "entityManagerFactory";

	/**
	 * 事务管理
	 * @return
	 */
	String transactionManagerRef() default "transactionManager";

	boolean considerNestedRepositories() default false;

	boolean enableDefaultTransactions() default true;

	/**
	 * Configures when the repositories are initialized in the bootstrap lifecycle. {@link BootstrapMode#DEFAULT}
	 * (default) means eager initialization except all repository interfaces annotated with {@link Lazy},
	 * {@link BootstrapMode#LAZY} means lazy by default including injection of lazy-initialization proxies into client
	 * beans so that those can be instantiated but will only trigger the initialization upon first repository usage (i.e a
	 * method invocation on it). This means repositories can still be uninitialized when the application context has
	 * completed its bootstrap. {@link BootstrapMode#DEFERRED} is fundamentally the same as {@link BootstrapMode#LAZY},
	 * but triggers repository initialization when the application context finishes its bootstrap.
	 * 
	 * @return
	 * @since 2.1
	 */
	BootstrapMode bootstrapMode() default BootstrapMode.DEFAULT;
}

查找关键Bean的注册时机

package org.springframework.boot.autoconfigure.orm.jpa;

@Configuration
@ConditionalOnClass({ LocalContainerEntityManagerFactoryBean.class, EntityManager.class })
@Conditional(HibernateEntityManagerCondition.class)
@EnableConfigurationProperties(JpaProperties.class)
@AutoConfigureAfter({ DataSourceAutoConfiguration.class })
@Import(HibernateJpaConfiguration.class)
public class HibernateJpaAutoConfiguration {}

进入配置Bean

package org.springframework.boot.autoconfigure.orm.jpa;

@Configuration
@EnableConfigurationProperties(HibernateProperties.class)
@ConditionalOnSingleCandidate(DataSource.class)
class HibernateJpaConfiguration extends JpaBaseConfiguration {}

在其父类JpaBaseConfiguration中声明了装配时机和条件

package org.springframework.boot.autoconfigure.orm.jpa;

/**
 * 该类在2.0版本进行了重构
 * @since 2.0.0
 */
@Configuration
@EnableConfigurationProperties(JpaProperties.class)
@Import(DataSourceInitializedPublisher.Registrar.class)
public abstract class JpaBaseConfiguration implements BeanFactoryAware {
 
 @Bean
	@ConditionalOnMissingBean
	public PlatformTransactionManager transactionManager() {
		JpaTransactionManager transactionManager = new JpaTransactionManager();
		if (this.transactionManagerCustomizers != null) {
 // 默认使用方法名称
			this.transactionManagerCustomizers.customize(transactionManager);
		}
		return transactionManager;
	}

	@Bean
	@ConditionalOnMissingBean
	public JpaVendorAdapter jpaVendorAdapter() {
		AbstractJpaVendorAdapter adapter = createJpaVendorAdapter();
		adapter.setShowSql(this.properties.isShowSql());
		adapter.setDatabase(this.properties.determineDatabase(this.dataSource));
		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;
	}

	@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();
	}
}

测试

爬完文档和源码，对需要配置Bean有了基本了解，新建工程进行多数据源测试

以当前最新版本SpringBoot进行测试

maven

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.1.3.RELEASE</version>
 <relativePath/> <!-- lookup parent from repository -->
 </parent>
 <groupId>top.fjy8018</groupId>
 <artifactId>jpadatasource</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <name>jpadatasource</name>
 <description>Demo project for Spring Boot</description>

 <properties>
 <java.version>1.8</java.version>
 </properties>

 <dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>

 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <scope>runtime</scope>
 </dependency>

 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 </dependency>

 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 </dependency>
 </dependencies>

 <build>
 <plugins>
 <plugin>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-maven-plugin</artifactId>
 </plugin>
 </plugins>
 </build>

</project>

实体类

通过包路径区分主库和备份库

主库实体类

package top.fjy8018.jpadatasource.entity.primary;

import lombok.Data;

import javax.persistence.Entity;
import javax.persistence.Id;

/**
 * @author F嘉阳
 * @date 2019-03-30 9:11
 */
@Data
@Entity
public class Product {

 @Id
 private Integer id;

 private String name;

 private Integer price;
}

备份库实体类

package top.fjy8018.jpadatasource.entity.backup;

import lombok.Data;

import javax.persistence.Entity;
import javax.persistence.Id;

/**
 * @author F嘉阳
 * @date 2019-03-30 9:36
 */
@Data
@Entity(name = "tb_order")
public class Order {

 @Id
 private Integer id;

 private String orderName;

 private Integer price;
}

坑一：表名关键字冲突

若此处不指定表名为tb_order则会与MySQL关键字冲突导致建表失败

报错：

org.hibernate.tool.schema.spi.CommandAcceptanceException: Error executing DDL "
 create table Order (
 id integer not null,
 orderName varchar(255),
 price integer,
 primary key (id)
 ) engine=InnoDB" via JDBC Statement
 ...

DAO

package top.fjy8018.jpadatasource.repository.backup;

import org.springframework.data.jpa.repository.JpaRepository;
import top.fjy8018.jpadatasource.entity.backup.Order;

/**
 * @author F嘉阳
 * @date 2019-03-30 9:12
 */
public interface OrderRepository extends JpaRepository<Order, Integer> {
}

package top.fjy8018.jpadatasource.repository.primary;

import org.springframework.data.jpa.repository.JpaRepository;
import top.fjy8018.jpadatasource.entity.primary.Product;

/**
 * @author F嘉阳
 * @date 2019-03-30 9:12
 */
public interface ProductRepository extends JpaRepository<Product, Integer> {
}

配置Bean

官方配置样例：

Both data sources are also bound for advanced customizations. For instance, you could configure them as follows:

app.datasource.first.url=jdbc:mysql://localhost/first
app.datasource.first.username=dbuser
app.datasource.first.password=dbpass
app.datasource.first.configuration.maximum-pool-size=30

app.datasource.second.url=jdbc:mysql://localhost/second
app.datasource.second.username=dbuser
app.datasource.second.password=dbpass
app.datasource.second.max-total=30

You can apply the same concept to the secondary DataSource as well, as shown in the following example:

@Bean
@Primary
@ConfigurationProperties("app.datasource.first")
public DataSourceProperties firstDataSourceProperties() {
	return new DataSourceProperties();
}

@Bean
@Primary
@ConfigurationProperties("app.datasource.first.configuration")
public HikariDataSource firstDataSource() {
	return firstDataSourceProperties().initializeDataSourceBuilder()
			.type(HikariDataSource.class).build();
}

@Bean
@ConfigurationProperties("app.datasource.second")
public DataSourceProperties secondDataSourceProperties() {
	return new DataSourceProperties();
}

@Bean
@ConfigurationProperties("app.datasource.second.configuration")
public BasicDataSource secondDataSource() {
	return secondDataSourceProperties().initializeDataSourceBuilder()
			.type(BasicDataSource.class).build();
}

The preceding example configures two data sources on custom namespaces with the same logic as Spring Boot would use in auto-configuration. Note that each configuration sub namespace provides advanced settings based on the chosen implementation.

参照编写配置文件，此处注意SpringBoot 2.x的驱动变化

坑二：mysql驱动类名变化

spring:
 datasource:
 first:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: financial_adminer
 password: financial_adminer_pass
 url: jdbc:mysql://localhost/jpa_test?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
 configuration:
 maximum-pool-size: 30
 second:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: financial_adminer
 password: financial_adminer_pass
 url: jdbc:mysql://localhost/jpa_test_bak?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
 configuration:
 maximum-pool-size: 20

 jpa:
 hibernate:
 ddl-auto: update
 show-sql: true
 database-platform: org.hibernate.dialect.MySQL55Dialect
 properties:
 hibernate:
 format_sql: true
 use_sql_comments: true

配置类

package top.fjy8018.jpadatasource.config;

import com.zaxxer.hikari.HikariDataSource;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

/**
 * @author F嘉阳
 * @date 2019-03-30 9:24
 */
@Configuration
public class DataAccessConfig {
 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.first")
 public DataSourceProperties firstDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.first.configuration")
 public HikariDataSource firstDataSource() {
 return firstDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }

 @Bean
 @ConfigurationProperties("spring.datasource.second")
 public DataSourceProperties secondDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @ConfigurationProperties("spring.datasource.second.configuration")
 public HikariDataSource secondDataSource() {
 return secondDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }
}

配置完成后发现只在主库自动建表，备份库无变化，属于预期情况，因为目前仅配置了三个必须Bean的其中一个

继续配置实体管理和事务管理Bean

官方文档样例

84.10 Use Two EntityManagers
Even if the default EntityManagerFactory works fine, you need to define a new one. Otherwise, the presence of the second bean of that type switches off the default. To make it easy to do, you can use the convenient EntityManagerBuilder provided by Spring Boot. Alternatively, you can just theLocalContainerEntityManagerFactoryBean directly from Spring ORM, as shown in the following example:
// add two data sources configured as above

@Bean
public LocalContainerEntityManagerFactoryBean customerEntityManagerFactory(
		EntityManagerFactoryBuilder builder) {
	return builder
			.dataSource(customerDataSource())
			.packages(Customer.class)
			.persistenceUnit("customers")
			.build();
}

@Bean
public LocalContainerEntityManagerFactoryBean orderEntityManagerFactory(
		EntityManagerFactoryBuilder builder) {
	return builder
			.dataSource(orderDataSource())
			.packages(Order.class)
			.persistenceUnit("orders")
			.build();
}
The configuration above almost works on its own. To complete the picture, you need to configure TransactionManagers for the two EntityManagers as well. If you mark one of them as @Primary, it could be picked up by the default JpaTransactionManager in Spring Boot. The other would have to be explicitly injected into a new instance. Alternatively, you might be able to use a JTA transaction manager that spans both.

If you use Spring Data, you need to configure @EnableJpaRepositories accordingly, as shown in the following example:
@Configuration
@EnableJpaRepositories(basePackageClasses = Customer.class,
		entityManagerFactoryRef = "customerEntityManagerFactory")
public class CustomerConfiguration {
	...
}

@Configuration
@EnableJpaRepositories(basePackageClasses = Order.class,
		entityManagerFactoryRef = "orderEntityManagerFactory")
public class OrderConfiguration {
	...
}

工程配置

package top.fjy8018.jpadatasource.config;

import com.zaxxer.hikari.HikariDataSource;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import top.fjy8018.jpadatasource.entity.backup.Order;
import top.fjy8018.jpadatasource.entity.primary.Product;
import top.fjy8018.jpadatasource.repository.backup.OrderRepository;
import top.fjy8018.jpadatasource.repository.primary.ProductRepository;

import javax.sql.DataSource;

/**
 * @author F嘉阳
 * @date 2019-03-30 9:24
 */
@Configuration
public class DataAccessConfig {
 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.first")
 public DataSourceProperties firstDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.first.configuration")
 public HikariDataSource firstDataSource() {
 return firstDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }

 @Bean
 @ConfigurationProperties("spring.datasource.second")
 public DataSourceProperties secondDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @ConfigurationProperties("spring.datasource.second.configuration")
 public HikariDataSource secondDataSource() {
 return secondDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }

 @Bean
 public LocalContainerEntityManagerFactoryBean firstEntityManagerFactory(
 EntityManagerFactoryBuilder builder, @Qualifier("firstDataSource") DataSource dataSource) {
 return builder
 .dataSource(dataSource)
 .packages(Product.class)
 .persistenceUnit("first")
 .build();
 }

 @Bean
 public LocalContainerEntityManagerFactoryBean secondEntityManagerFactory(
 EntityManagerFactoryBuilder builder, @Qualifier("secondDataSource") DataSource dataSource) {
 return builder
 .dataSource(dataSource)
 .packages(Order.class)
 .persistenceUnit("second")
 .build();
 }

 @Bean
 public PlatformTransactionManager primaryTransactionManager(
 @Qualifier("firstEntityManagerFactory") LocalContainerEntityManagerFactoryBean entityManagerFactory) {
 return new JpaTransactionManager(entityManagerFactory.getObject());
 }

 @Bean
 public PlatformTransactionManager backupTransactionManager(
 @Qualifier("secondEntityManagerFactory") LocalContainerEntityManagerFactoryBean entityManagerFactory) {
 return new JpaTransactionManager(entityManagerFactory.getObject());
 }

 @EnableJpaRepositories(basePackageClasses = ProductRepository.class,
 entityManagerFactoryRef = "firstEntityManagerFactory")
 @Primary
 public class PrimaryConfiguration {
 }

 @EnableJpaRepositories(basePackageClasses = OrderRepository.class,
 entityManagerFactoryRef = "secondEntityManagerFactory")
 public class secondConfiguration {
 }
}

坑三：官方文档样例有误

此时配置直接启动会报错

Method requestMappingHandlerMapping in org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration$EnableWebMvcConfiguration required a single bean, but 2 were found:
	- firstEntityManagerFactory: defined by method 'firstEntityManagerFactory' in class path resource [top/fjy8018/jpadatasource/config/DataAccessConfig.class]
	- secondEntityManagerFactory: defined by method 'secondEntityManagerFactory' in class path resource [top/fjy8018/jpadatasource/config/DataAccessConfig.class]


Action:

Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed

意思是自动装配时发现两个类型一致的Bean，主要指定优先级，而官方文档对此处可能出现的问题并未提示

指定firstEntityManagerFactory为优先Bean，同时文档样例创建了事务管理器但未配置到@EnableJpaRepositories注解中，此处也一并配置

最终配置类如下

package top.fjy8018.jpadatasource.config;

import com.zaxxer.hikari.HikariDataSource;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import top.fjy8018.jpadatasource.entity.backup.Order;
import top.fjy8018.jpadatasource.entity.primary.Product;
import top.fjy8018.jpadatasource.repository.backup.OrderRepository;
import top.fjy8018.jpadatasource.repository.primary.ProductRepository;

import javax.sql.DataSource;

/**
 * @author F嘉阳
 * @date 2019-03-30 9:24
 */
@Configuration
public class DataAccessConfig {
 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.first")
 public DataSourceProperties firstDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.first.configuration")
 public HikariDataSource firstDataSource() {
 return firstDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }

 @Bean
 @ConfigurationProperties("spring.datasource.second")
 public DataSourceProperties secondDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @ConfigurationProperties("spring.datasource.second.configuration")
 public HikariDataSource secondDataSource() {
 return secondDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }

 @Bean
 public LocalContainerEntityManagerFactoryBean firstEntityManagerFactory(
 EntityManagerFactoryBuilder builder, @Qualifier("firstDataSource") DataSource dataSource) {
 return builder
 .dataSource(dataSource)
 .packages(Product.class)
 .persistenceUnit("first")
 .build();
 }

 @Bean
 public LocalContainerEntityManagerFactoryBean secondEntityManagerFactory(
 EntityManagerFactoryBuilder builder, @Qualifier("secondDataSource") DataSource dataSource) {
 return builder
 .dataSource(dataSource)
 .packages(Order.class)
 .persistenceUnit("second")
 .build();
 }

 @Bean
 public PlatformTransactionManager primaryTransactionManager(
 @Qualifier("firstEntityManagerFactory") LocalContainerEntityManagerFactoryBean entityManagerFactory) {
 return new JpaTransactionManager(entityManagerFactory.getObject());
 }

 @Bean
 public PlatformTransactionManager backupTransactionManager(
 @Qualifier("secondEntityManagerFactory") LocalContainerEntityManagerFactoryBean entityManagerFactory) {
 return new JpaTransactionManager(entityManagerFactory.getObject());
 }

 @EnableJpaRepositories(basePackageClasses = ProductRepository.class,
 entityManagerFactoryRef = "firstEntityManagerFactory", transactionManagerRef = "primaryTransactionManager")
 @Primary
 public class PrimaryConfiguration {
 }

 @EnableJpaRepositories(basePackageClasses = OrderRepository.class,
 entityManagerFactoryRef = "secondEntityManagerFactory", transactionManagerRef = "backupTransactionManager")
 public class secondConfiguration {
 }
}

坑四：JPA不会自动建表

配置完成后启动

发现日志中建表SQL没有输出，同时查看数据库，确认表未创建

但官方文档对多数据源的配置说明已经结束，令人疑惑

自动建表语句没生成猜想可能由于与ddl相关的属性未配置导致

进入配置文件查看ddl配置，发现默认为false

将其配置为true后总配置文件如下

spring:
 datasource:
 first:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: financial_adminer
 password: financial_adminer_pass
 url: jdbc:mysql://120.79.226.26/jpa_test?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
 configuration:
 maximum-pool-size: 30
 second:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: financial_adminer
 password: financial_adminer_pass
 url: jdbc:mysql://120.79.226.26/jpa_test_bak?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
 configuration:
 maximum-pool-size: 20

 jpa:
 hibernate:
 ddl-auto: update
 show-sql: true
 database-platform: org.hibernate.dialect.MySQL55Dialect
 properties:
 hibernate:
 format_sql: true
 use_sql_comments: true
 generate-ddl: true

启动工程发现自动建表生效

查看数据库情况，与预期一致，主库只包含主库的表，备份库只包含备份库的表，多数据配置完成

坑五：hibernate默认配置被覆盖

若在单数据源配置下应当无需配置该项，同时发现本应该默认将驼峰属性名映射为_拼接名称策略也失效，说明自定义配置源时覆盖了默认配置或者导致默认配置失效

查询源码分析原因，发现hibernate相关配置均在HibernateProperties配置类中

package org.springframework.boot.autoconfigure.orm.jpa;

/**
 * Configuration properties for Hibernate.
 *
 * @author Stephane Nicoll
 * @since 2.1.0
 * @see JpaProperties
 */
@ConfigurationProperties("spring.jpa.hibernate")
public class HibernateProperties {}

而该类在HibernateJpaConfiguration中进行注入，但配置类中进行了条件装配注解@ConditionalOnSingleCandidate标注，导致在多数据源情况下不满足该配置，类没有被装配到Spring Bean中

package org.springframework.boot.autoconfigure.orm.jpa;

/**
 * {@link JpaBaseConfiguration} implementation for Hibernate.
 * @since 2.0.0
 */
@Configuration
@EnableConfigurationProperties(HibernateProperties.class)
@ConditionalOnSingleCandidate(DataSource.class)
class HibernateJpaConfiguration extends JpaBaseConfiguration {

	private final HibernateProperties hibernateProperties;

	HibernateJpaConfiguration(DataSource dataSource, JpaProperties jpaProperties,
			ConfigurableListableBeanFactory beanFactory,
			ObjectProvider<JtaTransactionManager> jtaTransactionManager,
			ObjectProvider<TransactionManagerCustomizers> transactionManagerCustomizers,
			HibernateProperties hibernateProperties,
			ObjectProvider<Collection<DataSourcePoolMetadataProvider>> metadataProviders,
			ObjectProvider<SchemaManagementProvider> providers,
			ObjectProvider<PhysicalNamingStrategy> physicalNamingStrategy,
			ObjectProvider<ImplicitNamingStrategy> implicitNamingStrategy,
			ObjectProvider<HibernatePropertiesCustomizer> hibernatePropertiesCustomizers) {
		super(dataSource, jpaProperties, jtaTransactionManager,
				transactionManagerCustomizers);
		this.hibernateProperties = hibernateProperties;
		this.defaultDdlAutoProvider = new HibernateDefaultDdlAutoProvider(providers);
		this.poolMetadataProvider = new CompositeDataSourcePoolMetadataProvider(
				metadataProviders.getIfAvailable());
		this.hibernatePropertiesCustomizers = determineHibernatePropertiesCustomizers(
				physicalNamingStrategy.getIfAvailable(),
				implicitNamingStrategy.getIfAvailable(), beanFactory,
				hibernatePropertiesCustomizers.orderedStream()
						.collect(Collectors.toList()));
	}
 ...
}

解决方法就只能自己工程内实现该类的配置，注意，Spring 2.x版本自动装配变化较大，当前配置基于最新版2.1.3有效，并不代表对后续版本一定兼容

工程配置

package top.fjy8018.jpadatasource.config;

import com.zaxxer.hikari.HikariDataSource;
import org.hibernate.boot.model.naming.ImplicitNamingStrategy;
import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
import org.hibernate.cfg.AvailableSettings;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties;
import org.springframework.boot.autoconfigure.orm.jpa.HibernatePropertiesCustomizer;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.EmbeddedDatabaseConnection;
import org.springframework.boot.jdbc.SchemaManagement;
import org.springframework.boot.jdbc.SchemaManagementProvider;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.hibernate5.SpringBeanContainer;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.util.ClassUtils;
import top.fjy8018.jpadatasource.entity.backup.Order;
import top.fjy8018.jpadatasource.entity.primary.Product;
import top.fjy8018.jpadatasource.repository.backup.OrderRepository;
import top.fjy8018.jpadatasource.repository.primary.ProductRepository;

import javax.sql.DataSource;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;

/**
 * @author F嘉阳
 * @date 2019-03-30 9:24
 */
@Configuration
public class DataAccessConfig {

 private final ObjectProvider<SchemaManagementProvider> providers;

 private final HibernateProperties hibernateProperties;

 private final JpaProperties properties;

 private final ObjectProvider<PhysicalNamingStrategy> physicalNamingStrategy;

 private final ObjectProvider<ImplicitNamingStrategy> implicitNamingStrategy;

 private final ConfigurableListableBeanFactory beanFactory;

 private final ObjectProvider<HibernatePropertiesCustomizer> hibernatePropertiesCustomizers;

 @Autowired
 public DataAccessConfig(ObjectProvider<SchemaManagementProvider> providers, HibernateProperties hibernateProperties, JpaProperties properties, ObjectProvider<PhysicalNamingStrategy> physicalNamingStrategy, ObjectProvider<ImplicitNamingStrategy> implicitNamingStrategy, ConfigurableListableBeanFactory beanFactory, ObjectProvider<HibernatePropertiesCustomizer> hibernatePropertiesCustomizers) {
 this.providers = providers;
 this.hibernateProperties = hibernateProperties;
 this.properties = properties;
 this.physicalNamingStrategy = physicalNamingStrategy;
 this.implicitNamingStrategy = implicitNamingStrategy;
 this.beanFactory = beanFactory;
 this.hibernatePropertiesCustomizers = hibernatePropertiesCustomizers;
 }

 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.first")
 public DataSourceProperties firstDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @Primary
 @ConfigurationProperties("spring.datasource.first.configuration")
 public HikariDataSource firstDataSource() {
 return firstDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }

 @Bean
 @ConfigurationProperties("spring.datasource.second")
 public DataSourceProperties secondDataSourceProperties() {
 return new DataSourceProperties();
 }

 @Bean
 @ConfigurationProperties("spring.datasource.second.configuration")
 public HikariDataSource secondDataSource() {
 return secondDataSourceProperties().initializeDataSourceBuilder()
 .type(HikariDataSource.class).build();
 }

 @Bean
 @Primary
 public LocalContainerEntityManagerFactoryBean firstEntityManagerFactory(
 EntityManagerFactoryBuilder builder, @Qualifier("firstDataSource") DataSource dataSource) {
 return builder
 .dataSource(dataSource)
 // 加入规约配置
 .properties(getVendorProperties(dataSource))
 .packages(Product.class)
 .persistenceUnit("first")
 .build();
 }

 @Bean
 public LocalContainerEntityManagerFactoryBean secondEntityManagerFactory(
 EntityManagerFactoryBuilder builder, @Qualifier("secondDataSource") DataSource dataSource) {
 return builder
 .dataSource(dataSource)
 .properties(getVendorProperties(dataSource))
 .packages(Order.class)
 .persistenceUnit("second")
 .build();
 }

 @Bean
 public PlatformTransactionManager primaryTransactionManager(
 @Qualifier("firstEntityManagerFactory") LocalContainerEntityManagerFactoryBean entityManagerFactory) {
 return new JpaTransactionManager(entityManagerFactory.getObject());
 }

 @Bean
 public PlatformTransactionManager backupTransactionManager(
 @Qualifier("secondEntityManagerFactory") LocalContainerEntityManagerFactoryBean entityManagerFactory) {
 return new JpaTransactionManager(entityManagerFactory.getObject());
 }

 @EnableJpaRepositories(basePackageClasses = ProductRepository.class,
 entityManagerFactoryRef = "firstEntityManagerFactory", transactionManagerRef = "primaryTransactionManager")
 @Primary
 public class PrimaryConfiguration {
 }

 @EnableJpaRepositories(basePackageClasses = OrderRepository.class,
 entityManagerFactoryRef = "secondEntityManagerFactory", transactionManagerRef = "backupTransactionManager")
 public class secondConfiguration {
 }

 /**
 * 获取配置文件信息
 *
 * @param dataSource
 * @return
 */
 private Map<String, Object> getVendorProperties(DataSource dataSource) {
 List<HibernatePropertiesCustomizer> hibernatePropertiesCustomizers = determineHibernatePropertiesCustomizers(
 physicalNamingStrategy.getIfAvailable(),
 implicitNamingStrategy.getIfAvailable(), beanFactory,
 this.hibernatePropertiesCustomizers.orderedStream()
 .collect(Collectors.toList()));
 Supplier<String> defaultDdlMode = () -> new HibernateDefaultDdlAutoProvider(providers)
 .getDefaultDdlAuto(dataSource);
 return new LinkedHashMap<>(this.hibernateProperties.determineHibernateProperties(
 properties.getProperties(),
 new HibernateSettings().ddlAuto(defaultDdlMode)
 .hibernatePropertiesCustomizers(
 hibernatePropertiesCustomizers)));
 }

 /**
 * 命名策略自动判断
 *
 * @param physicalNamingStrategy
 * @param implicitNamingStrategy
 * @param beanFactory
 * @param hibernatePropertiesCustomizers
 * @return
 */
 private List<HibernatePropertiesCustomizer> determineHibernatePropertiesCustomizers(
 PhysicalNamingStrategy physicalNamingStrategy,
 ImplicitNamingStrategy implicitNamingStrategy,
 ConfigurableListableBeanFactory beanFactory,
 List<HibernatePropertiesCustomizer> hibernatePropertiesCustomizers) {
 List<HibernatePropertiesCustomizer> customizers = new ArrayList<>();
 if (ClassUtils.isPresent(
 "org.hibernate.resource.beans.container.spi.BeanContainer",
 getClass().getClassLoader())) {
 customizers
 .add((properties) -> properties.put(AvailableSettings.BEAN_CONTAINER,
 new SpringBeanContainer(beanFactory)));
 }
 if (physicalNamingStrategy != null || implicitNamingStrategy != null) {
 customizers.add(new NamingStrategiesHibernatePropertiesCustomizer(
 physicalNamingStrategy, implicitNamingStrategy));
 }
 customizers.addAll(hibernatePropertiesCustomizers);
 return customizers;
 }

 /**
 * 自动进行建表操作
 */
 class HibernateDefaultDdlAutoProvider implements SchemaManagementProvider {

 private final Iterable<SchemaManagementProvider> providers;

 HibernateDefaultDdlAutoProvider(Iterable<SchemaManagementProvider> providers) {
 this.providers = providers;
 }

 public String getDefaultDdlAuto(DataSource dataSource) {
 if (!EmbeddedDatabaseConnection.isEmbedded(dataSource)) {
 return "none";
 }
 SchemaManagement schemaManagement = getSchemaManagement(dataSource);
 if (SchemaManagement.MANAGED.equals(schemaManagement)) {
 return "none";
 }
 return "create-drop";

 }

 @Override
 public SchemaManagement getSchemaManagement(DataSource dataSource) {
 return StreamSupport.stream(this.providers.spliterator(), false)
 .map((provider) -> provider.getSchemaManagement(dataSource))
 .filter(SchemaManagement.MANAGED::equals).findFirst()
 .orElse(SchemaManagement.UNMANAGED);
 }

 }

 private static class NamingStrategiesHibernatePropertiesCustomizer
 implements HibernatePropertiesCustomizer {

 private final PhysicalNamingStrategy physicalNamingStrategy;

 private final ImplicitNamingStrategy implicitNamingStrategy;

 NamingStrategiesHibernatePropertiesCustomizer(
 PhysicalNamingStrategy physicalNamingStrategy,
 ImplicitNamingStrategy implicitNamingStrategy) {
 this.physicalNamingStrategy = physicalNamingStrategy;
 this.implicitNamingStrategy = implicitNamingStrategy;
 }

 /**
 * 数据库命名映射策略
 *
 * @param hibernateProperties the JPA vendor properties to customize
 */
 @Override
 public void customize(Map<String, Object> hibernateProperties) {
 if (this.physicalNamingStrategy != null) {
 hibernateProperties.put("hibernate.physical_naming_strategy",
 this.physicalNamingStrategy);
 }
 if (this.implicitNamingStrategy != null) {
 hibernateProperties.put("hibernate.implicit_naming_strategy",
 this.implicitNamingStrategy);
 }
 }
 }
}

配置Bean完成后则规约配置会生效，便无需在配置文件显示配置DDL语句执行开关

启动日志也可看出结果符合预期

总结

由此发现，在SpringBoot版本迁移过程中不一定互相兼容，同时官方文档尽管全面，但随着版本变化文档也有不准确情况。而如果完全依靠爬源码复制源码配置也是无法实现最简单化的配置，需要结合文档、源码、日志逐一分析

工程源码已开放，注意配置自己的数据库连接地址，工程内的连接地址已经失效

GitHub源码

Spring Data JPA 知识记录

Sun, 09 Dec 2018 17:04:00 +0800

jpa方法命名规则

关键字	方法命名	sql where字句
And	findByNameAndPwd	where name= ? and pwd =?
Or	findByNameOrSex	where name= ? or sex=?
Is,Equals	findById,findByIdEquals	where id= ?
Between	findByIdBetween	where id between ? and ?
LessThan	findByIdLessThan	where id < ?
LessThanEquals	findByIdLessThanEquals	where id <= ?
GreaterThan	findByIdGreaterThan	where id > ?
GreaterThanEquals	findByIdGreaterThanEquals	where id > = ?
After	findByIdAfter	where id > ?
Before	findByIdBefore	where id < ?
IsNull	findByNameIsNull	where name is null
isNotNull,NotNull	findByNameNotNull	where name is not null
Like	findByNameLike	where name like ?
NotLike	findByNameNotLike	where name not like ?
StartingWith	findByNameStartingWith	where name like ‘?%’
EndingWith	findByNameEndingWith	where name like ‘%?’
Containing	findByNameContaining	where name like ‘%?%’
OrderBy	findByIdOrderByXDesc	where id=? order by x desc
Not	findByNameNot	where name <> ?
In	findByIdIn(Collection c)	where id in (?)
NotIn	findByIdNotIn(Collection c)	where id not in (?)
TRUE	findByAaaTue	where aaa = true
FALSE	findByAaaFalse	where aaa = false
IgnoreCase	findByNameIgnoreCase	where UPPER(name)=UPPER(?)

常用注解

自动生成时间和修改者

@CreatedDate、@CreatedBy、@LastModifiedDate、@LastModifiedBy

在spring jpa中，支持在字段或者方法上进行注解@CreatedDate、@CreatedBy、@LastModifiedDate、@LastModifiedBy，从字面意思可以很清楚的了解，这几个注解的用处。

@CreatedDate 表示该字段为创建时间时间字段，在这个实体被insert的时候，会设置值

@CreatedBy 表示该字段为创建人，在这个实体被insert的时候，会设置值

@LastModifiedDate、@LastModifiedBy同理。

自动建表引擎设置

使用SpringDataJpa自动建表默认为MyISAM，而主流大多数场景都需要使用InnoDB，可通过配置文件配置即可

spring:
 jpa:
 database-platform: org.hibernate.dialect.MySQL55Dialect

注意：类名有所变化

早期通过网上搜索的类名都说为org.hibernate.dialect.MySQL5InnoDBDialect，当实际测试时发现引擎依然为MyISAM，通过进一步查询源码发现早期类名已经弃用

/*
 * Hibernate, Relational Persistence for Idiomatic Java
 *
 * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
 * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
 */
package org.hibernate.dialect;

/** A Dialect for MySQL 5 using InnoDB engine
 *
 * @author Gavin King,
 * @author Scott Marlow
 * @deprecated Use "hibernate.dialect.storage_engine=innodb" environment variable or JVM system property instead.
 */
@Deprecated
public class MySQL5InnoDBDialect extends MySQL5Dialect {

	@Override
	protected MySQLStorageEngine getDefaultMySQLStorageEngine() {
		return InnoDBStorageEngine.INSTANCE;
	}
}

但注释里并没有指明新的替代类名，而是建议通过配置实现，但SpringDataJpa自动装配的类里没有支持该配置，故如果不单独引入hibernate依赖是无法使用该配置的

最后在stackoverflow上看到解决方案：where to put hibernate.dialect.storage_engine property

即使用新的类名org.hibernate.dialect.MySQL55Dialect替换即可，尽管两个类名初看没差别，实际上差了一个数字5，影响比较大

MySQL驱动变化

在使用了新版的驱动类后，不管是MyBatis还是Jpa，都会报时区不一致和报错信息乱码的错误需要将连接URL更新

新配置

spring:
 datasource:
 driver-class-name: com.mysql.cj.jdbc.Driver
 username: root
 password: 
 url: jdbc:mysql://localhost/pw_manager?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC

原配置

spring:
 datasource:
 driver-class-name: com.mysql.jdbc.Driver
 username: cmsspringcloud
 password: cmsdbadmin
 url: jdbc:mysql://localhost:3306/cms_springcloud?characterEncoding=utf-8&useSSL=false