quarkus数据库篇之四：本地缓存

欢迎访问我的GitHub

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

本篇概览

• 本文是《quarkus数据库篇》系列的第四篇，来实战一个非常有用的知识点：本地缓存
  
• 本地缓存可以省去远程查询数据库的操作，这就让查询性能有了显著提升，然而，对quarkus数据库本地缓存，我们不能抱太大希望，甚至在使用此功能时候要保持克制，不要用在重要场合，官方原文如下
  

• 个人的理解（请原谅我不入流的英文水平）
  

• quarkus的数据库本地缓存功能，还处于早期的、原始的、收到诸多限制的阶段
  
• 兼容性还没有做好（说不定quarkus一升级就会出现诸多问题）
  
• 将来可能会把更好的缓存方案集成进来（意思就是现在整个方案都不稳定）
  

• 实用的功能与摇摆不定的官方态度夹杂在一起，注定了本文不会展开细节，大家随我一道了解quarkus的缓存怎么用、效果如何，这就够了，主要分为以下四部分
  

• 新建一个子工程，写好未使用缓存的数据库查询代码
  
• 增加单个实体类的缓存，并验证效果
  
• 增加自定义SQL查询结果的缓存，并验证效果
  
• 增加一对多关联查询的缓存，并验证效果
  

• 这么水的内容，注定今天是一场轻松愉快的体验之旅（捂脸）
  
• 今天实战用的数据库依然是PostgreSQL，您可以根据自己情况自行调整
  

源码下载

• 如果您想写代码，可以在我的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是basic-cache，如下图红框
  
  

开发-创建子工程

• 《quarkus实战之一：准备工作》已创建了父工程，今天在此父工程下新增名为basic-cache的子工程，其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-junit5</artifactId>
25.             <scope>test</scope>
26.         </dependency>
27.         <dependency>
28.             <groupId>io.rest-assured</groupId>
29.             <artifactId>rest-assured</artifactId>
30.             <scope>test</scope>
31.         </dependency>
32.     </dependencies>

复制代码

开发-配置文件

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

• application.properties内容如下
  

1. quarkus.datasource.db-kind=postgresql
2. quarkus.hibernate-orm.log.sql=true
3. quarkus.datasource.jdbc.max-size=8
4. quarkus.datasource.jdbc.min-size=2

复制代码

• application-test.properties
  

1. quarkus.datasource.username=quarkus
2. quarkus.datasource.password=123456
3. quarkus.datasource.jdbc.url=jdbc:postgresql://192.168.50.43:15432/quarkus_test
4. quarkus.hibernate-orm.database.generation=drop-and-create
5. quarkus.hibernate-orm.sql-load-script=import.sql

复制代码

• 应用启动时加载数据的脚本import.sql
  

1. INSERT INTO city(id, name) VALUES (1, 'BeiJing');
2. INSERT INTO city(id, name) VALUES (2, 'ShangHai');
3. INSERT INTO city(id, name) VALUES (3, 'GuangZhou');
5. INSERT INTO country(id, name) VALUES (1, 'China');
6. INSERT INTO country_city(country_id, cities_id) VALUES (1, 1);
7. INSERT INTO country_city(country_id, cities_id) VALUES (1, 2);
8. INSERT INTO country_city(country_id, cities_id) VALUES (1, 3);

复制代码

• 配置完成，接下来把代码功能先想清楚，然后再编码
  

基本功能概述

• 接下来的功能会围绕两个表展开
  

• city：每一条记录是一个城市
  
• country：每一条记录是一个国家
  
• country-cities：每一条记录是一个城市和国家的关系
  

• 然后，咱们要写出city和country的增删改查代码，另外city和country是一对多的关系，这里涉及到关联查询
  
• 最后，全部用单元测试来对比添加缓存前后的查询接口执行时间，以此验证缓存生效
  

开发-实体类

• city表的实体类是City.java，和前面几篇文章中的实体类没啥区别，要注意的是有个名为City.findAll的自定义SQL查询，稍后会用来验证本地缓存是否对自动一个SQL有效
  

1. package com.bolingcavalry.db.entity;
3. import javax.persistence.*;
5. @Entity
6. @Table(name = "city")
7. @NamedQuery(name = "City.findAll", query = "SELECT c FROM City c ORDER BY c.name")
8. public class City {
10.     @Id
11.     @SequenceGenerator(name = "citySequence", sequenceName = "city_id_seq", allocationSize = 1, initialValue = 10)
12.     @GeneratedValue(generator = "citySequence")
13.     private Integer id;
15.     @Column(length = 40, unique = true)
16.     private String name;
18.     public City() {
19.     }
21.     public City(String name) {
22.         this.name = name;
23.     }
25.     public Integer getId() {
26.         return id;
27.     }
29.     public void setId(Integer id) {
30.         this.id = id;
31.     }
33.     public String getName() {
34.         return name;
35.     }
37.     public void setName(String name) {
38.         this.name = name;
39.     }
40. }

复制代码

