quarkus数据库篇之三：单应用同时操作多个数据库

欢迎访问我的GitHub

这里分类和汇总了欣宸的全部原创(含配套源码)：https://github.com/zq2599/blog_demos

本篇概览

• 一个应用同时连接多个数据库进行操作，这是常见的场景，quarkus也不例外，今天就随本文一起来实战多数据源操作
  
• 如下图，今天要创建名为multi-db-demo的应用，此应用同时连接两个数据库，名为fist-db的库中是卖家表，名为second-db的库中是买家表
  

• 为了简化demo，本篇继续坚持不支持web服务，用单元测试来验证应用同时操作两个数据库没有问题
  

限制

• quarkus连接和操作数据库的方式有两种：传统JDBC和反应式(reactive)，咱们前文演示的demo就是传统JDBC方式
  
• 截止当前（最新版本是2.9），只有JDBC方式支持多数据源，反应式还不支持
  

准备工作

• 实战前先把环境准备一下，既然是多数据源操作，那就要准备至少两个数据库了，请您将MySQL和PostgreSQL准备好再做下面的数据准备工作
  
• 先在MySQL数据库建库建表，参考SQL如下
  

1. # 建数据库
2. CREATE DATABASE first_db;
4. # 选中数据库
5. use first_db;
7. # 建表
8. CREATE TABLE IF NOT EXISTS `seller`(
9.     `id` INT UNSIGNED AUTO_INCREMENT,
10.     `name` VARCHAR(100) NOT NULL,
11.     `product_num` INT NULL,
12.     PRIMARY KEY ( `id` )
13. )ENGINE=InnoDB DEFAULT CHARSET=utf8;
15. # 新增三条记录
16. insert into seller (name, product_num) values ('seller1', 1111);
17. insert into seller (name, product_num) values ('seller2', 2222);
18. insert into seller (name, product_num) values ('seller3', 3333);

复制代码

• 然后是在PostgreSQL建库建表，参考SQL如下
  

1. # 建数据库
2. CREATE DATABASE second_db;
4. # 建表
5. CREATE TABLE buyer(
6.    id SERIAL PRIMARY KEY,
7.    name VARCHAR NOT NULL,
8.    order_num int NOT NULL
9. );
11. # 新增两条记录
12. insert into buyer (name, order_num) values ('buyer1', 100);
13. insert into buyer (name, order_num) values ('buyer2', 200);

复制代码

• 再整理一下两个数据库的地址，稍后用到
  

• MySQL：jdbc:mysql://192.168.50.43:3306/first_db
  
• PostgreSQL：jdbc:postgresql://192.168.50.43:15432/second_db
  

开发-创建子工程

• 《quarkus实战之一：准备工作》已创建了父工程，今天在此父工程下新增名为multi-db-demo的子工程，其pom与前文的工程区别不大，新增MySQL库，所有依赖如下
  

1.     <dependencies>
2.         <dependency>
3.             <groupId>io.quarkus</groupId>
4.             <artifactId>quarkus-arc</artifactId>
5.         </dependency>
6.         
7.         <dependency>
8.             <groupId>io.quarkus</groupId>
9.             <artifactId>quarkus-agroal</artifactId>
10.         </dependency>
11.         
12.         <dependency>
13.             <groupId>io.quarkus</groupId>
14.             <artifactId>quarkus-hibernate-orm</artifactId>
15.         </dependency>
16.         
17.         <dependency>
18.             <groupId>io.quarkus</groupId>
19.             <artifactId>quarkus-jdbc-postgresql</artifactId>
20.         </dependency>
21.         
22.         <dependency>
23.             <groupId>io.quarkus</groupId>
24.             <artifactId>quarkus-jdbc-mysql</artifactId>
25.         </dependency>
26.         
27.         <dependency>
28.             <groupId>io.quarkus</groupId>
29.             <artifactId>quarkus-junit5</artifactId>
30.             <scope>test</scope>
31.         </dependency>
32.         <dependency>
33.             <groupId>io.rest-assured</groupId>
34.             <artifactId>rest-assured</artifactId>
35.             <scope>test</scope>
36.         </dependency>
37.     </dependencies>

复制代码

开发-配置文件

• 接下来就是多数据源操作最关键的地方了：配置文件，为了满足多个profile的需要，这里继续使用application.properties和application-xxx.properties组合的方式，application.properties里存放公共配置，例如数据库类型，而application-xxx.properties里面是和各个profile环境有关的配置项，例如数据库IP地址、账号密码等，如下图
  

• 这里再强调一下配置的内容：配置的是数据源（datasource），代码中连接数据库时用到的配置项
  
• 接下来就是配置项了，这里有两个数据源，所以这两个数据源配置项都要有，咱们逐个配置
  
• 首先是first-db的，我们将其当做应用的默认数据源，那么它的配置和原来单数据源的没有任何却别，如下所示
  

1. # first-db的配置，下面五个配置项在application.properties文件中
2. quarkus.hibernate-orm.log.sql=true
3. quarkus.datasource.db-kind=mysql
4. quarkus.datasource.jdbc.max-size=8
5. quarkus.datasource.jdbc.min-size=2
6. quarkus.hibernate-orm.packages=com.bolingcavalry.multidb.entity.firstdb
8. # first-db的配置，下面三个配置项在application-test.properties文件中，即test环境下fitst-db的数据库地址、账号、密码等信息
9. quarkus.datasource.username=root
10. quarkus.datasource.password=123456
11. quarkus.datasource.jdbc.url=jdbc:mysql://192.168.50.43:3306/first_db

复制代码

• 其次是second_db的配置，注意quarkus对非默认数据源配置的要求：配置项的key中都要有数据源名称，下图是默认数据源和非默认数据源配置项的对比，红色内容是数据源名称，放在第二个点号后面
  

• 按照上述规则，second_db的所有配置如下
  

1. # second_db的配置，下面五个配置项在application.properties文件中
2. quarkus.hibernate-orm.second_db.log.sql=true
3. quarkus.datasource.second_db.db-kind=postgresql
4. quarkus.datasource.second_db.jdbc.max-size=8
5. quarkus.datasource.second_db.jdbc.min-size=2
6. quarkus.hibernate-orm.second_db.datasource=second_db
7. quarkus.hibernate-orm.second_db.packages=com.bolingcavalry.multidb.entity.seconddb
9. # second_db的配置，下面三个配置项在application-test.properties文件中，即test环境下second_db的数据库地址、账号、密码等信息
10. quarkus.datasource.second_db.username=quarkus
11. quarkus.datasource.second_db.password=123456
12. quarkus.datasource.second_db.jdbc.url=jdbc:postgresql://192.168.50.43:15432/second_db

复制代码

• 还要注意一点：quarkus.hibernate-orm.packages和quarkus.hibernate-orm.second_db.packages分别代表默认数据源和second_db各自表的entity类所在package，稍后编码写entity类的时候，seller表的entity只能放在com.bolingcavalry.multidb.entity.firstdb，buyer表的entity类只能放在com.bolingcavalry.multidb.entity.seconddb
  
• 配置完成，可以开始写代码了
  

开发-编码

• 先写entity类，注意entity类的package要对应quarkus.hibernate-orm.packages或者quarkus.hibernate-orm.second_db.packages这两个配置项的值
  
• 首先是first_db的卖家表seller的entity类，完整源码如下，注意主键生成的注解GeneratedValue的配置
  

