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

    <dependencies>
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-arc</artifactId>
        </dependency>
        <!-- JDBC库 -->
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-agroal</artifactId>
        </dependency>
        <!-- hibernate库 -->
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-hibernate-orm</artifactId>
        </dependency>
        <!-- postgresql库 -->
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-jdbc-postgresql</artifactId>
        </dependency>
        <!-- 单元测试库 -->
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-junit5</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.rest-assured</groupId>
            <artifactId>rest-assured</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

开发-配置文件

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

• application.properties内容如下

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

• application-test.properties

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

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

INSERT INTO city(id, name) VALUES (1, 'BeiJing');
INSERT INTO city(id, name) VALUES (2, 'ShangHai');
INSERT INTO city(id, name) VALUES (3, 'GuangZhou');

INSERT INTO country(id, name) VALUES (1, 'China');
INSERT INTO country_city(country_id, cities_id) VALUES (1, 1);
INSERT INTO country_city(country_id, cities_id) VALUES (1, 2);
INSERT INTO country_city(country_id, cities_id) VALUES (1, 3);

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

基本功能概述

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

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

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

开发-实体类

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

package com.bolingcavalry.db.entity;

import javax.persistence.*;

@Entity
@Table(name = "city")
@NamedQuery(name = "City.findAll", query = "SELECT c FROM City c ORDER BY c.name")
public class City {

    @Id
    @SequenceGenerator(name = "citySequence", sequenceName = "city_id_seq", allocationSize = 1, initialValue = 10)
    @GeneratedValue(generator = "citySequence")
    private Integer id;

    @Column(length = 40, unique = true)
    private String name;

    public City() {
    }

    public City(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

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

package com.bolingcavalry.db.entity;

import javax.persistence.*;
import java.util.List;
@Entity
@Table(name = "country")
public class Country {

    @Id
    @SequenceGenerator(name = "countrySequence", sequenceName = "country_id_seq", allocationSize = 1, initialValue = 10)
    @GeneratedValue(generator = "countrySequence")
    private Integer id;

    @Column(length = 40, unique = true)
    private String name;

    @OneToMany
    List<City> cities;

    public Country() {
    }

    public Country(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<City> getCities() {
        return cities;
    }

    public void setCities(List<City> cities) {
        this.cities = cities;
    }
}

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

开发-服务类

• city表的增删改查

@ApplicationScoped
public class CityService {
    @Inject
    EntityManager entityManager;

    public City getSingle(Integer id) {
        return entityManager.find(City.class, id);
    }

    public List<City> get() {
        return entityManager.createNamedQuery("City.findAll", City.class)
                .getResultList();
    }

    @Transactional
    public void create(City fruit) {
        entityManager.persist(fruit);
    }

    @Transactional
    public void update(Integer id, City fruit) {
        City entity = entityManager.find(City.class, id);

        if (null!=entity) {
            entity.setName(fruit.getName());
        }
    }

    @Transactional
    public void delete(Integer id) {
        City entity = entityManager.getReference(City.class, id);

        if (null!=entity) {
            entityManager.remove(entity);
        }
    }
}

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

@ApplicationScoped
public class CountyService {
    @Inject
    EntityManager entityManager;

    public Country getSingle(Integer id) {
        return entityManager.find(Country.class, id);
    }
}

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

开发-单元测试

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

@QuarkusTest
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class CacheTest {

    /**
     * import.sql中导入的记录数量，这些是应用启动是导入的
     */
    private static final int EXIST_CITY_RECORDS_SIZE = 3;
    private static final int EXIST_COUNTRY_RECORDS_SIZE = 1;

    /**
     * 在City.java中，id字段的SequenceGenerator指定了initialValue等于10，
     * 表示自增ID从10开始
     */
    private static final int ID_SEQUENCE_INIT_VALUE = 10;

    /**
     * import.sql中，第一条记录的id
     */
    private static final int EXIST_FIRST_ID = 1;

    @Inject
    CityService cityService;

    @Inject
    CountyService countyService;



    @Test
    @DisplayName("list")
    @Order(1)
    public void testGet() {
        List<City> list = cityService.get();
        // 判定非空
        Assertions.assertNotNull(list);
        // import.sql中新增3条记录
        Assertions.assertEquals(EXIST_CITY_RECORDS_SIZE, list.size());
    }

    @Test
    @DisplayName("getSingle")
    @Order(2)
    public void testGetSingle() {
        City city = cityService.getSingle(EXIST_FIRST_ID);
        // 判定非空
        Assertions.assertNotNull(city);
        // import.sql中的第一条记录
        Assertions.assertEquals("BeiJing", city.getName());
    }

    @Test
    @DisplayName("update")
    @Order(3)
    public void testUpdate() {
        String newName = LocalDateTime.now().toString();

        cityService.update(EXIST_FIRST_ID, new City(newName));

        // 从数据库取出的对象，其名称应该等于修改的名称
        Assertions.assertEquals(newName, cityService.getSingle(EXIST_FIRST_ID).getName());
    }

    @Test
    @DisplayName("create")
    @Order(4)
    public void testCreate() {
        int numBeforeDelete = cityService.get().size();
        City city = new City("ShenZhen");
        cityService.create(city);

        // 由于是第一次新增，所以ID应该等于自增ID的起始值
        Assertions.assertEquals(ID_SEQUENCE_INIT_VALUE, city.getId());

        // 记录总数应该等于已有记录数+1
        Assertions.assertEquals(numBeforeDelete + 1, cityService.get().size());
    }

    @Test
    @DisplayName("delete")
    @Order(5)
    public void testDelete() {
        // 先记删除前的总数
        int numBeforeDelete = cityService.get().size();

        // 删除testCreate方法中新增的记录，此记录的是第一次使用自增主键，所以id等于自增主键的起始id
        cityService.delete(ID_SEQUENCE_INIT_VALUE);

        // 记录数应该应该等于删除前的数量减一
        Assertions.assertEquals(numBeforeDelete-1, cityService.get().size());
    }
}

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

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

实体类缓存

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

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

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

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

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

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

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

SQL查询结果缓存

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

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

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

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

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

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

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

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

一对多关联查询缓存

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

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

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

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

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

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

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

重要提示

• 在使用本地缓存时有个问题需要注意：以city表为例，如果对city表的所有写操作都是通过当前应用完成的，那么使用本地缓存是没有问题的，如果除了basic-cache，还有另一个应用在修改city表，那么basic-cache中的缓存就不会失效（因为没人告诉它），这样从basic-cache中读取的数据因为是本地缓存，所以还是更新前的数据

• 至此，quarkus数据库本地缓存的现有方案，咱们已全部完成了，希望本文能给您一些参考，协助您提升应用性能

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

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