• country表的实体类是Country.java，这里有一处要注意的地方，就是在我们的设计中，city和country表并不是通过字段关联的，而是一个额外的表记录了他们之间的关系，因此，成员变量citys并不对应country或者city表的某个字段，使用注解OneToMany后，quarkus的hibernate模块默认用country_cities表来记录city和country的关系，至于country_cities这个表名，来自quarkus的默认规则，如果您想用city或者country的某个字段来建立两表的关联，请参考javax.persistence.OneToMany源码的注释，里面有详细说明
  

1. package com.bolingcavalry.db.entity;
3. import javax.persistence.*;
4. import java.util.List;
5. @Entity
6. @Table(name = "country")
7. public class Country {
9.     @Id
10.     @SequenceGenerator(name = "countrySequence", sequenceName = "country_id_seq", allocationSize = 1, initialValue = 10)
11.     @GeneratedValue(generator = "countrySequence")
12.     private Integer id;
14.     @Column(length = 40, unique = true)
15.     private String name;
17.     @OneToMany
18.     List<City> cities;
20.     public Country() {
21.     }
23.     public Country(String name) {
24.         this.name = name;
25.     }
27.     public Integer getId() {
28.         return id;
29.     }
31.     public void setId(Integer id) {
32.         this.id = id;
33.     }
35.     public String getName() {
36.         return name;
37.     }
39.     public void setName(String name) {
40.         this.name = name;
41.     }
43.     public List<City> getCities() {
44.         return cities;
45.     }
47.     public void setCities(List<City> cities) {
48.         this.cities = cities;
49.     }
50. }

复制代码

• 两个实体类写完了，该写服务类了
  

开发-服务类

• city表的增删改查
  

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

复制代码

• country表的增删改查，为了简化，只写一个按照id查询的，至于其他的操作如新增删除等，在本篇研究缓存时用不上就不写了
  

1. @ApplicationScoped
2. public class CountyService {
3.     @Inject
4.     EntityManager entityManager;
6.     public Country getSingle(Integer id) {
7.         return entityManager.find(Country.class, id);
8.     }
9. }

复制代码

• 应用代码已经写完了，接下来是验证基本功能的单元测试代码
  

开发-单元测试

• 数据库数据被修改后，再次读取的时候，是读到最新的数据，还是之前缓存的旧数据呢？显然前者才是正确的，这就需要单元测试来保证正确性了
  

1. @QuarkusTest
2. @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
3. public class CacheTest {
5.     /**
6.      * import.sql中导入的记录数量，这些是应用启动是导入的
7.      */
8.     private static final int EXIST_CITY_RECORDS_SIZE = 3;
9.     private static final int EXIST_COUNTRY_RECORDS_SIZE = 1;
11.     /**
12.      * 在City.java中，id字段的SequenceGenerator指定了initialValue等于10，
13.      * 表示自增ID从10开始
14.      */
15.     private static final int ID_SEQUENCE_INIT_VALUE = 10;
17.     /**
18.      * import.sql中，第一条记录的id
19.      */
20.     private static final int EXIST_FIRST_ID = 1;
22.     @Inject
23.     CityService cityService;
25.     @Inject
26.     CountyService countyService;
30.     @Test
31.     @DisplayName("list")
32.     @Order(1)
33.     public void testGet() {
34.         List<City> list = cityService.get();
35.         // 判定非空
36.         Assertions.assertNotNull(list);
37.         // import.sql中新增3条记录
38.         Assertions.assertEquals(EXIST_CITY_RECORDS_SIZE, list.size());
39.     }
41.     @Test
42.     @DisplayName("getSingle")
43.     @Order(2)
44.     public void testGetSingle() {
45.         City city = cityService.getSingle(EXIST_FIRST_ID);
46.         // 判定非空
47.         Assertions.assertNotNull(city);
48.         // import.sql中的第一条记录
49.         Assertions.assertEquals("BeiJing", city.getName());
50.     }
52.     @Test
53.     @DisplayName("update")
54.     @Order(3)
55.     public void testUpdate() {
56.         String newName = LocalDateTime.now().toString();
58.         cityService.update(EXIST_FIRST_ID, new City(newName));
60.         // 从数据库取出的对象，其名称应该等于修改的名称
61.         Assertions.assertEquals(newName, cityService.getSingle(EXIST_FIRST_ID).getName());
62.     }
64.     @Test
65.     @DisplayName("create")
66.     @Order(4)
67.     public void testCreate() {
68.         int numBeforeDelete = cityService.get().size();
69.         City city = new City("ShenZhen");
70.         cityService.create(city);
72.         // 由于是第一次新增，所以ID应该等于自增ID的起始值
73.         Assertions.assertEquals(ID_SEQUENCE_INIT_VALUE, city.getId());
75.         // 记录总数应该等于已有记录数+1
76.         Assertions.assertEquals(numBeforeDelete + 1, cityService.get().size());
77.     }
79.     @Test
80.     @DisplayName("delete")
81.     @Order(5)
82.     public void testDelete() {
83.         // 先记删除前的总数
84.         int numBeforeDelete = cityService.get().size();
86.         // 删除testCreate方法中新增的记录，此记录的是第一次使用自增主键，所以id等于自增主键的起始id
87.         cityService.delete(ID_SEQUENCE_INIT_VALUE);
89.         // 记录数应该应该等于删除前的数量减一
90.         Assertions.assertEquals(numBeforeDelete-1, cityService.get().size());
91.     }
92. }