1. package com.bolingcavalry.multidb.entity.firstdb;
3. import javax.persistence.*;
5. @Entity
6. @Table(name = "seller")
7. @NamedQuery(name = "Seller.findAll", query = "SELECT f FROM Seller f ORDER BY f.name", hints = @QueryHint(name = "org.hibernate.cacheable", value = "true"))
8. @Cacheable
9. public class Seller {
11.     @Id
12.     @GeneratedValue(strategy = GenerationType.IDENTITY)
13.     private Integer id;
15.     @Column
16.     private String name;
18.     @Column(name = "product_num")
19.     private int productNum;
21.     public Integer getId() {
22.         return id;
23.     }
25.     public void setId(Integer id) {
26.         this.id = id;
27.     }
29.     public String getName() {
30.         return name;
31.     }
33.     public void setName(String name) {
34.         this.name = name;
35.     }
37.     public int getProductNum() {
38.         return productNum;
39.     }
41.     public void setProductNum(int productNum) {
42.         this.productNum = productNum;
43.     }
44. }

复制代码

• 首先是second_db的买家表buyer的entity类，完整源码如下，注意主键生成的注解GeneratedValue的配置
  

1. package com.bolingcavalry.multidb.entity.seconddb;
3. import javax.persistence.*;
5. @Entity
6. @Table(name = "buyer")
7. @NamedQuery(name = "Buyer.findAll", query = "SELECT f FROM Buyer f ORDER BY f.name", hints = @QueryHint(name = "org.hibernate.cacheable", value = "true"))
8. @Cacheable
9. public class Buyer {
11.     @Id
12.     @GeneratedValue(strategy = GenerationType.IDENTITY)
13.     private Integer id;
15.     @Column
16.     private String name;
18.     @Column(name = "order_num")
19.     private int orderNum;
21.     public Integer getId() {
22.         return id;
23.     }
25.     public void setId(Integer id) {
26.         this.id = id;
27.     }
29.     public String getName() {
30.         return name;
31.     }
33.     public void setName(String name) {
34.         this.name = name;
35.     }
37.     public int getOrderNum() {
38.         return orderNum;
39.     }
41.     public void setOrderNum(int orderNum) {
42.         this.orderNum = orderNum;
43.     }
44. }

复制代码

• 可见除了package要和配置项的指定值对齐，上述两个entity类并无任何特殊之处，不论单数据源还是多数据源，都是同样的写法
  
• 接下来是服务类了，先看卖家表对应的服务类SellerService.java，如下，由于seller表对应的数据库是当前应用的默认数据库，所以在操作数据库的时候，无需任何与数据源有关的特别设置，这和单数据源的应用是一样的
  

1. @ApplicationScoped
2. public class SellerService {
3.     @Inject
4.     EntityManager entityManager;
6.     public List<Seller> get() {
7.         return entityManager.createNamedQuery("Seller.findAll", Seller.class)
8.                 .getResultList();
9.     }
11.     public Seller getSingle(Integer id) {
12.         return entityManager.find(Seller.class, id);
13.     }
15.     @Transactional
16.     public void create(Seller seller) {
17.         entityManager.persist(seller);
18.     }
20.     @Transactional
21.     public void update(Integer id, Seller seller) {
22.         Seller entity = entityManager.find(Seller.class, id);
24.         if (null!=entity) {
25.             entity.setName(seller.getName());
26.         }
27.     }
29.     @Transactional
30.     public void delete(Integer id) {
31.         Seller entity = entityManager.getReference(Seller.class, id);
33.         if (null!=entity) {
34.             entityManager.remove(entity);
35.         }
36.     }
37. }

复制代码

• 然后是买家表buyer相关操作的服务类BuyerService.java，可见它的成员变量entityManager多了个注解PersistenceUnit，值等于配置文件中的数据库名second_db，这个注解确保了entityManager用的是second_db的数据源，其他代码和单数据源的操作并无区别
  

1. package com.bolingcavalry.multidb.service;
3. import com.bolingcavalry.multidb.entity.seconddb.Buyer;
4. import io.quarkus.hibernate.orm.PersistenceUnit;
5. import javax.enterprise.context.ApplicationScoped;
6. import javax.inject.Inject;
7. import javax.persistence.EntityManager;
8. import javax.transaction.Transactional;
9. import java.util.List;
11. @ApplicationScoped
12. public class BuyerService {
13.     @Inject
14.     @PersistenceUnit("second_db")
15.     EntityManager entityManager;
17.     public List<Buyer> get() {
18.         return entityManager.createNamedQuery("Buyer.findAll", Buyer.class)
19.                 .getResultList();
20.     }
22.     public Buyer getSingle(Integer id) {
23.         return entityManager.find(Buyer.class, id);
24.     }
26.     @Transactional
27.     public void create(Buyer buyer) {
28.         entityManager.persist(buyer);
29.     }
31.     @Transactional
32.     public void update(Integer id, Buyer buyer) {
33.         Buyer entity = entityManager.find(Buyer.class, id);
35.         if (null!=entity) {
36.             entity.setName(buyer.getName());
37.         }
38.     }
40.     @Transactional
41.     public void delete(Integer id) {
42.         Buyer entity = entityManager.getReference(Buyer.class, id);
44.         if (null!=entity) {
45.             entityManager.remove(entity);
46.         }
47.     }
48. }

复制代码

• 有个要格外注意的地方：PersistenceUnit类的package是io.quarkus.hibernate.orm，在import的时候要注意
  
• 代码写完了，接下来进入验证环节，依然使用单元测试来验证
  

开发-单元测试

• 虽然有两个服务类（SellerService和BuyerService），但是单元测试类只有一个，这里是为了模拟实际应用中同时操作两个数据库的场景，您也可以根据自身情况改成每个服务类一个单元测试类
  

