【云岚到家】-day03-2-门户缓存实现实战

[5 缓存实现](#5 缓存实现)
- [5.2 定时任务更新缓存](#5.2 定时任务更新缓存)
- - [5.2.1 分布式调度平台](#5.2.1 分布式调度平台)
  - - [5.2.1.1 jdk提供的Timer定时器](#5.2.1.1 jdk提供的Timer定时器)
    - [5.2.1.2 使用第三方Quartz方式](#5.2.1.2 使用第三方Quartz方式)
    - [5.2.1.3 使用分布式调度平台XXL-JOB](#5.2.1.3 使用分布式调度平台XXL-JOB)
  - [5.2.2 XXL-JOB](#5.2.2 XXL-JOB)
  - - [5.2.2.1 介绍](#5.2.2.1 介绍)
    - [5.2.2.2 部署调度中心](#5.2.2.2 部署调度中心)
    - [5.2.2.3 执行器](#5.2.2.3 执行器)
  - [5.2.2 定义缓存更新任务](#5.2.2 定义缓存更新任务)
  - - [5.2.2.1 编写任务方法](#5.2.2.1 编写任务方法)
    - [5.2.2.2 配置任务](#5.2.2.2 配置任务)
    - [5.2.2.3 启动任务并测试](#5.2.2.3 启动任务并测试)
- [5.3 首页服务列表实现](#5.3 首页服务列表实现)
- - [5.3.1 首页服务列表实现](#5.3.1 首页服务列表实现)
  - - [5.3.1.1 需求分析](#5.3.1.1 需求分析)
    - [5.3.1.2 接口定义](#5.3.1.2 接口定义)
    - [5.3.1.3 mapper](#5.3.1.3 mapper)
    - [5.3.1.4 service](#5.3.1.4 service)
    - [5.3.1.5 controller](#5.3.1.5 controller)
    - [5.3.1.6 测试](#5.3.1.6 测试)
  - [5.3.2 首页服务列表缓存](#5.3.2 首页服务列表缓存)
  - - [5.3.2.1 缓存方案分析](#5.3.2.1 缓存方案分析)
    - [5.3.2.2 查询缓存](#5.3.2.2 查询缓存)
    - [5.3.2.3 查询缓存测试](#5.3.2.3 查询缓存测试)
    - [5.3.2.4 定时任务更新缓存](#5.3.2.4 定时任务更新缓存)
    - [5.3.2.5 定时任务更新缓存测试](#5.3.2.5 定时任务更新缓存测试)
    - [5.3.2.6 禁用区域时删除缓存](#5.3.2.6 禁用区域时删除缓存)
[6 缓存-实战](#6 缓存-实战)
- [6.1 服务类型列表缓存](#6.1 服务类型列表缓存)
- - [6.1.1 分析设计](#6.1.1 分析设计)
  - - [6.1.1.1 界面原型](#6.1.1.1 界面原型)
    - [6.1.1.2 接口定义](#6.1.1.2 接口定义)
  - [6.1.2 服务类型列表实现](#6.1.2 服务类型列表实现)
  - - [6.1.2.1 mapper](#6.1.2.1 mapper)
    - [6.1.2.2 service](#6.1.2.2 service)
    - [6.1.2.3 controller](#6.1.2.3 controller)
    - [6.1.2.4 测试](#6.1.2.4 测试)
  - [6.1.3 服务类型列表缓存](#6.1.3 服务类型列表缓存)
  - - [6.1.3.1 缓存方案分析](#6.1.3.1 缓存方案分析)
    - [6.1.3.2 查询缓存](#6.1.3.2 查询缓存)
    - [6.1.3.3 查询缓存测试](#6.1.3.3 查询缓存测试)
    - [6.1.3.4 定时任务更新缓存](#6.1.3.4 定时任务更新缓存)
    - [6.1.3.5 禁用区域时删除缓存](#6.1.3.5 禁用区域时删除缓存)
- [6.2 热门服务列表](#6.2 热门服务列表)
- - [6.2.1 分析设计](#6.2.1 分析设计)
  - - [6.2.1.1 界面原型](#6.2.1.1 界面原型)
    - [6.2.1.2 接口设计](#6.2.1.2 接口设计)
  - [6.2.2 热门服务列表实现](#6.2.2 热门服务列表实现)
  - - [6.2.2.1 mapper](#6.2.2.1 mapper)
    - [6.2.2.2 service](#6.2.2.2 service)
    - [6.2.2.3 controller](#6.2.2.3 controller)
    - [6.2.2.4 测试](#6.2.2.4 测试)
  - [6.2.3 热门服务列表缓存](#6.2.3 热门服务列表缓存)
  - - [6.2.3.1 缓存方案分析](#6.2.3.1 缓存方案分析)
    - [6.2.3.2 查询缓存](#6.2.3.2 查询缓存)
    - [6.2.3.3 查询缓存测试](#6.2.3.3 查询缓存测试)
    - [6.2.3.4 定时任务更新缓存](#6.2.3.4 定时任务更新缓存)
    - [6.2.3.5 禁用区域时删除缓存](#6.2.3.5 禁用区域时删除缓存)
- [6.3 服务详情](#6.3 服务详情)
- - [6.3.1 分析设计](#6.3.1 分析设计)
  - - [6.3.1.1 界面原型](#6.3.1.1 界面原型)
    - [6.3.1.2 接口设计](#6.3.1.2 接口设计)
  - [6.3.2 服务详情实现](#6.3.2 服务详情实现)
  - - [6.3.2.1 mapper](#6.3.2.1 mapper)
    - [6.3.2.2 service](#6.3.2.2 service)
    - [6.3.2.3 controller](#6.3.2.3 controller)
    - [6.3.2.4 测试](#6.3.2.4 测试)
  - [6.3.3 服务详情缓存](#6.3.3 服务详情缓存)
  - - [6.2.3.1 缓存方案分析](#6.2.3.1 缓存方案分析)
    - [6.2.3.2 缓存信息](#6.2.3.2 缓存信息)
    - - 1) 缓存服务信息缓存服务信息)
      - 2) 缓存服务项信息缓存服务项信息)

5 缓存实现

5.1在day03-1

5.2 定时任务更新缓存

5.2.1 分布式调度平台

5.2.1.1 jdk提供的Timer定时器

示例代码如下：

每个Timer对应一个线程，可以同时启动多个Timer定时执行多个任务。

java 复制代码

public static void main(String[] args){  
    Timer timer = new Timer();  
    timer.schedule(new TimerTask(){
        @Override  
        public void run() {  
           //TODO：something
        }  
    }, 1000, 2000);  //1秒后开始调度，每2秒执行一次
}

Time使用简单，可以实现每隔一定的时间去执行任务，但无法实现每天凌晨去执行任务，即在某个时间点去执行任务。

5.2.1.2 使用第三方Quartz方式

Quartz 是一个功能强大的任务调度框架（项目地址：https://github.com/quartz-scheduler/quartz ），它可以满足更多更复杂的调度需求，Quartz 设计的核心类包括 Scheduler, Job 以及 Trigger。其中，Job 负责定义需要执行的任务，Trigger 负责设置调度策略，Scheduler 将二者组装在一起，并触发任务开始执行。Quartz支持简单的按时间间隔调度、还支持按日历调度方式，通过设置CronTrigger表达式（包括：秒、分、时、日、月、周、年）进行任务调度。

虽然Quartz可以实现按日历调度的方式，但无法支持分布式环境下任务调度。分布式环境下通常一个服务部署多个实例即多个jvm进程，假设运营基础服务部署两个实例每个实例定时执行更新缓存的任务，两个实例就会重复执行。如下图：

5.2.1.3 使用分布式调度平台XXL-JOB

在分布式环境下进行任务调度需要使用分布式任务调度平台，XXL-JOB是一个轻量级分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。

官网：https://www.xuxueli.com/xxl-job/

文档：https://www.xuxueli.com/xxl-job/#《分布式任务调度平台XXL-JOB》

5.2.2 XXL-JOB

5.2.2.1 介绍

XXL-JOB主要有调度中心、执行器、任务：

调度中心：

负责管理调度信息，按照调度配置发出调度请求，自身不承担业务代码；

主要职责为执行器管理、任务管理、监控运维、日志管理等

任务执行器：

负责接收调度请求并执行任务逻辑；

主要职责是执行任务、执行结果上报、日志服务等

使用XXL-JOB就可以解决使用多个jvm进程重复执行任务的问题，如下图：

XXL-JOB调度中心可以配置路由策略，比如：第一个、轮询策略、分片等，它们分别表示的意义如下：

第一个：即每次执行任务都由第一个执行器去执行。

轮询：即执行器轮番执行。

分片：每次执行任务广播给每个执行器让他们同时执行任务。

如果根据需求每次执行任务仅由一个执行器去执行任务可以设置路由策略：第一个、轮询。

如果根据需求每次执行任务由多个执行器同时执行可以设置路由策略为：分片。

5.2.2.2 部署调度中心

1.查阅xxl-job的源码

首先下载XXL-JOB

GitHub：https://github.com/xuxueli/xxl-job

码云：https://gitee.com/xuxueli0323/xxl-job

项目使用2.3.1版本： https://github.com/xuxueli/xxl-job/releases/tag/2.3.1

也可从课程资料目录获取，解压xxl-job-2.3.1.zip

使用IDEA打开解压后的目录

xxl-job-admin：调度中心

xxl-job-core：公共依赖

xxl-job-executor-samples：执行器Sample示例（选择合适的版本执行器，可直接使用）

：xxl-job-executor-sample-springboot：Springboot版本，通过Springboot管理执行器，推荐这种方式；

：xxl-job-executor-sample-frameless：无框架版本；

doc :文档资料，包含数据库脚本

在下发的虚拟机的MySQL中已经创建了xxl_job_2.3.1数据库

如下图：

2.启动xxl-job

执行

shell 复制代码

docker start xxl-job-admin

启动xxl-job

访问：http://192.168.101.68:8088/xxl-job-admin/

账号和密码：admin/123456

5.2.2.3 执行器

1.添加执行器依赖

下边配置执行器，执行器负责与调度中心通信接收调度中心发起的任务调度请求，执行器负责执行微服务中定义的任务，执行器程序由xxl-job提供，在微服务中引入下边的依赖即加入了执行器的程序：

xml 复制代码

<dependency>
    <groupId>com.xuxueli</groupId>
    <artifactId>xxl-job-core</artifactId>
</dependency>

本项目在framework中定义了jzo2o-xxl-job工程，它对执行器bean执行了定义：

所以在需要使用xxl-job的微服务中需要引入下边的依赖，在jzo2o-foundations服务中引入下边的依赖：

xml 复制代码

<dependency>
    <groupId>com.jzo2o</groupId>
    <artifactId>jzo2o-xxl-job</artifactId>
</dependency>

2.配置xxl-job

接下来进入nacos，配置shared-xxl-job.yaml：

说明：

address：调度中心的地址

appName：执行器名称，为spring.application.name表示微服务的名称（在bootstrap.yml中配置）

port：执行器端口号,通过xxl-job.port配置

在jzo2o-foundations.yaml中配置执行器的端口：

在jzo2o-foundations中加载shared-xxl-job.yaml：

3. 下边进入调度中心添加执行器

进入调度中心，进入执行器管理界面，如下图：

AppName：执行名称，在shared-xxl-job.yaml中指定执行器名称就是微服务的应用名。

名称：取一个中文名称。

注册方式：自动注册，只要执行器和调度中心连通执行器会自动注册到调度中心

机器地址：自动注册时不用填写。

找到应用名：jzo2o-foundations，如下图：

启动jzo2o-foundations，查看jzo2o-foundations的控制台：

>>>>>>>>>>> xxl-job remoting server start success, nettype = class com.xxl.job.core.server.EmbedServer, port = 11603 说明执行器启动成功。

稍等片刻进入 xxl-job调度中心，进入执行器管理界面，执行器注册成功：

点击"查看（1）"，查看执行器的地址，如下图：

5.2.2 定义缓存更新任务

根据本节的目标，使用xxl-job定时更新开通区域列表的缓存。

5.2.2.1 编写任务方法

定时执行任务就需要编写任务方法，此任务方法由执行器去调用。

可以参考xxl-job源码去编写任务方法，从源码目录中找到执行器示例代码：

xxl-job-2.3.1\xxl-job-executor-samples\xxl-job-executor-sample-springboot\src\main\java\com\xxl\job\executor\service\jobhandler\SampleXxlJob.java

部分示例代码如下，下边代码中demoJobHandler()就是一个任务方法，需要使用@XxlJob注解标识，所在类需要由spring去管理，所以加了@Component注解。

java 复制代码

@Component
public class SampleXxlJob {
    private static Logger logger = LoggerFactory.getLogger(SampleXxlJob.class);


    /**
     * 1、简单任务示例（Bean模式）
     */
    @XxlJob("demoJobHandler")
    public void demoJobHandler() throws Exception {
        XxlJobHelper.log("XXL-JOB, Hello World.");

        for (int i = 0; i < 5; i++) {
            XxlJobHelper.log("beat at:" + i);
            TimeUnit.SECONDS.sleep(2);
        }
        // default success
    }
    ....

参考上边的代码我们编写更新开通区域列表缓存的任务方法：

先删除开通区域的缓存，再查询开通区域列表进行缓存。

创建handler包，创建com.jzo2o.foundations.handler.SpringCacheSynHandler类

java 复制代码

@Component
@Slf4j
public class SpringCacheSynHandler {

    @Resource
    private IRegionService regionService;
    @Resource
    private RedisTemplate redisTemplate;

    /**
     * 已启用区域缓存更新
     * 每日凌晨1点执行
     */
    @XxlJob(value = "activeRegionCacheSync")
    public void activeRegionCacheSync() {
        log.info(">>>>>>>>开始进行缓存同步，更新已启用区域");
        //1.清理缓存
        String key = RedisConstants.CacheName.JZ_CACHE + "::ACTIVE_REGIONS";
        redisTemplate.delete(key);

        //2.刷新缓存
        regionService.queryActiveRegionListCache();
        log.info(">>>>>>>>更新已启用区域完成");
    }
}

5.2.2.2 配置任务

下边在调度中心配置任务。

进入任务管理，新增任务：

填写任务信息：

说明：

调度类型：

固定速度指按固定的间隔定时调度。

Cron，通过Cron表达式实现更丰富的定时调度策略。

Cron表达式是一个字符串，通过它可以定义调度策略，格式如下：

{秒数} {分钟} {小时} {日期} {月份} {星期} {年份(可为空)}

xxl-job提供图形界面去配置：

一些例子如下：

0 0 0 * * ? 每天0点触发

30 10 1 * * ? 每天1点10分30秒触发

0/30 * * * * ? 每30秒触发一次

* 0/10 * * * ? 每10分钟触发一次

为了方便测试这里第5秒执行一次，设置为：0/5 * * * * ?

运行模式有BEAN和GLUE，bean模式较常用就是在项目工程中编写执行器的任务代码，GLUE是将任务代码编写在调度中心。

JobHandler即任务方法名，填写任务方法上边@XxlJob注解中的名称。

路由策略：

第一个：即每次执行任务都由第一个执行器去执行。

轮询：即执行器轮番执行。

分片：每次执行任务广播给每个执行器让他们同时执行任务。

详细说明xxl-job源码中的doc目录下的文档：

5.2.2.3 启动任务并测试

任务配置完成，下边启动任务

重启foundations微服务，查看控制台

说明我们的xxl-job调用成功

5.3 首页服务列表实现

我们先实现从数据库查询"首页服务列表"，将整体功能调试通过，再实现查询缓存。

下边我们先实现从数据库查询服务类型列表。

5.3.1 首页服务列表实现

5.3.1.1 需求分析

1.界面原型

首页服务列表在门户的中心位置，下图红框中为首页服务列表区域：

默认展示前两个服务分类（按后台设置的排序字段进行升序排序），每个服务分类下取前4个服务项（按后台设置的排序字段进行升序排序）如下图：

一级服务分类显示的内容：服务分类的图标，服务分类的名称。

服务分类下的服务项内容：服务项图标，服务项名称。

5.3.1.2 接口定义

定义首页服务列表接口，查询2个一级服务分类，每个服务分类下查询4个服务项。

接口名称：首页服务列表

接口路径：GET/foundations/customer/serve/firstPageServeList

定义controller方法：

门户信息查询类接口统一在FirstPageServeController类中定义，service统一写在HomeService下。

创建com.jzo2o.foundations.controller.consumer.FirstPageServeController类提供门户界面查询类接口。

java 复制代码

@RestController("consumerServeController")
@RequestMapping("/customer/serve")
@Api(tags = "用户端 - 首页服务查询接口")
public class FirstPageServeController {

    @GetMapping("/firstPageServeList")
    @ApiOperation("首页服务列表")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "regionId", value = "区域id", required = true, dataTypeClass = Long.class)
    })
    public List<ServeCategoryResDTO> serveCategory(@RequestParam("regionId") Long regionId) {
        return null;
    }
}

5.3.1.3 mapper

数据来源于三张表：serve_type、serve_item、serve，区域id是非常重要的限制条件，因为要查询该区域显示在首页的服务列表。

如何查询数据？

可以先查询出服务类型，再根据服务类型id查询下边的服务项，伪代码如下：

java 复制代码

//查询服务类型
List<ServeType> serveTypeList =...
for(ServeType serveType: serveTypeList){
      Long serveTypeId = serveType.getId();
     //再根据服务类型id查询下属的服务项信息

}

上边的代码会导致1+n次查询数据库，这种代码要避免。

我们可以一次将符合条件的数据查询出来，再通过java程序对数据进行处理，再封装为接口要求的数据格式，最后返回给前端。

接口

java 复制代码

/**
 * 根据区域查询服务图标分类
 * @param regionId
 * @return
 */
List<ServeCategoryResDTO> findServeIconCategoryByRegionId(@Param("regionId") Long regionId);

下边编写mapper的xml映射文件

xml 复制代码

<select id="findServeIconCategoryByRegionId" resultType="com.jzo2o.foundations.model.dto.response.ServeCategoryResDTO">
    SELECT
        type.id as serve_type_id,
        type.name as serve_type_name,
        type.serve_type_icon,
        serve.city_code,
        serve.id as serve_id,
        item.id as serve_item_id,
        item.name as serve_item_name,
        item.serve_item_icon,
        item.sort_num as serve_item_sort_num
    FROM
        serve
            inner JOIN serve_item AS item ON item.id = serve.serve_item_id
            inner JOIN serve_type AS type ON type.id = item.serve_type_id
    WHERE
        serve.region_id = #{regionId}
      AND serve.sale_status = 2
    ORDER BY
        type.sort_num,
        item.sort_num
</select>

如果我们使用

xml 复制代码

<select id="findServeIconCategoryByRegionId"
        resultType="com.jzo2o.foundations.model.dto.response.ServeCategoryResDTO">

那返回的时全部的list，而不是只包含item.id as

serve_item_id,
item.name as serve_item_name,
item.serve_item_icon,
item.sort_num as serve_item_sort_num

的List，所以我们需要进行手动映射，所以结果我们需要从 resultType变为 `resultMap，并且在下面进行手动映射。

xml 复制代码

<select id="findServeIconCategoryByRegionId" resultMap="ServeCategoryMap">

xml 复制代码

<!--手动的映射-->
<resultMap id="ServeCategoryMap" type="com.jzo2o.foundations.model.dto.response.ServeCategoryResDTO">
    <!--id映射主键字段-->
    <id column="serve_type_id" property="serveTypeId"></id>
    <!--result映射普通字段-->
    <result column="serve_type_name" property="serveTypeName"></result>
    <result column="serve_type_icon" property="serveTypeIcon"></result>
    <result column="city_code" property="cityCode"></result>

    <!--column 数据库中的字段名-->
    <!--property 实体类中对应的属性 该关键字可以省略... -->
    <!--ofType 是javaType中的单个对象类型-->
    <collection property="serveResDTOList" ofType="com.jzo2o.foundations.model.dto.response.ServeSimpleResDTO">
        <id column="serve_id" property="id"></id>
        <result column="serve_item_id" property="serveItemId"></result>
        <result column="serve_item_name" property="serveItemName"></result>
        <result column="serve_item_icon" property="serveItemIcon"></result>
        <result column="serve_item_sort_num" property="serveItemSortNum"></result>
    </collection>
</resultMap>

5.3.1.4 service

创建com.jzo2o.foundations.service.HomeService

定义专门用于门户首页查询的service接口,用于实现查询缓存：

java 复制代码

public interface HomeService {
    /**
     * 根据区域id获取服务图标信息
     *
     * @param regionId 区域id
     * @return 服务图标列表
     */
    List<ServeCategoryResDTO> queryServeIconCategoryByRegionIdCache(Long regionId);
}

实现，创建com.jzo2o.foundations.service.impl.HomeServiceImpl

java 复制代码

@Slf4j
@Service
public class HomeServiceImpl implements HomeService {
    @Resource
    private ServeMapper serveMapper;
    @Resource
    private IRegionService regionService;
    @Override
    public List<ServeCategoryResDTO> queryServeIconCategoryByRegionIdCache(Long regionId) {
        //1.校验当前城市是否为启用状态
        Region region = regionService.getById(regionId);
        if (ObjectUtil.isEmpty(region) || ObjectUtil.equal(FoundationStatusEnum.DISABLE.getStatus(), region.getActiveStatus())) {
            return Collections.emptyList();
        }
        //2.根据城市编码查询所有的服务图标
        List<ServeCategoryResDTO> list = serveMapper.findServeIconCategoryByRegionId(regionId);
        if (ObjectUtil.isEmpty(list)) {
            return Collections.emptyList();
        }
        //3.服务类型取前两个，每个类型下服务项取前4个
        //list的截止下标
        int endIndex = list.size() >= 2 ? 2 : list.size();
        List<ServeCategoryResDTO> serveCategoryResDTOS = new ArrayList<>(list.subList(0, endIndex));
        serveCategoryResDTOS.forEach(v -> {
            List<ServeSimpleResDTO> serveResDTOList = v.getServeResDTOList();
            //serveResDTOList的截止下标
            int endIndex2 = serveResDTOList.size() >= 4 ? 4 : serveResDTOList.size();
            List<ServeSimpleResDTO> serveSimpleResDTOS = new ArrayList<>(serveResDTOList.subList(0, endIndex2));
            v.setServeResDTOList(serveSimpleResDTOS);
        });
        return serveCategoryResDTOS;
    }
}

5.3.1.5 controller

在controller中调用service查询首页服务列表。

java 复制代码

@Validated
@RestController("consumerServeController")
@RequestMapping("/customer/serve")
@Api(tags = "用户端 - 首页服务查询接口")
public class FirstPageServeController {

    @Resource
    private HomeService homeService;

    @GetMapping("/firstPageServeList")
    @ApiOperation("首页服务列表")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "regionId", value = "区域id", required = true, dataTypeClass = Long.class)
    })
    public List<ServeCategoryResDTO> serveCategory(@RequestParam("regionId") Long regionId) {
        List<ServeCategoryResDTO> serveCategoryResDTOS = homeService.queryServeIconCategoryByRegionIdCache(regionId);
        return serveCategoryResDTOS;
    }
}

5.3.1.6 测试

重启jzo2o-foundations服务、网关服务，打开小程序。

切换到北京地区，观察小程序的访问记录

成功查询到

5.3.2 首页服务列表缓存

5.3.2.1 缓存方案分析

下边是门户的缓存设计：

信息内容类型	缓存过期时间	缓存结构	缓存key	缓存同步方案
开通区域列表	永久缓存	String	JZ_CACHE::ACTIVE_REGIONS	查询缓存：查询开通区域列表进行缓存启用区域：删除开通区域缓存禁用区域：删除开通区域及其它信息由定时任务每天凌晨更新缓存
首页服务列表	永久缓存	String	JZ_CACHE:SERVE_ICON::区域id	查询缓存：初次查询进行缓存禁用区域：删除本区域的首页服务列表缓存由定时任务每天凌晨更新缓存
服务类型列表	永久缓存	String	JZ_CACHE:SERVE_TYPE::区域id	查询缓存：初次查询直接缓存禁用区域：删除本区域的服务类型列表缓存由定时任务每天凌晨更新缓存
热门服务列表	永久缓存	String	JZ_CACHE:HOT_SERVE::区域id	查询缓存：初次查询直接缓存禁用区域：删除本区域的热门服务列表缓存由定时任务每天凌晨更新缓存
服务项信息	缓存1天	String	JZ_CACHE:SERVE_ITEM::服务项id	启动：添加缓存禁用：删除缓存修改: 修改缓存
服务信息	缓存1天	String	JZ_CACHE:SERVE_RECORD::服务id	上架：添加缓存下架：删除缓存修改: 修改缓存

下边分析首页服务列表的缓存方案：

查询缓存：查询首页服务列表，如果缓存没有则查询数据库并缓存，如果缓存有则直接返回

注意：缓存时需要考虑缓存穿透问题。

禁用区域：删除首页服务列表缓存

定时任务：每天凌晨缓存首页服务列表。

5.3.2.2 查询缓存

下边在首页服务列表查询方法上添加Spring Cache注解实现查询缓存。

为了避免缓存穿透，如果服务列表为空则向redis缓存空值，缓存时间为30分钟；不为空则进行永久缓存。

在Cacheable注解中有两个属性可以指定条件进行缓存：

condition：指定一个 SpEL 表达式，用于决定是否要进行缓存。只有当条件表达式的结果为 true 时，方法的返回值才会被缓存。例如：

java 复制代码

@Cacheable(value = "myCache", condition = "#id != null")

unless：与 condition 相反，只有当 SpEL 表达式的结果为 false 时，方法的返回值才会被缓存。

例如：

java 复制代码

@Cacheable(value = "myCache", unless = "#result.length() > 100")

#result 表示方法的返回值，如果返回值结果集的长度大于100不进行缓存。

根据需求，我们需要根据方法的返回值去判断，如果结果集的长度大于0说明服务列表不空，此时缓存时间为永久缓存，否则缓存时间为30分钟。

condition不支持获取方法返回的值，不能识别#result。

我们使用unless实现。

unless 的特点是符合条件的不缓存。设置技巧：确定要缓存的条件，取反即不缓存的条件。

当方法返回的List的size为0时缓存30分钟，避免缓存穿透，设置为：#result.size() != 0

当方法返回的List的size大于0永不过期，设置为：#result.size() == 0

代码如下：

java 复制代码

@Caching(
        cacheable = {
                //result为null时,属于缓存穿透情况，缓存时间30分钟
                @Cacheable(value = RedisConstants.CacheName.SERVE_ICON, key = "#regionId", unless = "#result.size() != 0", cacheManager = RedisConstants.CacheManager.THIRTY_MINUTES),
                //result不为null时,永久缓存
                @Cacheable(value = RedisConstants.CacheName.SERVE_ICON, key = "#regionId", unless = "#result.size() == 0", cacheManager = RedisConstants.CacheManager.FOREVER)
        }
)
@Override
public List<ServeCategoryResDTO> queryServeIconCategoryByRegionIdCache(Long regionId) {
    //1.校验当前城市是否为启用状态
    Region region = regionService.getById(regionId);
    if (ObjectUtil.isEmpty(region) || ObjectUtil.equal(FoundationStatusEnum.DISABLE.getStatus(), region.getActiveStatus())) {
        return Collections.emptyList();
    }

5.3.2.3 查询缓存测试

下边进行测试:

启动：jzo2o-foundations服务、网关服务，打开小程序，等待首页服务列表正常显示，进入redis查看首页服务列表是否缓存。

预期结果：首页服务列表正常缓存。

5.3.2.4 定时任务更新缓存

根据缓存方案的分析，对首页服务列表进行缓存。应该拿到所有的开通城市列表然后更新一遍。

编写定时任务代码：

java 复制代码

@Component
@Slf4j
public class SpringCacheSynHandler {

    @Resource
    private IRegionService regionService;
    @Resource
    private RedisTemplate redisTemplate;
    @Resource
    private HomeService homeService;
    /**
     * 已启用区域缓存更新
     * 每日凌晨1点执行
     */
    @XxlJob("activeRegionCacheSync")
    public void activeRegionCacheSync() throws Exception {
        log.info(">>>>>>>>开始进行缓存同步，更新已启用区域");

        //删除缓存
        Boolean delete = redisTemplate.delete(RedisConstants.CacheName.JZ_CACHE + "::ACTIVE_REGIONS");

        //通过查询开通区域列表进行缓存
        List<RegionSimpleResDTO> regionSimpleResDTOS = regionService.queryActiveRegionListCache();

        //遍历区域对该区域下的服务类型进行缓存
        regionSimpleResDTOS.forEach(item->{
            //区域id
            Long regionId = item.getId();

            //删除该区域下的首页服务列表
            String serve_type_key = RedisConstants.CacheName.SERVE_ICON + "::" + regionId;
            redisTemplate.delete(serve_type_key);
            homeService.queryServeIconCategoryByRegionIdCache(regionId);
            //todo 删除该区域下的服务类型列表缓存
        });
    }
}

5.3.2.5 定时任务更新缓存测试

下边测试定时任务更新缓存：

先将首页服务列表的缓存手动删除。

重启foundations服务，在上边代码中打断点，保证定时任务成功执行。

预期结果：对每个运营区域的首页服务列表进行缓存。

我们开放上海和郑州

查看缓存

4 编码规范

门户信息查询类接口统一在FirstPageServeController类中定义，service统一写在HomeService下。

首先实现业务接口的功能，测试通过后再去实现缓存。

5.3.2.6 禁用区域时删除缓存

找到禁用区域代码 ,添加删除首页服务列表缓存的代码，如下：

java 复制代码

@Override
@Caching(evict = {
        @CacheEvict(value = RedisConstants.CacheName.JZ_CACHE, key = "'ACTIVE_REGIONS'"),
        @CacheEvict(value = RedisConstants.CacheName.SERVE_ICON, key = "#id")
})
public void deactivate(Long id) {
    //区域信息
    Region region = baseMapper.selectById(id);
    //启用状态
    Integer activeStatus = region.getActiveStatus();

6 缓存-实战

6.1 服务类型列表缓存

6.1.1 分析设计

6.1.1.1 界面原型

点击首页服务列表的服务分类或直接点击"全部服务"进入全部服务界面。

"全部服务" 界面如下图：

在全部服务界面需要展示当前区域下的服务分类，点击服务分类查询分类下的服务。

服务类型列表数据包括：服务类型的名称、服务类型id。

注意：只实现上图左侧显示的服务分类列表

6.1.1.2 接口定义

服务类型列表查询接口传入参数为：区域id，输出数据为服务类型列表，列表中元素包括：服务类型的名称、服务类型id，为了可扩展，列表元素包括服务类型的图标、排序字段方便进行展示。

接口名称：服务分类列表

接口路径：GET/foundations/customer/serve/serveTypeList

6.1.2 服务类型列表实现

响应实体类

java 复制代码

@Data
@ApiModel("服务类型列表响应值")
public class ServeTypeListDto {
    /**
     * 主键
     */
    @ApiModelProperty("主键")
    private Long serveTypeId;

    /**
     * 服务类型图片
     */
    @ApiModelProperty("服务类型图片")
    private String serveTypeImg;

    /**
     * 服务类型名称
     */
    @ApiModelProperty("服务类型名称")
    private String serveTypeName;

    /**
     * 服务类型排序字段
     */
    @ApiModelProperty("排序字段")
    private Integer serveTypeSortNum;
}

6.1.2.1 mapper

在com.jzo2o.foundations.mapper.ServeTypeMapper接口中

java 复制代码

/**
 * 根据区域id查询服务类型
 * @param regionId
 * @return
 */
List<ServeTypeListDto> findServeTypeByRegionId(Long regionId);

xml

xml 复制代码

<select id="findServeTypeByRegionId" resultType="com.jzo2o.foundations.model.dto.response.ServeTypeListDto">
    SELECT DISTINCT
        type.id AS serve_type_id,
        type.NAME AS serve_type_name,
        type.img serve_type_img,
        type.sort_num serve_type_sort_num
    FROM
        serve
            INNER JOIN serve_item AS item ON item.id = serve.serve_item_id
            INNER JOIN serve_type AS type ON type.id = item.serve_type_id
    WHERE
        serve.region_id = #{regionId}
      AND serve.sale_status = 2
    ORDER BY
	serve_type_sort_num ASC
</select>

6.1.2.2 service

在com.jzo2o.foundations.service.HomeService接口中

java 复制代码

List<ServeTypeListDto> queryServeTypeByRegionIdCache(Long regionId);

实现

java 复制代码

@Override
public List<ServeTypeListDto> queryServeTypeByRegionIdCache(Long regionId) {
    //1.校验当前城市是否为启用状态
    Region region = regionService.getById(regionId);
    if (ObjectUtil.isEmpty(region) || ObjectUtil.equal(FoundationStatusEnum.DISABLE.getStatus(), region.getActiveStatus())) {
        return Collections.emptyList();
    }
    //2.根据城市编码查询所有的服务类型
    List<ServeTypeListDto> list = serveTypeMapper.findServeTypeByRegionId(regionId);
    if (ObjectUtil.isEmpty(list)) {
        return Collections.emptyList();
    }
    return list;
}

6.1.2.3 controller

java 复制代码

@GetMapping("/serveTypeList")
@ApiOperation("服务类型列表")
@ApiImplicitParams({
        @ApiImplicitParam(name = "regionId", value = "区域id", required = true, dataTypeClass = Long.class)
})
public List<ServeTypeListDto> serveTypeList(@RequestParam("regionId") Long regionId) {
    List<ServeTypeListDto> serveTypeList = homeService.queryServeTypeByRegionIdCache(regionId);
    return serveTypeList;
}

6.1.2.4 测试

6.1.3 服务类型列表缓存

6.1.3.1 缓存方案分析

下边分析服务类型列表的缓存方案：

查询缓存：查询服务类型列表，如果缓存没有则查询数据库并缓存，如果缓存有则直接返回

禁用区域：删除服务类型列表缓存

定时任务：每天凌晨缓存服务类型列表。

服务类型列表缓存还需要完善的点：

定时任务更新缓存。

禁用区域时删除服务类型列表缓存。

6.1.3.2 查询缓存

java 复制代码

@Caching(
        cacheable = {
                //result为null时,属于缓存穿透情况，缓存时间30分钟
                @Cacheable(value = RedisConstants.CacheName.SERVE_TYPE, key = "#regionId", unless = "#result.size() != 0", cacheManager = RedisConstants.CacheManager.THIRTY_MINUTES),
                //result不为null时,永久缓存
                @Cacheable(value = RedisConstants.CacheName.SERVE_TYPE, key = "#regionId", unless = "#result.size() == 0", cacheManager = RedisConstants.CacheManager.FOREVER)
        }
)
@Override
public List<ServeTypeResDTO> queryServeTypeByRegionIdCache(Long regionId) {
    //1.校验当前城市是否为启用状态
    Region region = regionService.getById(regionId);
    if (ObjectUtil.isEmpty(region) || ObjectUtil.equal(FoundationStatusEnum.DISABLE.getStatus(), region.getActiveStatus())) {
        return Collections.emptyList();
    }
    //2.根据城市编码查询所有的服务类型
    List<ServeTypeResDTO> list = serveTypeMapper.findServeTypeByRegionId(regionId);
    if (ObjectUtil.isEmpty(list)) {
        return Collections.emptyList();
    }
    return list;
}

6.1.3.3 查询缓存测试

6.1.3.4 定时任务更新缓存

在com.jzo2o.foundations.handler.SpringCacheSynHandler中

java 复制代码

@Component
@Slf4j
public class SpringCacheSynHandler {

    @Resource
    private IRegionService regionService;
    @Resource
    private RedisTemplate redisTemplate;
    @Resource
    private HomeService homeService;
    /**
     * 已启用区域缓存更新
     * 每日凌晨1点执行
     */
    @XxlJob("activeRegionCacheSync")
    public void activeRegionCacheSync() throws Exception {
        log.info(">>>>>>>>开始进行缓存同步，更新已启用区域");

        //删除缓存
        Boolean delete = redisTemplate.delete(RedisConstants.CacheName.JZ_CACHE + "::ACTIVE_REGIONS");

        //通过查询开通区域列表进行缓存
        List<RegionSimpleResDTO> regionSimpleResDTOS = regionService.queryActiveRegionListCache();

        //遍历区域对该区域下的服务类型进行缓存
        regionSimpleResDTOS.forEach(item->{
            //区域id
            Long regionId = item.getId();

            //删除该区域下的首页服务列表
            String serve_type_key = RedisConstants.CacheName.SERVE_ICON + "::" + regionId;
            redisTemplate.delete(serve_type_key);
            homeService.queryServeIconCategoryByRegionIdCache(regionId);
            //删除该区域下的服务类型列表缓存
            String serve_icon_key = RedisConstants.CacheName.SERVE_TYPE + "::" + regionId;
            redisTemplate.delete(serve_icon_key);
            homeService.queryServeTypeByRegionIdCache(regionId);
        });
    }
}

6.1.3.5 禁用区域时删除缓存

java 复制代码

@Override
@Transactional
@Caching(evict = {
        @CacheEvict(value = RedisConstants.CacheName.JZ_CACHE, key = "'ACTIVE_REGIONS'"),
        @CacheEvict(value = RedisConstants.CacheName.SERVE_TYPE, key = "#id")
})
public void deactivate(Long id) {
    //查询服务类型
    ServeType serveType = baseMapper.selectById(id);
    if (ObjectUtil.isNull(serveType)) {
        throw new ForbiddenOperationException("服务类型不存在");

6.2 热门服务列表

6.2.1 分析设计

6.2.1.1 界面原型

在门户有一块区域叫精选推荐，此信息为热门服务列表，如下图：

热门服务列表是在区域服务管理界面进行设置，如下图：

"设置热门"表示该服务项在本区域为精选推荐。

"取消热门"表示取消该服务项的精选推荐。

热门服务列表数据素包括：区域服务价格、价格单位、服务项id、服务项名称、服务项图标、服务详图。

信息来源于两张表：serve_item、serve

查询条件：区域id、是否热门（是）、是否上架（是）

按服务修改时间降序排序

6.2.1.2 接口设计

接口名称：首页热门服务列表

接口路径：GET/foundations/customer/serve/hotServeList

6.2.2 热门服务列表实现

6.2.2.1 mapper

在com.jzo2o.foundations.mapper.ServeMapper接口中

java 复制代码

List<ServeAggregationSimpleResDTO> queryHotServeListByRegionId(@Param("regionId") Long regionId);

xml

xml 复制代码

<select id="queryHotServeListByRegionId"
        resultType="com.jzo2o.foundations.model.dto.response.ServeAggregationSimpleResDTO">
    SELECT
        serve.city_code,
        item.NAME serve_item_name,
        item.id serve_item_id,
        item.unit,
        item.detail_img,
        serve.price,
        item.img serve_item_img,
        serve.id id
    FROM
        serve
            INNER JOIN serve_item AS item ON item.id = serve.serve_item_id
    WHERE
        serve.region_id = 1686303222843662337
      AND serve.sale_status = 2
      AND serve.is_hot=1
    ORDER BY
        serve.update_time DESC
</select>

6.2.2.2 service

在com.jzo2o.foundations.service.HomeService接口中接口

java 复制代码

List<ServeAggregationSimpleResDTO> queryHotServeListByRegionId(Long regionId);

实现

java 复制代码

@Override
public List<ServeAggregationSimpleResDTO> queryHotServeListByRegionId(Long regionId) {
    //1.校验当前城市是否为启用状态
    Region region = regionService.getById(regionId);
    if (ObjectUtil.isEmpty(region) || ObjectUtil.equal(FoundationStatusEnum.DISABLE.getStatus(), region.getActiveStatus())) {
        return Collections.emptyList();
    }
    //2.根据城市编码查询所有的热门服务
    List<ServeAggregationSimpleResDTO> list = serveMapper.queryHotServeListByRegionId(regionId);
    if (ObjectUtil.isEmpty(list)) {
        return Collections.emptyList();
    }
    return list;
}

6.2.2.3 controller

java 复制代码

@GetMapping("/hotServeList")
@ApiOperation("热门服务列表")
@ApiImplicitParams({
        @ApiImplicitParam(name = "regionId", value = "区域id", required = true, dataTypeClass = Long.class)
})
public List<ServeAggregationSimpleResDTO> hotServeList(@RequestParam("regionId") Long regionId) {
    List<ServeAggregationSimpleResDTO> serveCategoryResDTOS = homeService.queryHotServeListByRegionId(regionId);
    return serveCategoryResDTOS;
}

6.2.2.4 测试

6.2.3 热门服务列表缓存

6.2.3.1 缓存方案分析

查询缓存：查询热门服务列表，如果缓存没有则查询数据库并缓存，如果缓存有则直接返回

注意：缓存时需要考虑缓存穿透问题。

禁用区域：删除热门服务列表缓存

定时任务：每天凌晨缓存热门服务列表。

6.2.3.2 查询缓存

java 复制代码

@Caching(
        cacheable = {
                //result为null时,属于缓存穿透情况，缓存时间30分钟
                @Cacheable(value = RedisConstants.CacheName.HOT_SERVE, key = "#regionId", unless = "#result.size() != 0", cacheManager = RedisConstants.CacheManager.THIRTY_MINUTES),
                //result不为null时,永久缓存
                @Cacheable(value = RedisConstants.CacheName.HOT_SERVE, key = "#regionId", unless = "#result.size() == 0", cacheManager = RedisConstants.CacheManager.FOREVER)
        }
)
@Override
public List<ServeAggregationSimpleResDTO> queryHotServeListByRegionId(Long regionId) {
    //1.校验当前城市是否为启用状态
    Region region = regionService.getById(regionId);
    if (ObjectUtil.isEmpty(region) || ObjectUtil.equal(FoundationStatusEnum.DISABLE.getStatus(), region.getActiveStatus())) {
        return Collections.emptyList();
    }

6.2.3.3 查询缓存测试

6.2.3.4 定时任务更新缓存

在com.jzo2o.foundations.handler.SpringCacheSynHandler中

java 复制代码

//删除该区域下的首页服务列表
String serve_type_key = RedisConstants.CacheName.SERVE_ICON + "::" + regionId;
redisTemplate.delete(serve_type_key);
homeService.queryServeIconCategoryByRegionIdCache(regionId);
//删除该区域下的服务类型列表缓存
String serve_icon_key = RedisConstants.CacheName.SERVE_TYPE + "::" + regionId;
redisTemplate.delete(serve_icon_key);
homeService.queryServeTypeByRegionIdCache(regionId);
//删除该区域下的热门服务列表缓存
String hot_serve_key = RedisConstants.CacheName.HOT_SERVE + "::" + regionId;
redisTemplate.delete(hot_serve_key);
homeService.queryHotServeListByRegionId(regionId);

6.2.3.5 禁用区域时删除缓存

java 复制代码

@Override
@Caching(evict = {
        @CacheEvict(value = RedisConstants.CacheName.JZ_CACHE, key = "'ACTIVE_REGIONS'"),
        @CacheEvict(value = RedisConstants.CacheName.SERVE_ICON, key = "#id"),
        @CacheEvict(value = RedisConstants.CacheName.HOT_SERVE, key = "#id"),
})
public void deactivate(Long id) {
    //区域信息
    Region region = baseMapper.selectById(id);

6.3 服务详情

6.3.1 分析设计

6.3.1.1 界面原型

在首页服务列表区域、热门服务列表区域以及全部服务界面，点击服务项名称进入服务详情页面，如下图：

服务详情页面显示服务相关的信息包括：服务项的名称、服务的运营价格、服务项的图片、服务项名称、价格单位。信息来源于serve_item表和serve表。

6.3.1.2 接口设计

接口名称：根据id查询服务

接口路径：GET/foundations/customer/serve/{id}

请求参数：服务id，即serve表的主键

6.3.2 服务详情实现

6.3.2.1 mapper

在com.jzo2o.foundations.mapper.ServeMapper接口中

java 复制代码

List<ServeAggregationSimpleResDTO> queryServeDetailById(@Param("id") Long id);

xml

xml 复制代码

<select id="queryServeDetailById"
        resultType="com.jzo2o.foundations.model.dto.response.ServeAggregationSimpleResDTO">
    SELECT
        serve.city_code,
        item.NAME serve_item_name,
        item.id serve_item_id,
        item.unit,
        item.detail_img,
        serve.price,
        item.img serve_item_img,
        serve.id id
    FROM
        serve
            INNER JOIN serve_item AS item ON item.id = serve.serve_item_id
    WHERE
        serve.id = #{id}
      AND serve.sale_status = 2
</select>

6.3.2.2 service

在com.jzo2o.foundations.service.HomeService接口中接口

java 复制代码

List<ServeAggregationSimpleResDTO> queryServeDetail(Long id);

实现

java 复制代码

@Override
public List<ServeAggregationSimpleResDTO> queryServeDetail(Long id) {
    return serveMapper.queryServeDetailById(id);
}

6.3.2.3 controller

java 复制代码

@GetMapping("/{id}")
@ApiOperation("服务详情")
@ApiImplicitParams({
        @ApiImplicitParam(name = "id", value = "服务id", required = true, dataTypeClass = Long.class)
})
public List<ServeAggregationSimpleResDTO> serveDetail(@PathVariable("id") Long id) {
    List<ServeAggregationSimpleResDTO> serveCategoryResDTOS = homeService.queryServeDetail(id);
    return serveCategoryResDTOS;
}

6.3.2.4 测试

6.3.3 服务详情缓存

6.2.3.1 缓存方案分析

服务详情信息来源于两部分信息：服务项信息、服务信息。

分别对服务项信息、服务信息进行缓存，方案如下：

服务项信息	缓存1天	String	JZ_CACHE:SERVE_ITEM::服务项id	启动：添加缓存禁用：删除缓存修改: 修改缓存
服务信息	缓存1天	String	JZ_CACHE:SERVE_RECORD::服务id	上架：添加缓存下架：删除缓存修改: 修改缓存

6.2.3.2 缓存信息

1) 缓存服务信息

启动详情，com.jzo2o.foundations.service.impl.HomeServiceImpl#queryServeDetail

java 复制代码

@Caching(
        cacheable = {
                //result为null时,属于缓存穿透情况，缓存时间30分钟
                @Cacheable(value = RedisConstants.CacheName.SERVE, key = "#id", unless = "#result.size() != 0", cacheManager = RedisConstants.CacheManager.THIRTY_MINUTES),
                //result不为null时,永久缓存
                @Cacheable(value = RedisConstants.CacheName.SERVE, key = "#id", unless = "#result.size() == 0", cacheManager = RedisConstants.CacheManager.ONE_DAY)
        }
)
@Override
public List<ServeAggregationSimpleResDTO> queryServeDetail(Long id) {
    return serveMapper.queryServeDetailById(id);
}

上架，com.jzo2o.foundations.service.impl.ServeServiceImpl#onSale

java 复制代码

@Override
@Transactional
@CachePut(value = RedisConstants.CacheName.SERVE, key = "#id",unless = "#result.saleStatus != 2",  cacheManager = RedisConstants.CacheManager.ONE_DAY)
public Serve onSale(Long id){
    Serve serve = baseMapper.selectById(id);
    if(ObjectUtil.isNull(serve)){
        throw new ForbiddenOperationException("区域服务不存在");

禁用，com.jzo2o.foundations.service.impl.ServeServiceImpl#offSale

java 复制代码

@Override
@Transactional
@CacheEvict(value = RedisConstants.CacheName.SERVE, key = "#id")
public Serve offSale(Long id){
    Serve serve = baseMapper.selectById(id);
    if(ObjectUtil.isNull(serve)){
        throw new ForbiddenOperationException("区域服务不存在");

修改，com.jzo2o.foundations.service.impl.ServeServiceImpl#update

java 复制代码

@Override
@Transactional
@CacheEvict(value = RedisConstants.CacheName.SERVE, key = "#id")
public Serve update(Long id, BigDecimal price) {
    //1.更新服务价格
    LambdaUpdateWrapper<Serve> updateWrapper = Wrappers.<Serve>lambdaUpdate()
            .eq(Serve::getId, id)
            .set(Serve::getPrice, price);

2) 缓存服务项信息

启用，com.jzo2o.foundations.service.impl.ServeItemServiceImpl#activate

@Override
@Transactional
@CachePut(value = RedisConstants.CacheName.SERVE_ITEM, key = "#id", cacheManager = RedisConstants.CacheManager.ONE_DAY)
public ServeItem activate(Long id) {

    //查询服务项
    ServeItem serveItem = baseMapper.selectById(id);
    if (ObjectUtil.isNull(serveItem)) {
        throw new ForbiddenOperationException("服务项不存在");

禁用，com.jzo2o.foundations.service.impl.ServeItemServiceImpl#deactivate

java 复制代码

@Override
@Transactional
@CacheEvict(value = RedisConstants.CacheName.SERVE_ITEM, key = "#id", beforeInvocation = true)
public void deactivate(Long id) {
    //查询服务项
    ServeItem serveItem = baseMapper.selectById(id);
    if (ObjectUtil.isNull(serveItem)) {
        throw new ForbiddenOperationException("服务项不存在");

修改，com.jzo2o.foundations.service.impl.ServeItemServiceImpl#update

java 复制代码

@Override
@Transactional
@CachePut(value = RedisConstants.CacheName.SERVE_ITEM, key = "#id", unless = "#result.saleStatus != 2", cacheManager = RedisConstants.CacheManager.ONE_DAY)
public ServeItem update(Long id, ServeItemUpsertReqDTO serveItemUpsertReqDTO) {
    //1.更新服务项
    ServeItem serveItem = BeanUtil.toBean(serveItemUpsertReqDTO, ServeItem.class);
    serveItem.setId(id);
    baseMapper.updateById(serveItem);