复制代码

• 运行单元测试，如下图，两个表的操作都正常，建表语句也符合预期
  

• 啥都准备好了，有请本地缓存闪亮登场
  

实体类缓存

• 先看不用缓存的时候，查询单个实体类的性能，增加一个单元测试方法testCacheEntity，用RepeatedTest让此方法执行一万次
  

1.     @DisplayName("cacheEntity")
2.     @Order(6)
3.     @RepeatedTest(10000)
4.     public void testCacheEntity() {
5.         City city = cityService.getSingle(EXIST_FIRST_ID);
6.         // 判定非空
7.         Assertions.assertNotNull(city);
8.     }

复制代码

• 点击下图红框中的绿色三角形按钮，会立即执行一万次testCacheEntity方法
  

• 执行完毕后，耗时统计如下图红框所示，47秒，单次查询耗时约为5毫秒左右，记住这两个数字
  

• 接下来是本篇的第一个关键：开启实体类缓存，其实很简单，如下图红框，增加Cacheable注解即可
  

• 再次运行单元测试的方法，如下图红框，总耗时从之前的47秒缩减到1秒多，黄框中有一些时间统计为空，这表示单次执行的时候耗时低于1毫秒
  

• 可见本地缓存的效果是显著的
  

SQL查询结果缓存

• 回顾city的entity类代码，如下图黄框，有一个自定义SQL
  

• 写一个单元测试方法，验证上述SQL的实际性能
  

1.     @DisplayName("cacheSQL")
2.     @Order(7)
3.     @RepeatedTest(10000)
4.     public void testCacheSQL() {
5.         List<City> cities = cityService.get();
6.         // 判定非空
7.         Assertions.assertNotNull(cities);
8.         // import.sql中新增3条city记录
9.         Assertions.assertEquals(EXIST_CITY_RECORDS_SIZE, cities.size());
10.     }

复制代码

• 单元测试效果如下图，红框显示，没有使用缓存时，一万次自定义SQL查询需要1分钟零5秒
  

• 然后是本篇的第二个重点：给SQL查询增加缓存，方法如下图红框，增加hints属性
  

• 为SQL添加了本地缓存后，再次执行同样的单元测试方法，效果如下图，本地缓存将SQL查询的耗时从1分零5秒缩短到1秒多钟
  

• 另外要注意的是，如果您的SQL是通过API执行的，而不是基于NamedQuery注解，那就要通过API来开启SQL缓存，示例如下
  

1. Query query = ...
2. query.setHint("org.hibernate.cacheable", Boolean.TRUE);

复制代码

一对多关联查询缓存

• country和city是一对多的关系，查询Country记录的时候，与其关联的city表记录也会被查询出来，填入Country对象的cities成员变量中
  
• 所以，是不是只要给实体类Country增加缓存注解，在查询Country的时候，其关联的City对象也会走本地缓存呢？
  
• 咱们来实际验证一下吧，先给Country类增加缓存注解，如下图红框
  

• 新增一个单元测试方法，查询一条Country记录
  

1.     @DisplayName("cacheOne2Many")
2.     @Order(8)
3.     @RepeatedTest(10000)
4.     public void testCacheOne2Many() {
5.         Country country = countyService.getSingle(EXIST_FIRST_ID);
6.         // 判定非空
7.         Assertions.assertNotNull(country);
8.         // import.sql中新增3条city记录
9.         Assertions.assertEquals(EXIST_CITY_RECORDS_SIZE, country.getCities().size());
10.     }

复制代码

• 执行方法testCacheOne2Many，效果如下图红框所示，34秒，这显然是本地缓存没有生效的结果
  

• 接下来，就是本篇的第三个重点：设置一对多关联查询缓存，设置方法如下图红框所示
  

• 再次执行方法testCacheOne2Many，效果如下图红框所示，1秒多完成，缓存已生效
  

• 最后还要做件事情，就是完整的运行单元测试类CacheTest.java，如此做是为了验证这个场景：缓存开启的时候，如果做了写操作，接下来读取的也是最新的记录，而非缓存的之前的旧数据，即缓存失效功能，如下图，所有测试方法都顺利通过，总耗时3秒
  

重要提示

• 在使用本地缓存时有个问题需要注意：以city表为例，如果对city表的所有写操作都是通过当前应用完成的，那么使用本地缓存是没有问题的，如果除了basic-cache，还有另一个应用在修改city表，那么basic-cache中的缓存就不会失效（因为没人告诉它），这样从basic-cache中读取的数据因为是本地缓存，所以还是更新前的数据
  
• 至此，quarkus数据库本地缓存的现有方案，咱们已全部完成了，希望本文能给您一些参考，协助您提升应用性能
  

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

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

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