1. @QuarkusTest
2. @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
3. public class MultiDBTest {
5.     /**
6.      * first_db的seller表中，初始记录数
7.      */
8.     private static final int FIRST_DB_EXIST_RECORDS_SIZE = 3;
10.     /**
11.      * second_db的buyer表中，初始记录数
12.      */
13.     private static final int SECOND_DB_EXIST_RECORDS_SIZE = 2;
15.     /**
16.      * import.sql中，第一条记录的id
17.      */
18.     private static final int EXIST_FIRST_ID = 1;
20.     /**
21.      * 在Fruit.java中，id字段的SequenceGenerator指定了initialValue等于10，
22.      * 表示自增ID从10开始
23.      */
24.     private static final int ID_SEQUENCE_INIT_VALUE = 10;
26.     @Inject
27.     SellerService sellerService;
29.     @Inject
30.     BuyerService buyerService;
32.     @Test
33.     @DisplayName("list")
34.     @Order(1)
35.     public void testGet() {
36.         List<Seller> sellerList = sellerService.get();
37.         // 判定非空
38.         Assertions.assertNotNull(sellerList);
39.         // seller表初始化时新增了3条记录
40.         Assertions.assertEquals(FIRST_DB_EXIST_RECORDS_SIZE, sellerList.size());
42.         List<Buyer> buyerList = buyerService.get();
43.         // 判定非空
44.         Assertions.assertNotNull(buyerList);
45.         // buyer表初始化时新增了2条记录
46.         Assertions.assertEquals(SECOND_DB_EXIST_RECORDS_SIZE, buyerList.size());
47.     }
49.     @Test
50.     @DisplayName("getSingle")
51.     @Order(2)
52.     public void testGetSingle() {
53.         // 用第二条记录吧，第一条在执行testUpdate方法时被更改了
54.         Seller seller = sellerService.getSingle(EXIST_FIRST_ID+1);
55.         // 判定非空
56.         Assertions.assertNotNull(seller);
57.         // buyer表的第一条记录
58.         Assertions.assertEquals("seller2", seller.getName());
60.         // 用第二条记录吧，第一条在执行testUpdate方法时被更改了
61.         Buyer buyer = buyerService.getSingle(EXIST_FIRST_ID+1);
62.         // 判定非空
63.         Assertions.assertNotNull(buyer);
64.         // buyer表的第二条记录
65.         Assertions.assertEquals("buyer2", buyer.getName());
66.     }
68.     @Test
69.     @DisplayName("update")
70.     @Order(3)
71.     public void testUpdate() {
72.         // 验证first_db的操作
73.         String newName = LocalDateTime.now().toString();
75.         Seller seller = new Seller();
76.         seller.setName(newName);
78.         // 更新数据库
79.         sellerService.update(EXIST_FIRST_ID, seller);
81.         Seller sellerFromDB = sellerService.getSingle(EXIST_FIRST_ID);
82.         // 从数据库取出的对象，其名称应该等于修改的名称
83.         Assertions.assertEquals(newName, sellerFromDB.getName());
85.         // 验证second_db的操作
86.         Buyer buyer = new Buyer();
87.         buyer.setName(newName);
89.         // 更新数据库
90.         buyerService.update(EXIST_FIRST_ID, buyer);
92.         Buyer buyerFromDB = buyerService.getSingle(EXIST_FIRST_ID);
93.         // 从数据库取出的对象，其名称应该等于修改的名称
94.         Assertions.assertEquals(newName, buyerFromDB.getName());
95.     }
97.     @Test
98.     @DisplayName("create")
99.     @Order(3)
100.     public void testCreate() {
101.         Seller seller = new Seller();
102.         seller.setName("seller4");
103.         sellerService.create(seller);
104.         // 创建成功后，记录主键肯定是大于3的
105.         Assertions.assertTrue(seller.getId()>FIRST_DB_EXIST_RECORDS_SIZE);
106.         // 记录总数应该等于已有记录数+1
107.         Assertions.assertEquals(FIRST_DB_EXIST_RECORDS_SIZE+1, sellerService.get().size());
109.         Buyer buyer = new Buyer();
110.         buyer.setName("buyer3");
111.         buyerService.create(buyer);
112.         // 创建成功后，记录主键肯定是大于3的
113.         Assertions.assertTrue(buyer.getId()>SECOND_DB_EXIST_RECORDS_SIZE);
114.         // 记录总数应该等于已有记录数+1
115.         Assertions.assertEquals(SECOND_DB_EXIST_RECORDS_SIZE+1, buyerService.get().size());
116.     }
118.     @Test
119.     @DisplayName("delete")
120.     @Order(5)
121.     public void testDelete() {
122.         List<Seller> sellers = sellerService.get();
123.         // 先记删除前的总数
124.         int numBeforeDelete = sellers.size();
126.         // 删除最后一条记录
127.         sellerService.delete(sellers.get(numBeforeDelete-1).getId());
129.         // 记录数应该应该等于删除前的数量减一
130.         Assertions.assertEquals(numBeforeDelete-1, sellerService.get().size());
132.         List<Buyer> buyers = buyerService.get();
134.         // 先记删除前的总数
135.         numBeforeDelete = buyers.size();
137.         // 删除最后一条记录
138.         buyerService.delete(buyers.get(numBeforeDelete-1).getId());
140.         // 记录数应该应该等于删除前的数量减一
141.         Assertions.assertEquals(numBeforeDelete-1, buyerService.get().size());
142.     }
143. }

复制代码

• 代码中已经有详细的注释，就不多赘述了
  

验证

• 请再次确认数据库、表、记录都已经准备就绪
  
• 运行单元测试类，如下图，一切符合预期
  

• 去数据库看一下，如下图红框所示，那是执行testUpdate方法时更新的结果
  

• 至此，quarkus连接多个数据库的实战操作已完成，希望这个实用技能可以给您一些参考
  

源码下载

• 本篇实战的完整源码可在GitHub下载到，地址和链接信息如下表所示(https://github.com/zq2599/blog_demos)
  

名称链接备注项目主页https://github.com/zq2599/blog_demos该项目在GitHub上的主页git仓库地址(https)https://github.com/zq2599/blog_demos.git该项目源码的仓库地址，https协议git仓库地址(ssh)git@github.com:zq2599/blog_demos.git该项目源码的仓库地址，ssh协议

• 这个git项目中有多个文件夹，本次实战的源码在quarkus-tutorials文件夹下，如下图红框
  
  
• quarkus-tutorials是个父工程，里面有多个module，本篇实战的module是multi-db-demo，如下图红框
  
  

本篇概览

• 一个应用同时连接多个数据库进行操作，这是常见的场景，quarkus也不例外，今天就随本文一起来实战多数据源操作
  
• 如下图，今天要创建名为multi-db-demo的应用，此应用同时连接两个数据库，名为fist-db的库中是卖家表，名为second-db的库中是买家表
  

• 为了简化demo，本篇继续坚持不支持web服务，用单元测试来验证应用同时操作两个数据库没有问题
  

限制

• quarkus连接和操作数据库的方式有两种：传统JDBC和反应式(reactive)，咱们前文演示的demo就是传统JDBC方式
  
• 截止当前（最新版本是2.9），只有JDBC方式支持多数据源，反应式还不支持
  

准备工作

• 实战前先把环境准备一下，既然是多数据源操作，那就要准备至少两个数据库了，请您将MySQL和PostgreSQL准备好再做下面的数据准备工作
  
• 先在MySQL数据库建库建表，参考SQL如下
  

1. # 建数据库
2. CREATE DATABASE first_db;
4. # 选中数据库
5. use first_db;
7. # 建表
8. CREATE TABLE IF NOT EXISTS `seller`(
9.     `id` INT UNSIGNED AUTO_INCREMENT,
10.     `name` VARCHAR(100) NOT NULL,
11.     `product_num` INT NULL,
12.     PRIMARY KEY ( `id` )
13. )ENGINE=InnoDB DEFAULT CHARSET=utf8;
15. # 新增三条记录
16. insert into seller (name, product_num) values ('seller1', 1111);
17. insert into seller (name, product_num) values ('seller2', 2222);
18. insert into seller (name, product_num) values ('seller3', 3333);

复制代码

• 然后是在PostgreSQL建库建表，参考SQL如下
  

1. # 建数据库
2. CREATE DATABASE second_db;
4. # 建表
5. CREATE TABLE buyer(
6.    id SERIAL PRIMARY KEY,
7.    name VARCHAR NOT NULL,
8.    order_num int NOT NULL
9. );
11. # 新增两条记录
12. insert into buyer (name, order_num) values ('buyer1', 100);
13. insert into buyer (name, order_num) values ('buyer2', 200);

复制代码

• 再整理一下两个数据库的地址，稍后用到
  

• MySQL：jdbc:mysql://192.168.50.43:3306/first_db
  
• PostgreSQL：jdbc:postgresql://192.168.50.43:15432/second_db
  

开发-创建子工程

• 《quarkus实战之一：准备工作》已创建了父工程，今天在此父工程下新增名为multi-db-demo的子工程，其pom与前文的工程区别不大，新增MySQL库，所有依赖如下
  

1.     <dependencies>
2.         <dependency>
3.             <groupId>io.quarkus</groupId>
4.             <artifactId>quarkus-arc</artifactId>
5.         </dependency>
6.         
7.         <dependency>
8.             <groupId>io.quarkus</groupId>
9.             <artifactId>quarkus-agroal</artifactId>
10.         </dependency>
11.         
12.         <dependency>
13.             <groupId>io.quarkus</groupId>
14.             <artifactId>quarkus-hibernate-orm</artifactId>
15.         </dependency>
16.         
17.         <dependency>
18.             <groupId>io.quarkus</groupId>
19.             <artifactId>quarkus-jdbc-postgresql</artifactId>
20.         </dependency>
21.         
22.         <dependency>
23.             <groupId>io.quarkus</groupId>
24.             <artifactId>quarkus-jdbc-mysql</artifactId>
25.         </dependency>
26.         
27.         <dependency>
28.             <groupId>io.quarkus</groupId>
29.             <artifactId>quarkus-junit5</artifactId>
30.             <scope>test</scope>
31.         </dependency>
32.         <dependency>
33.             <groupId>io.rest-assured</groupId>
34.             <artifactId>rest-assured</artifactId>
35.             <scope>test</scope>
36.         </dependency>
37.     </dependencies>

复制代码

开发-配置文件

• 接下来就是多数据源操作最关键的地方了：配置文件，为了满足多个profile的需要，这里继续使用application.properties和application-xxx.properties组合的方式，application.properties里存放公共配置，例如数据库类型，而application-xxx.properties里面是和各个profile环境有关的配置项，例如数据库IP地址、账号密码等，如下图
  

• 这里再强调一下配置的内容：配置的是数据源（datasource），代码中连接数据库时用到的配置项
  
• 接下来就是配置项了，这里有两个数据源，所以这两个数据源配置项都要有，咱们逐个配置
  
• 首先是first-db的，我们将其当做应用的默认数据源，那么它的配置和原来单数据源的没有任何却别，如下所示
  

1. # first-db的配置，下面五个配置项在application.properties文件中
2. quarkus.hibernate-orm.log.sql=true
3. quarkus.datasource.db-kind=mysql
4. quarkus.datasource.jdbc.max-size=8
5. quarkus.datasource.jdbc.min-size=2
6. quarkus.hibernate-orm.packages=com.bolingcavalry.multidb.entity.firstdb
8. # first-db的配置，下面三个配置项在application-test.properties文件中，即test环境下fitst-db的数据库地址、账号、密码等信息
9. quarkus.datasource.username=root
10. quarkus.datasource.password=123456
11. quarkus.datasource.jdbc.url=jdbc:mysql://192.168.50.43:3306/first_db

复制代码

• 其次是second_db的配置，注意quarkus对非默认数据源配置的要求：配置项的key中都要有数据源名称，下图是默认数据源和非默认数据源配置项的对比，红色内容是数据源名称，放在第二个点号后面
  

• 按照上述规则，second_db的所有配置如下
  

1. # second_db的配置，下面五个配置项在application.properties文件中
2. quarkus.hibernate-orm.second_db.log.sql=true
3. quarkus.datasource.second_db.db-kind=postgresql
4. quarkus.datasource.second_db.jdbc.max-size=8
5. quarkus.datasource.second_db.jdbc.min-size=2
6. quarkus.hibernate-orm.second_db.datasource=second_db
7. quarkus.hibernate-orm.second_db.packages=com.bolingcavalry.multidb.entity.seconddb
9. # second_db的配置，下面三个配置项在application-test.properties文件中，即test环境下second_db的数据库地址、账号、密码等信息
10. quarkus.datasource.second_db.username=quarkus
11. quarkus.datasource.second_db.password=123456
12. quarkus.datasource.second_db.jdbc.url=jdbc:postgresql://192.168.50.43:15432/second_db

复制代码

• 还要注意一点：quarkus.hibernate-orm.packages和quarkus.hibernate-orm.second_db.packages分别代表默认数据源和second_db各自表的entity类所在package，稍后编码写entity类的时候，seller表的entity只能放在com.bolingcavalry.multidb.entity.firstdb，buyer表的entity类只能放在com.bolingcavalry.multidb.entity.seconddb
  
• 配置完成，可以开始写代码了
  

开发：编码

• 先写entity类，注意entity类的package要对应quarkus.hibernate-orm.packages或者quarkus.hibernate-orm.second_db.packages这两个配置项的值
  
• 首先是first_db的卖家表seller的entity类，完整源码如下，注意主键生成的注解GeneratedValue的配置
  

1. package com.bolingcavalry.multidb.entity.firstdb;
3. import javax.persistence.*;
5. @Entity
6. @Table(name = "seller")
7. @NamedQuery(name = "Seller.findAll", query = "SELECT f FROM Seller f ORDER BY f.name", hints = @QueryHint(name = "org.hibernate.cacheable", value = "true"))
8. @Cacheable
9. public class Seller {
11.     @Id
12.     @GeneratedValue(strategy = GenerationType.IDENTITY)
13.     private Integer id;
15.     @Column
16.     private String name;
18.     @Column(name = "product_num")
19.     private int productNum;
21.     public Integer getId() {
22.         return id;
23.     }
25.     public void setId(Integer id) {
26.         this.id = id;
27.     }
29.     public String getName() {
30.         return name;
31.     }
33.     public void setName(String name) {
34.         this.name = name;
35.     }
37.     public int getProductNum() {
38.         return productNum;
39.     }
41.     public void setProductNum(int productNum) {
42.         this.productNum = productNum;
43.     }
44. }

复制代码

• 首先是second_db的买家表buyer的entity类，完整源码如下，注意主键生成的注解GeneratedValue的配置
  

1. package com.bolingcavalry.multidb.entity.seconddb;
3. import javax.persistence.*;
5. @Entity
6. @Table(name = "buyer")
7. @NamedQuery(name = "Buyer.findAll", query = "SELECT f FROM Buyer f ORDER BY f.name", hints = @QueryHint(name = "org.hibernate.cacheable", value = "true"))
8. @Cacheable
9. public class Buyer {
11.     @Id
12.     @GeneratedValue(strategy = GenerationType.IDENTITY)
13.     private Integer id;
15.     @Column
16.     private String name;
18.     @Column(name = "order_num")
19.     private int orderNum;
21.     public Integer getId() {
22.         return id;
23.     }
25.     public void setId(Integer id) {
26.         this.id = id;
27.     }
29.     public String getName() {
30.         return name;
31.     }
33.     public void setName(String name) {
34.         this.name = name;
35.     }
37.     public int getOrderNum() {
38.         return orderNum;
39.     }
41.     public void setOrderNum(int orderNum) {
42.         this.orderNum = orderNum;
43.     }
44. }

复制代码

• 可见除了package要和配置项的指定值对齐，上述两个entity类并无任何特殊之处，不论单数据源还是多数据源，都是同样的写法
  
• 接下来是服务类了，先看卖家表对应的服务类SellerService.java，如下，由于seller表对应的数据库是当前应用的默认数据库，所以在操作数据库的时候，无需任何与数据源有关的特别设置，这和单数据源的应用是一样的
  

1. @ApplicationScoped
2. public class SellerService {
3.     @Inject
4.     EntityManager entityManager;
6.     public List<Seller> get() {
7.         return entityManager.createNamedQuery("Seller.findAll", Seller.class)
8.                 .getResultList();
9.     }
11.     public Seller getSingle(Integer id) {
12.         return entityManager.find(Seller.class, id);
13.     }
15.     @Transactional
16.     public void create(Seller seller) {
17.         entityManager.persist(seller);
18.     }
20.     @Transactional
21.     public void update(Integer id, Seller seller) {
22.         Seller entity = entityManager.find(Seller.class, id);
24.         if (null!=entity) {
25.             entity.setName(seller.getName());
26.         }
27.     }
29.     @Transactional
30.     public void delete(Integer id) {
31.         Seller entity = entityManager.getReference(Seller.class, id);
33.         if (null!=entity) {
34.             entityManager.remove(entity);
35.         }
36.     }
37. }

复制代码

• 然后是买家表buyer相关操作的服务类BuyerService.java，可见它的成员变量entityManager多了个注解PersistenceUnit，值等于配置文件中的数据库名second_db，这个注解确保了entityManager用的是second_db的数据源，其他代码和单数据源的操作并无区别
  

1. package com.bolingcavalry.multidb.service;
3. import com.bolingcavalry.multidb.entity.seconddb.Buyer;
4. import io.quarkus.hibernate.orm.PersistenceUnit;
5. import javax.enterprise.context.ApplicationScoped;
6. import javax.inject.Inject;
7. import javax.persistence.EntityManager;
8. import javax.transaction.Transactional;
9. import java.util.List;
11. @ApplicationScoped
12. public class BuyerService {
13.     @Inject
14.     @PersistenceUnit("second_db")
15.     EntityManager entityManager;
17.     public List<Buyer> get() {
18.         return entityManager.createNamedQuery("Buyer.findAll", Buyer.class)
19.                 .getResultList();
20.     }
22.     public Buyer getSingle(Integer id) {
23.         return entityManager.find(Buyer.class, id);
24.     }
26.     @Transactional
27.     public void create(Buyer buyer) {
28.         entityManager.persist(buyer);
29.     }
31.     @Transactional
32.     public void update(Integer id, Buyer buyer) {
33.         Buyer entity = entityManager.find(Buyer.class, id);
35.         if (null!=entity) {
36.             entity.setName(buyer.getName());
37.         }
38.     }
40.     @Transactional
41.     public void delete(Integer id) {
42.         Buyer entity = entityManager.getReference(Buyer.class, id);
44.         if (null!=entity) {
45.             entityManager.remove(entity);
46.         }
47.     }
48. }

复制代码

• 有个要格外注意的地方：PersistenceUnit类的package是io.quarkus.hibernate.orm，在import的时候要注意
  
• 代码写完了，接下来进入验证环节，依然使用单元测试来验证
  

开发-单元测试

• 虽然有两个服务类（SellerService和BuyerService），但是单元测试类只有一个，这里是为了模拟实际应用中同时操作两个数据库的场景，您也可以根据自身情况改成每个服务类一个单元测试类
  

1. @QuarkusTest
2. @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
3. public class MultiDBTest {
5.     /**
6.      * first_db的seller表中，初始记录数
7.      */
8.     private static final int FIRST_DB_EXIST_RECORDS_SIZE = 3;
10.     /**
11.      * second_db的buyer表中，初始记录数
12.      */
13.     private static final int SECOND_DB_EXIST_RECORDS_SIZE = 2;
15.     /**
16.      * import.sql中，第一条记录的id
17.      */
18.     private static final int EXIST_FIRST_ID = 1;
20.     /**
21.      * 在Fruit.java中，id字段的SequenceGenerator指定了initialValue等于10，
22.      * 表示自增ID从10开始
23.      */
24.     private static final int ID_SEQUENCE_INIT_VALUE = 10;
26.     @Inject
27.     SellerService sellerService;
29.     @Inject
30.     BuyerService buyerService;
32.     @Test
33.     @DisplayName("list")
34.     @Order(1)
35.     public void testGet() {
36.         List<Seller> sellerList = sellerService.get();
37.         // 判定非空
38.         Assertions.assertNotNull(sellerList);
39.         // seller表初始化时新增了3条记录
40.         Assertions.assertEquals(FIRST_DB_EXIST_RECORDS_SIZE, sellerList.size());
42.         List<Buyer> buyerList = buyerService.get();
43.         // 判定非空
44.         Assertions.assertNotNull(buyerList);
45.         // buyer表初始化时新增了2条记录
46.         Assertions.assertEquals(SECOND_DB_EXIST_RECORDS_SIZE, buyerList.size());
47.     }
49.     @Test
50.     @DisplayName("getSingle")
51.     @Order(2)
52.     public void testGetSingle() {
53.         // 用第二条记录吧，第一条在执行testUpdate方法时被更改了
54.         Seller seller = sellerService.getSingle(EXIST_FIRST_ID+1);
55.         // 判定非空
56.         Assertions.assertNotNull(seller);
57.         // buyer表的第一条记录
58.         Assertions.assertEquals("seller2", seller.getName());
60.         // 用第二条记录吧，第一条在执行testUpdate方法时被更改了
61.         Buyer buyer = buyerService.getSingle(EXIST_FIRST_ID+1);
62.         // 判定非空
63.         Assertions.assertNotNull(buyer);
64.         // buyer表的第二条记录
65.         Assertions.assertEquals("buyer2", buyer.getName());
66.     }
68.     @Test
69.     @DisplayName("update")
70.     @Order(3)
71.     public void testUpdate() {
72.         // 验证first_db的操作
73.         String newName = LocalDateTime.now().toString();
75.         Seller seller = new Seller();
76.         seller.setName(newName);
78.         // 更新数据库
79.         sellerService.update(EXIST_FIRST_ID, seller);
81.         Seller sellerFromDB = sellerService.getSingle(EXIST_FIRST_ID);
82.         // 从数据库取出的对象，其名称应该等于修改的名称
83.         Assertions.assertEquals(newName, sellerFromDB.getName());
85.         // 验证second_db的操作
86.         Buyer buyer = new Buyer();
87.         buyer.setName(newName);
89.         // 更新数据库
90.         buyerService.update(EXIST_FIRST_ID, buyer);
92.         Buyer buyerFromDB = buyerService.getSingle(EXIST_FIRST_ID);
93.         // 从数据库取出的对象，其名称应该等于修改的名称
94.         Assertions.assertEquals(newName, buyerFromDB.getName());
95.     }
97.     @Test
98.     @DisplayName("create")
99.     @Order(3)
100.     public void testCreate() {
101.         Seller seller = new Seller();
102.         seller.setName("seller4");
103.         sellerService.create(seller);
104.         // 创建成功后，记录主键肯定是大于3的
105.         Assertions.assertTrue(seller.getId()>FIRST_DB_EXIST_RECORDS_SIZE);
106.         // 记录总数应该等于已有记录数+1
107.         Assertions.assertEquals(FIRST_DB_EXIST_RECORDS_SIZE+1, sellerService.get().size());
109.         Buyer buyer = new Buyer();
110.         buyer.setName("buyer3");
111.         buyerService.create(buyer);
112.         // 创建成功后，记录主键肯定是大于3的
113.         Assertions.assertTrue(buyer.getId()>SECOND_DB_EXIST_RECORDS_SIZE);
114.         // 记录总数应该等于已有记录数+1
115.         Assertions.assertEquals(SECOND_DB_EXIST_RECORDS_SIZE+1, buyerService.get().size());
116.     }
118.     @Test
119.     @DisplayName("delete")
120.     @Order(5)
121.     public void testDelete() {
122.         List<Seller> sellers = sellerService.get();
123.         // 先记删除前的总数
124.         int numBeforeDelete = sellers.size();
126.         // 删除最后一条记录
127.         sellerService.delete(sellers.get(numBeforeDelete-1).getId());
129.         // 记录数应该应该等于删除前的数量减一
130.         Assertions.assertEquals(numBeforeDelete-1, sellerService.get().size());
132.         List<Buyer> buyers = buyerService.get();
134.         // 先记删除前的总数
135.         numBeforeDelete = buyers.size();
137.         // 删除最后一条记录
138.         buyerService.delete(buyers.get(numBeforeDelete-1).getId());
140.         // 记录数应该应该等于删除前的数量减一
141.         Assertions.assertEquals(numBeforeDelete-1, buyerService.get().size());
142.     }
143. }

复制代码

• 代码中已经有详细的注释，就不多赘述了
  

验证

• 请再次确认数据库、表、记录都已经准备就绪
  
• 运行单元测试类，如下图，一切符合预期
  

• 去数据库看一下，如下图红框所示，那是执行testUpdate方法时更新的结果
  

• 至此，quarkus连接多个数据库的实战操作已完成，希望这个实用技能可以给您一些参考
  

源码下载

• 本篇实战的完整源码可在GitHub下载到，地址和链接信息如下表所示(https://github.com/zq2599/blog_demos)
  

名称链接备注项目主页https://github.com/zq2599/blog_demos该项目在GitHub上的主页git仓库地址(https)https://github.com/zq2599/blog_demos.git该项目源码的仓库地址，https协议git仓库地址(ssh)git@github.com:zq2599/blog_demos.git该项目源码的仓库地址，ssh协议

• 这个git项目中有多个文件夹，本次实战的源码在quarkus-tutorials文件夹下，如下图红框
  
  
• quarkus-tutorials是个父工程，里面有多个module，本篇实战的module是multi-db-demo，如下图红框
  
  

本篇概览

• 一个应用同时连接多个数据库进行操作，这是常见的场景，quarkus也不例外，今天就随本文一起来实战多数据源操作
  
• 如下图，今天要创建名为multi-db-demo的应用，此应用同时连接两个数据库，名为fist-db的库中是卖家表，名为second-db的库中是买家表
  

• 为了简化demo，本篇继续坚持不支持web服务，用单元测试来验证应用同时操作两个数据库没有问题
  

限制

• quarkus连接和操作数据库的方式有两种：传统JDBC和反应式(reactive)，咱们前文演示的demo就是传统JDBC方式
  
• 截止当前（最新版本是2.9），只有JDBC方式支持多数据源，反应式还不支持
  

准备工作

• 实战前先把环境准备一下，既然是多数据源操作，那就要准备至少两个数据库了，请您将MySQL和PostgreSQL准备好再做下面的数据准备工作
  
• 先在MySQL数据库建库建表，参考SQL如下
  

1. # 建数据库
2. CREATE DATABASE first_db;
4. # 选中数据库
5. use first_db;
7. # 建表
8. CREATE TABLE IF NOT EXISTS `seller`(
9.     `id` INT UNSIGNED AUTO_INCREMENT,
10.     `name` VARCHAR(100) NOT NULL,
11.     `product_num` INT NULL,
12.     PRIMARY KEY ( `id` )
13. )ENGINE=InnoDB DEFAULT CHARSET=utf8;
15. # 新增三条记录
16. insert into seller (name, product_num) values ('seller1', 1111);
17. insert into seller (name, product_num) values ('seller2', 2222);
18. insert into seller (name, product_num) values ('seller3', 3333);

复制代码

• 然后是在PostgreSQL建库建表，参考SQL如下
  

1. # 建数据库
2. CREATE DATABASE second_db;
4. # 建表
5. CREATE TABLE buyer(
6.    id SERIAL PRIMARY KEY,
7.    name VARCHAR NOT NULL,
8.    order_num int NOT NULL
9. );
11. # 新增两条记录
12. insert into buyer (name, order_num) values ('buyer1', 100);
13. insert into buyer (name, order_num) values ('buyer2', 200);

复制代码

• 再整理一下两个数据库的地址，稍后用到
  

• MySQL：jdbc:mysql://192.168.50.43:3306/first_db
  
• PostgreSQL：jdbc:postgresql://192.168.50.43:15432/second_db
  

开发-创建子工程

• 《quarkus实战之一：准备工作》已创建了父工程，今天在此父工程下新增名为multi-db-demo的子工程，其pom与前文的工程区别不大，新增MySQL库，所有依赖如下
  

1.     <dependencies>
2.         <dependency>
3.             <groupId>io.quarkus</groupId>
4.             <artifactId>quarkus-arc</artifactId>
5.         </dependency>
6.         
7.         <dependency>
8.             <groupId>io.quarkus</groupId>
9.             <artifactId>quarkus-agroal</artifactId>
10.         </dependency>
11.         
12.         <dependency>
13.             <groupId>io.quarkus</groupId>
14.             <artifactId>quarkus-hibernate-orm</artifactId>
15.         </dependency>
16.         
17.         <dependency>
18.             <groupId>io.quarkus</groupId>
19.             <artifactId>quarkus-jdbc-postgresql</artifactId>
20.         </dependency>
21.         
22.         <dependency>
23.             <groupId>io.quarkus</groupId>
24.             <artifactId>quarkus-jdbc-mysql</artifactId>
25.         </dependency>
26.         
27.         <dependency>
28.             <groupId>io.quarkus</groupId>
29.             <artifactId>quarkus-junit5</artifactId>
30.             <scope>test</scope>
31.         </dependency>
32.         <dependency>
33.             <groupId>io.rest-assured</groupId>
34.             <artifactId>rest-assured</artifactId>
35.             <scope>test</scope>
36.         </dependency>
37.     </dependencies>

复制代码

开发-配置文件

• 接下来就是多数据源操作最关键的地方了：配置文件，为了满足多个profile的需要，这里继续使用application.properties和application-xxx.properties组合的方式，application.properties里存放公共配置，例如数据库类型，而application-xxx.properties里面是和各个profile环境有关的配置项，例如数据库IP地址、账号密码等，如下图
  

• 这里再强调一下配置的内容：配置的是数据源（datasource），代码中连接数据库时用到的配置项
  
• 接下来就是配置项了，这里有两个数据源，所以这两个数据源配置项都要有，咱们逐个配置
  
• 首先是first-db的，我们将其当做应用的默认数据源，那么它的配置和原来单数据源的没有任何却别，如下所示
  

1. # first-db的配置，下面五个配置项在application.properties文件中
2. quarkus.hibernate-orm.log.sql=true
3. quarkus.datasource.db-kind=mysql
4. quarkus.datasource.jdbc.max-size=8
5. quarkus.datasource.jdbc.min-size=2
6. quarkus.hibernate-orm.packages=com.bolingcavalry.multidb.entity.firstdb
8. # first-db的配置，下面三个配置项在application-test.properties文件中，即test环境下fitst-db的数据库地址、账号、密码等信息
9. quarkus.datasource.username=root
10. quarkus.datasource.password=123456
11. quarkus.datasource.jdbc.url=jdbc:mysql://192.168.50.43:3306/first_db

复制代码

• 其次是second_db的配置，注意quarkus对非默认数据源配置的要求：配置项的key中都要有数据源名称，下图是默认数据源和非默认数据源配置项的对比，红色内容是数据源名称，放在第二个点号后面
  

• 按照上述规则，second_db的所有配置如下
  

1. # second_db的配置，下面五个配置项在application.properties文件中
2. quarkus.hibernate-orm.second_db.log.sql=true
3. quarkus.datasource.second_db.db-kind=postgresql
4. quarkus.datasource.second_db.jdbc.max-size=8
5. quarkus.datasource.second_db.jdbc.min-size=2
6. quarkus.hibernate-orm.second_db.datasource=second_db
7. quarkus.hibernate-orm.second_db.packages=com.bolingcavalry.multidb.entity.seconddb
9. # second_db的配置，下面三个配置项在application-test.properties文件中，即test环境下second_db的数据库地址、账号、密码等信息
10. quarkus.datasource.second_db.username=quarkus
11. quarkus.datasource.second_db.password=123456
12. quarkus.datasource.second_db.jdbc.url=jdbc:postgresql://192.168.50.43:15432/second_db

复制代码

• 还要注意一点：quarkus.hibernate-orm.packages和quarkus.hibernate-orm.second_db.packages分别代表默认数据源和second_db各自表的entity类所在package，稍后编码写entity类的时候，seller表的entity只能放在com.bolingcavalry.multidb.entity.firstdb，buyer表的entity类只能放在com.bolingcavalry.multidb.entity.seconddb
  
• 配置完成，可以开始写代码了
  

开发：编码

• 先写entity类，注意entity类的package要对应quarkus.hibernate-orm.packages或者quarkus.hibernate-orm.second_db.packages这两个配置项的值
  
• 首先是first_db的卖家表seller的entity类，完整源码如下，注意主键生成的注解GeneratedValue的配置
  

1. package com.bolingcavalry.multidb.entity.firstdb;
3. import javax.persistence.*;
5. @Entity
6. @Table(name = "seller")
7. @NamedQuery(name = "Seller.findAll", query = "SELECT f FROM Seller f ORDER BY f.name", hints = @QueryHint(name = "org.hibernate.cacheable", value = "true"))
8. @Cacheable
9. public class Seller {
11.     @Id
12.     @GeneratedValue(strategy = GenerationType.IDENTITY)
13.     private Integer id;
15.     @Column
16.     private String name;
18.     @Column(name = "product_num")
19.     private int productNum;
21.     public Integer getId() {
22.         return id;
23.     }
25.     public void setId(Integer id) {
26.         this.id = id;
27.     }
29.     public String getName() {
30.         return name;
31.     }
33.     public void setName(String name) {
34.         this.name = name;
35.     }
37.     public int getProductNum() {
38.         return productNum;
39.     }
41.     public void setProductNum(int productNum) {
42.         this.productNum = productNum;
43.     }
44. }

复制代码

• 首先是second_db的买家表buyer的entity类，完整源码如下，注意主键生成的注解GeneratedValue的配置
  

1. package com.bolingcavalry.multidb.entity.seconddb;
3. import javax.persistence.*;
5. @Entity
6. @Table(name = "buyer")
7. @NamedQuery(name = "Buyer.findAll", query = "SELECT f FROM Buyer f ORDER BY f.name", hints = @QueryHint(name = "org.hibernate.cacheable", value = "true"))
8. @Cacheable
9. public class Buyer {
11.     @Id
12.     @GeneratedValue(strategy = GenerationType.IDENTITY)
13.     private Integer id;
15.     @Column
16.     private String name;
18.     @Column(name = "order_num")
19.     private int orderNum;
21.     public Integer getId() {
22.         return id;
23.     }
25.     public void setId(Integer id) {
26.         this.id = id;
27.     }
29.     public String getName() {
30.         return name;
31.     }
33.     public void setName(String name) {
34.         this.name = name;
35.     }
37.     public int getOrderNum() {
38.         return orderNum;
39.     }
41.     public void setOrderNum(int orderNum) {
42.         this.orderNum = orderNum;
43.     }
44. }

复制代码

• 可见除了package要和配置项的指定值对齐，上述两个entity类并无任何特殊之处，不论单数据源还是多数据源，都是同样的写法
  
• 接下来是服务类了，先看卖家表对应的服务类SellerService.java，如下，由于seller表对应的数据库是当前应用的默认数据库，所以在操作数据库的时候，无需任何与数据源有关的特别设置，这和单数据源的应用是一样的
  

1. @ApplicationScoped
2. public class SellerService {
3.     @Inject
4.     EntityManager entityManager;
6.     public List<Seller> get() {
7.         return entityManager.createNamedQuery("Seller.findAll", Seller.class)
8.                 .getResultList();
9.     }
11.     public Seller getSingle(Integer id) {
12.         return entityManager.find(Seller.class, id);
13.     }
15.     @Transactional
16.     public void create(Seller seller) {
17.         entityManager.persist(seller);
18.     }
20.     @Transactional
21.     public void update(Integer id, Seller seller) {
22.         Seller entity = entityManager.find(Seller.class, id);
24.         if (null!=entity) {
25.             entity.setName(seller.getName());
26.         }
27.     }
29.     @Transactional
30.     public void delete(Integer id) {
31.         Seller entity = entityManager.getReference(Seller.class, id);
33.         if (null!=entity) {
34.             entityManager.remove(entity);
35.         }
36.     }
37. }

复制代码

• 然后是买家表buyer相关操作的服务类BuyerService.java，可见它的成员变量entityManager多了个注解PersistenceUnit，值等于配置文件中的数据库名second_db，这个注解确保了entityManager用的是second_db的数据源，其他代码和单数据源的操作并无区别
  

1. package com.bolingcavalry.multidb.service;
3. import com.bolingcavalry.multidb.entity.seconddb.Buyer;
4. import io.quarkus.hibernate.orm.PersistenceUnit;
5. import javax.enterprise.context.ApplicationScoped;
6. import javax.inject.Inject;
7. import javax.persistence.EntityManager;
8. import javax.transaction.Transactional;
9. import java.util.List;
11. @ApplicationScoped
12. public class BuyerService {
13.     @Inject
14.     @PersistenceUnit("second_db")
15.     EntityManager entityManager;
17.     public List<Buyer> get() {
18.         return entityManager.createNamedQuery("Buyer.findAll", Buyer.class)
19.                 .getResultList();
20.     }
22.     public Buyer getSingle(Integer id) {
23.         return entityManager.find(Buyer.class, id);
24.     }
26.     @Transactional
27.     public void create(Buyer buyer) {
28.         entityManager.persist(buyer);
29.     }
31.     @Transactional
32.     public void update(Integer id, Buyer buyer) {
33.         Buyer entity = entityManager.find(Buyer.class, id);
35.         if (null!=entity) {
36.             entity.setName(buyer.getName());
37.         }
38.     }
40.     @Transactional
41.     public void delete(Integer id) {
42.         Buyer entity = entityManager.getReference(Buyer.class, id);
44.         if (null!=entity) {
45.             entityManager.remove(entity);
46.         }
47.     }
48. }

复制代码

• 有个要格外注意的地方：PersistenceUnit类的package是io.quarkus.hibernate.orm，在import的时候要注意
  
• 代码写完了，接下来进入验证环节，依然使用单元测试来验证
  

开发-单元测试

• 虽然有两个服务类（SellerService和BuyerService），但是单元测试类只有一个，这里是为了模拟实际应用中同时操作两个数据库的场景，您也可以根据自身情况改成每个服务类一个单元测试类
  

1. @QuarkusTest
2. @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
3. public class MultiDBTest {
5.     /**
6.      * first_db的seller表中，初始记录数
7.      */
8.     private static final int FIRST_DB_EXIST_RECORDS_SIZE = 3;
10.     /**
11.      * second_db的buyer表中，初始记录数
12.      */
13.     private static final int SECOND_DB_EXIST_RECORDS_SIZE = 2;
15.     /**
16.      * import.sql中，第一条记录的id
17.      */
18.     private static final int EXIST_FIRST_ID = 1;
20.     /**
21.      * 在Fruit.java中，id字段的SequenceGenerator指定了initialValue等于10，
22.      * 表示自增ID从10开始
23.      */
24.     private static final int ID_SEQUENCE_INIT_VALUE = 10;
26.     @Inject
27.     SellerService sellerService;
29.     @Inject
30.     BuyerService buyerService;
32.     @Test
33.     @DisplayName("list")
34.     @Order(1)
35.     public void testGet() {
36.         List<Seller> sellerList = sellerService.get();
37.         // 判定非空
38.         Assertions.assertNotNull(sellerList);
39.         // seller表初始化时新增了3条记录
40.         Assertions.assertEquals(FIRST_DB_EXIST_RECORDS_SIZE, sellerList.size());
42.         List<Buyer> buyerList = buyerService.get();
43.         // 判定非空
44.         Assertions.assertNotNull(buyerList);
45.         // buyer表初始化时新增了2条记录
46.         Assertions.assertEquals(SECOND_DB_EXIST_RECORDS_SIZE, buyerList.size());
47.     }
49.     @Test
50.     @DisplayName("getSingle")
51.     @Order(2)
52.     public void testGetSingle() {
53.         // 用第二条记录吧，第一条在执行testUpdate方法时被更改了
54.         Seller seller = sellerService.getSingle(EXIST_FIRST_ID+1);
55.         // 判定非空
56.         Assertions.assertNotNull(seller);
57.         // buyer表的第一条记录
58.         Assertions.assertEquals("seller2", seller.getName());
60.         // 用第二条记录吧，第一条在执行testUpdate方法时被更改了
61.         Buyer buyer = buyerService.getSingle(EXIST_FIRST_ID+1);
62.         // 判定非空
63.         Assertions.assertNotNull(buyer);
64.         // buyer表的第二条记录
65.         Assertions.assertEquals("buyer2", buyer.getName());
66.     }
68.     @Test
69.     @DisplayName("update")
70.     @Order(3)
71.     public void testUpdate() {
72.         // 验证first_db的操作
73.         String newName = LocalDateTime.now().toString();
75.         Seller seller = new Seller();
76.         seller.setName(newName);
78.         // 更新数据库
79.         sellerService.update(EXIST_FIRST_ID, seller);
81.         Seller sellerFromDB = sellerService.getSingle(EXIST_FIRST_ID);
82.         // 从数据库取出的对象，其名称应该等于修改的名称
83.         Assertions.assertEquals(newName, sellerFromDB.getName());
85.         // 验证second_db的操作
86.         Buyer buyer = new Buyer();
87.         buyer.setName(newName);
89.         // 更新数据库
90.         buyerService.update(EXIST_FIRST_ID, buyer);
92.         Buyer buyerFromDB = buyerService.getSingle(EXIST_FIRST_ID);
93.         // 从数据库取出的对象，其名称应该等于修改的名称
94.         Assertions.assertEquals(newName, buyerFromDB.getName());
95.     }
97.     @Test
98.     @DisplayName("create")
99.     @Order(3)
100.     public void testCreate() {
101.         Seller seller = new Seller();
102.         seller.setName("seller4");
103.         sellerService.create(seller);
104.         // 创建成功后，记录主键肯定是大于3的
105.         Assertions.assertTrue(seller.getId()>FIRST_DB_EXIST_RECORDS_SIZE);
106.         // 记录总数应该等于已有记录数+1
107.         Assertions.assertEquals(FIRST_DB_EXIST_RECORDS_SIZE+1, sellerService.get().size());
109.         Buyer buyer = new Buyer();
110.         buyer.setName("buyer3");
111.         buyerService.create(buyer);
112.         // 创建成功后，记录主键肯定是大于3的
113.         Assertions.assertTrue(buyer.getId()>SECOND_DB_EXIST_RECORDS_SIZE);
114.         // 记录总数应该等于已有记录数+1
115.         Assertions.assertEquals(SECOND_DB_EXIST_RECORDS_SIZE+1, buyerService.get().size());
116.     }
118.     @Test
119.     @DisplayName("delete")
120.     @Order(5)
121.     public void testDelete() {
122.         List<Seller> sellers = sellerService.get();
123.         // 先记删除前的总数
124.         int numBeforeDelete = sellers.size();
126.         // 删除最后一条记录
127.         sellerService.delete(sellers.get(numBeforeDelete-1).getId());
129.         // 记录数应该应该等于删除前的数量减一
130.         Assertions.assertEquals(numBeforeDelete-1, sellerService.get().size());
132.         List<Buyer> buyers = buyerService.get();
134.         // 先记删除前的总数
135.         numBeforeDelete = buyers.size();
137.         // 删除最后一条记录
138.         buyerService.delete(buyers.get(numBeforeDelete-1).getId());
140.         // 记录数应该应该等于删除前的数量减一
141.         Assertions.assertEquals(numBeforeDelete-1, buyerService.get().size());
142.     }
143. }

复制代码

• 代码中已经有详细的注释，就不多赘述了
  

验证

• 请再次确认数据库、表、记录都已经准备就绪
  
• 运行单元测试类，如下图，一切符合预期
  

• 去数据库看一下，如下图红框所示，那是执行testUpdate方法时更新的结果
  

• 至此，quarkus连接多个数据库的实战操作已完成，希望这个实用技能可以给您一些参考
  

源码下载

• 本篇实战的完整源码可在GitHub下载到，地址和链接信息如下表所示(https://github.com/zq2599/blog_demos)
  

名称链接备注项目主页https://github.com/zq2599/blog_demos该项目在GitHub上的主页git仓库地址(https)https://github.com/zq2599/blog_demos.git该项目源码的仓库地址，https协议git仓库地址(ssh)git@github.com:zq2599/blog_demos.git该项目源码的仓库地址，ssh协议

• 这个git项目中有多个文件夹，本次实战的源码在quarkus-tutorials文件夹下，如下图红框
  
  
• quarkus-tutorials是个父工程，里面有多个module，本篇实战的module是multi-db-demo，如下图红框
  
  

欢迎关注博客园：程序员欣宸

学习路上，你不孤单，欣宸原创一路相伴...

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