【前言】

Day05 的 Task 是 Redis 的入门，了解 Redis 数据类型、常用命令，如何在Java中使用Redis，以及 Redis 在项目中的应用场景，通过项目案例使用 Redis。

Contents

• Redis入门
• Redis数据类型
• Redis常用命令
• 在Java中操作redis
• 店铺营业状态设置

Redis入门

1. 简介：Redis是一个基于内存的key-value结构数据库。Redis 是互联网技术领域使用最为广泛的存储中间件。

2. 主要特点：

• 基于内存存储，读写性能高
• 适合存储热点数据（热点商品、资讯、新闻）
• 企业应用广泛

Redis是用C语言开发的一个开源的高性能键值对(key-value)数据库，官方提供的数据是可以达到100000+的QPS（每秒内查询次数）。它存储的value类型比较丰富，也被称为结构化的NoSql数据库。

NoSql（Not Only SQL），不仅仅是SQL，泛指非关系型数据库。NoSql数据库并不是要取代关系型数据库，而是关系型数据库的补充。

3. Redis服务启动与停止：

windows 版 Redis 服务启动命令：redis-server.exe redis.windows.conf

Redis服务默认端口号为 6379 ，通过快捷键Ctrl + C 即可停止Redis服务

当Redis服务启动成功后，可通过客户端进行连接。客户端连接命令：redis-cli.exe

通过redis-cli.exe命令默认连接的是本地的redis服务，并且使用默认6379端口。也可以通过指定如下参数连接：

• -h ip地址

• -p 端口号

• -a 密码（如果需要）

4. 修改Redis配置文件：

若要设置Redis服务密码，修改redis.windows.conf

requirepass 123456

注意：

• 修改密码后需要重启Redis服务才能生效
• Redis配置文件中 # 表示注释

重启Redis后，再次连接Redis时，需加上密码，否则连接失败。

Redis数据类型

1. 五种常用数据类型介绍

Redis存储的是key-value结构的数据，其中key是字符串类型，value有5种常用的数据类型：

• 字符串 string
• 哈希 hash
• 列表 list
• 集合 set
• 有序集合 sorted set / zset

2. 数据类型特点：

解释说明：

• 字符串(string)：普通字符串，Redis中最简单的数据类型
• 哈希(hash)：也叫散列，类似于Java中的HashMap结构
• 列表(list)：按照插入顺序排序，可以有重复元素，类似于Java中的LinkedList
• 集合(set)：无序集合，没有重复元素，类似于Java中的HashSet
• 有序集合(sorted set/zset)：集合中每个元素关联一个分数(score)，根据分数升序排序，没有重复元素

Redis常用命令

以下只介绍 常用的 命令，更多命令可以参考Redis中文网：https://www.redis.net.cn

字符串操作命令

Redis 中字符串类型常用命令：

• SET key value 设置指定key的值
• GET key 获取指定key的值
• SETEX key seconds value 设置指定key的值，并将 key 的过期时间设为 seconds 秒
• SETNX key value 只有在 key 不存在时设置 key 的值

哈希操作命令

Redis hash 是一个string类型的 field 和 value 的映射表，hash特别适合用于存储对象，常用命令：

• HSET key field value 将哈希表 key 中的字段 field 的值设为 value
• HGET key field 获取存储在哈希表中指定字段的值
• HDEL key field 删除存储在哈希表中的指定字段
• HKEYS key 获取哈希表中所有字段
• HVALS key 获取哈希表中所有值

列表操作命令

Redis 列表是简单的字符串列表，按照插入顺序排序，常用命令：

• LPUSH key value1 [value2] 将一个或多个值插入到列表头部
• LRANGE key start stop 获取列表指定范围内的元素
• RPOP key 移除并获取列表最后一个元素
• LLEN key 获取列表长度
• BRPOP key1 [key2 ] timeout 移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超 时或发现可弹出元素为止

集合操作命令

Redis set 是string类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据，常用命令：

• SADD key member1 [member2] 向集合添加一个或多个成员
• SMEMBERS key 返回集合中的所有成员
• SCARD key 获取集合的成员数
• SINTER key1 [key2] 返回给定所有集合的交集
• SUNION key1 [key2] 返回所有给定集合的并集
• SREM key member1 [member2] 移除集合中一个或多个成员

有序集合操作命令

Redis有序集合是string类型元素的集合，且不允许有重复成员。每个元素都会关联一个double类型的分数。常用命令：

常用命令：

• ZADD key score1 member1 [score2 member2] 向有序集合添加一个或多个成员
• ZRANGE key start stop [WITHSCORES] 通过索引区间返回有序集合中指定区间内的成员
• ZINCRBY key increment member 有序集合中对指定成员的分数加上增量 increment
• ZREM key member [member …] 移除有序集合中的一个或多个成员

通用命令

Redis的通用命令是不分数据类型的，都可以使用的命令：

• KEYS pattern 查找所有符合给定模式( pattern)的 key
• EXISTS key 检查给定 key 是否存在
• TYPE key 返回 key 所储存的值的类型
• DEL key 该命令用于在 key 存在是删除 key

在Java中操作redis

Redis的Java客户端：Spring Data Redis

Spring Data Redis 是 Spring 的一部分，提供了在 Spring 应用中通过简单的配置就可以访问 Redis 服务，对 Redis 底层开发包进行了高度封装。在 Spring 项目中，可以使用Spring Data Redis来简化 Redis 操作。

Spring Boot提供了对应的Starter，maven坐标：

<dependency>    <groupId>org.springframework.boot</groupId>    <artifactId>spring-boot-starter-data-redis</artifactId></dependency>

Spring Data Redis中提供了一个高度封装的类：RedisTemplate，对相关api进行了归类封装,将同一类型操作封装为operation接口，具体分类如下：

• ValueOperations：string数据操作
• SetOperations：set类型数据操作
• ZSetOperations：zset类型数据操作
• HashOperations：hash类型的数据操作
• ListOperations：list类型的数据操作

环境搭建

进入到sky-server模块

1). 导入Spring Data Redis的maven坐标

<dependency>     <groupId>org.springframework.boot</groupId>     <artifactId>spring-boot-starter-data-redis</artifactId></dependency>

2). 配置Redis数据源

在application-dev.yml中添加

sky:  redis:    host: localhost    port: 6379    password: 123456    database: 10

解释说明：

database:指定使用Redis的哪个数据库，Redis服务启动后默认有16个数据库，编号分别是从0到15。

可以通过修改Redis配置文件来指定数据库的数量。

在application.yml中添加读取application-dev.yml中的相关Redis配置

spring:  profiles:    active: dev  redis:    host: ${sky.redis.host}    port: ${sky.redis.port}    password: ${sky.redis.password}    database: ${sky.redis.database}

3). 编写配置类，创建RedisTemplate对象

package com.sky.config;import lombok.extern.slf4j.Slf4j;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.data.redis.connection.RedisConnectionFactory;import org.springframework.data.redis.core.RedisTemplate;import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;import org.springframework.data.redis.serializer.StringRedisSerializer;@Configuration@Slf4jpublic class RedisConfiguration {    @Bean    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {        log.info("开始创建RedisTemplate模板对象...");        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();        redisTemplate.setConnectionFactory(redisConnectionFactory);                // Key序列化器（String类型，避免Key乱码）        redisTemplate.setKeySerializer(new StringRedisSerializer());        // Value序列化器（JSON格式，支持对象、集合等复杂类型，且可读性好）        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());        // Hash结构的Key序列化器        redisTemplate.setHashKeySerializer(new StringRedisSerializer());        // Hash结构的Value序列化器        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());                redisTemplate.afterPropertiesSet(); // 初始化RedisTemplate        return redisTemplate;    }}

解释说明：

当前配置类不是必须的，因为 Spring Boot 框架会自动装配 RedisTemplate 对象，但是默认的key序列化器为

JdkSerializationRedisSerializer，导致我们存到Redis中后的数据和原始数据有差别，故设置为

StringRedisSerializer序列化器。

注：

• RedisTemplate是泛型类（RedisTemplate<K, V>），若未指定泛型类型（如<String, Object>），编译器会因 “原始类型使用”“未检查调用” 报警告。这些警告虽不影响运行，但会降低代码规范性，且可能隐藏潜在类型转换问题。

• **解决方法：**修改RedisConfiguration类中的redisTemplate方法，指定泛型为<String, Object>（Redis 的 Key 通常为 String，Value 为任意对象），并完善序列化器配置（避免 Redis 存储数据时出现乱码）。

• 泛型<String, Object>的指定，消除了 “原始类型使用”“未检查调用” 的警告。

• 完善的序列化器配置（StringRedisSerializer+GenericJackson2JsonRedisSerializer），确保 Redis 中 Key、Value 的存储格式清晰（避免乱码），且支持对象、集合等复杂类型的序列化 / 反序列化。

4). 通过RedisTemplate对象操作Redis

在test下新建测试类

package com.sky.test;import org.junit.jupiter.api.Test;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.boot.test.context.SpringBootTest;import org.springframework.data.redis.core.*;@SpringBootTestpublic class SpringDataRedisTest {    @Autowired    private RedisTemplate redisTemplate;    @Test    public void testRedisTemplate(){        System.out.println(redisTemplate);        //string数据操作        ValueOperations valueOperations = redisTemplate.opsForValue();        //hash类型的数据操作        HashOperations hashOperations = redisTemplate.opsForHash();        //list类型的数据操作        ListOperations listOperations = redisTemplate.opsForList();        //set类型数据操作        SetOperations setOperations = redisTemplate.opsForSet();        //zset类型数据操作        ZSetOperations zSetOperations = redisTemplate.opsForZSet();    }}

测试：

说明RedisTemplate对象注入成功，并且通过该RedisTemplate对象获取操作5种数据类型相关对象。

操作常见类型数据

1). 操作字符串类型数据

/**    * 操作字符串类型的数据    */   @Test   public void testString(){       // set get setex setnx       redisTemplate.opsForValue().set("name","小明");       String city = (String) redisTemplate.opsForValue().get("name");       System.out.println(city);       redisTemplate.opsForValue().set("code","1234",3, TimeUnit.MINUTES);       redisTemplate.opsForValue().setIfAbsent("lock","1");       redisTemplate.opsForValue().setIfAbsent("lock","2");   }

2). 操作哈希类型数据

/**    * 操作哈希类型的数据    */   @Test   public void testHash(){       //hset hget hdel hkeys hvals       HashOperations hashOperations = redisTemplate.opsForHash();       hashOperations.put("100","name","tom");       hashOperations.put("100","age","20");       String name = (String) hashOperations.get("100", "name");       System.out.println(name);       Set keys = hashOperations.keys("100");       System.out.println(keys);       List values = hashOperations.values("100");       System.out.println(values);       hashOperations.delete("100","age");   }

3). 操作列表类型数据

/**    * 操作列表类型的数据    */   @Test   public void testList(){       //lpush lrange rpop llen       ListOperations listOperations = redisTemplate.opsForList();       listOperations.leftPushAll("mylist","a","b","c");       listOperations.leftPush("mylist","d");       List mylist = listOperations.range("mylist", 0, -1);       System.out.println(mylist);       listOperations.rightPop("mylist");       Long size = listOperations.size("mylist");       System.out.println(size);   }

4). 操作集合类型数据

/**    * 操作集合类型的数据    */   @Test   public void testSet(){       //sadd smembers scard sinter sunion srem       SetOperations setOperations = redisTemplate.opsForSet();       setOperations.add("set1","a","b","c","d");       setOperations.add("set2","a","b","x","y");       Set members = setOperations.members("set1");       System.out.println(members);       Long size = setOperations.size("set1");       System.out.println(size);       Set intersect = setOperations.intersect("set1", "set2");       System.out.println(intersect);       Set union = setOperations.union("set1", "set2");       System.out.println(union);       setOperations.remove("set1","a","b");   }

5). 操作有序集合类型数据

/**    * 操作有序集合类型的数据    */   @Test   public void testZset(){       //zadd zrange zincrby zrem       ZSetOperations zSetOperations = redisTemplate.opsForZSet();       zSetOperations.add("zset1","a",10);       zSetOperations.add("zset1","b",12);       zSetOperations.add("zset1","c",9);       Set zset1 = zSetOperations.range("zset1", 0, -1);       System.out.println(zset1);       zSetOperations.incrementScore("zset1","c",10);       zSetOperations.remove("zset1","a","b");   }

6). 通用命令操作

/**    * 通用命令操作    */   @Test   public void testCommon(){       //keys exists type del       Set keys = redisTemplate.keys("*");       System.out.println(keys);       Boolean name = redisTemplate.hasKey("name");       Boolean set1 = redisTemplate.hasKey("set1");       for (Object key : keys) {           DataType type = redisTemplate.type(key);           System.out.println(type.name());       }       redisTemplate.delete("mylist");   }

店铺营业状态设置

需求分析与接口设计

• 进到苍穹外卖后台，显示餐厅的营业状态，营业状态分为营业中和打烊中，若当前餐厅处于营业状态，自动接收任何订单，客户可在小程序进行下单操作；若当前餐厅处于打烊状态，不接受任何订单，客户便无法在小程序进行下单操作。

产品原型：

接口设计：

• 设置营业状态
• 管理端查询营业状态
• 用户端查询营业状态

**注：**从技术层面分析，其实管理端和用户端查询营业状态时，可通过一个接口去实现即可。因为营业状态是一致的。但是，本项目约定：

• 管理端发出的请求，统一使用/admin作为前缀。
• 用户端发出的请求，统一使用/user作为前缀。

因为访问路径不一致，故分为两个接口实现。

1). 设置营业状态

2). 管理端营业状态

3). 用户端营业状态

营业状态存储方式

虽然，可以通过一张表来存储营业状态数据，但整个表中只有一个字段，所以意义不大。

营业状态数据存储方式：基于Redis的字符串来进行存储。**约定：**1表示营业 0表示打烊。

代码编写

admin/ShopController.java

package com.sky.controller.admin;import com.sky.result.Result;import io.swagger.annotations.Api;import io.swagger.annotations.ApiOperation;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.data.redis.core.RedisTemplate;import org.springframework.web.bind.annotation.*;@RestController("adminShopController")@RequestMapping("admin/shop")@Slf4j@Api(tags = "管理端-商铺相关接口")public class ShopController {    private final static String KEY = "SHOP_STATUS_";    @Autowired    private RedisTemplate<String, Object> redisTemplate;    /**     * 设置店铺营业状态     *     * @param status 店铺状态 0-打烊 1-营业     * @return 无     */    @PutMapping("/{status}")    @ApiOperation("设置店铺营业状态")    public Result<Void> setStatus(@PathVariable Integer status) {        log.info("设置店铺营业状态：{}", (status == 1 ? "营业" : "打烊"));        // 将店铺状态存入 Redis        redisTemplate.opsForValue().set(KEY, status);        return Result.success();    }    /**     * 获取店铺营业状态     *     * @return 店铺状态 0-打烊 1-营业     */    @ApiOperation("获取店铺营业状态")    @GetMapping("/status")    public Result<Integer> getStatus() {        Integer status = (Integer) redisTemplate.opsForValue().get(KEY);        log.info("获取店铺营业状态：{}", (status != null && status == 1 ? "营业" : "打烊"));        return Result.success(status);    }}

user/ShopController.java

package com.sky.controller.user;import com.sky.result.Result;import io.swagger.annotations.Api;import io.swagger.annotations.ApiOperation;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.data.redis.core.RedisTemplate;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;@RestController@RequestMapping("user/shop")@Slf4j@Api(tags = "用户端-商铺相关接口")public class ShopController {    private static final String KEY = "SHOP_STATUS_";    @Autowired    private RedisTemplate<String, Object> redisTemplate;    /**     * 获取店铺营业状态     *     * @return 店铺状态 0-打烊 1-营业     */    @GetMapping("/status")    @ApiOperation("获取店铺营业状态")    public Result<Integer> getStatus() {        Integer status = (Integer) redisTemplate.opsForValue().get(KEY);        log.info("获取店铺营业状态：{}", (status != null && status == 1 ? "营业" : "打烊"));        return Result.success(status);    }}

功能测试

注意！： 测试时记得要把Redis服务开启，否则连接不到Redis，数据都存不了，更别谈测试了。

在接口文档测试中，管理端和用户端的接口放在一起，不方便区分。

接下来，我们要实现管理端和用户端接口进行区分。

在WebMvcConfiguration.java中，分别扫描”com.sky.controller.admin”和”com.sky.controller.user”这两个包。

@Bean   public Docket docket1(){       log.info("准备生成接口文档...");       ApiInfo apiInfo = new ApiInfoBuilder()               .title("苍穹外卖项目接口文档")               .version("2.0")               .description("苍穹外卖项目接口文档")               .build();       Docket docket = new Docket(DocumentationType.SWAGGER_2)               .groupName("管理端接口")               .apiInfo(apiInfo)               .select()               //指定生成接口需要扫描的包               .apis(RequestHandlerSelectors.basePackage("com.sky.controller.admin"))               .paths(PathSelectors.any())               .build();       return docket;   }   @Bean   public Docket docket2(){       log.info("准备生成接口文档...");       ApiInfo apiInfo = new ApiInfoBuilder()               .title("苍穹外卖项目接口文档")               .version("2.0")               .description("苍穹外卖项目接口文档")               .build();       Docket docket = new Docket(DocumentationType.SWAGGER_2)               .groupName("用户端接口")               .apiInfo(apiInfo)               .select()               //指定生成接口需要扫描的包               .apis(RequestHandlerSelectors.basePackage("com.sky.controller.user"))               .paths(PathSelectors.any())               .build();       return docket;   }

重启服务器，再次访问接口文档，可进行选择用户端接口或者管理端接口

设置状态测试：

获取状态测试：

日志查看

【前言】

Day04 的 Task 是套餐管理相关代码的开发 ，也是对多表业务的分析能力的锻炼

Contents

• 新增套餐
• 套餐分页查询
• 删除套餐
• 修改套餐
• 起售停售套餐

1. 新增套餐

需求分析与接口设计

业务规则：

• 套餐名称唯一
• 套餐必须属于某个分类
• 套餐必须包含菜品
• 名称、分类、价格、图片为必填项
• 添加菜品窗口需要根据分类类型来展示菜品
• 新增的套餐默认为停售状态

接口设计（共涉及到 4 个接口）：

• 根据类型查询分类（已完成）
• 根据分类 id 查询菜品
• 图片上传（已完成）
• 新增套餐

产品原型：

可以看到，在新增套餐中还涉及到了菜品的一个接口，就是 根据分类 id 查询菜品并列出菜品，所以需要在 DishController 再加一个接口 来根据分类 id 展示菜品（list）

接口设计：

表设计：

setmeal 表为套餐表，用于存储套餐的信息。具体表结构如下：

setmeal_dish 表为套餐菜品关系表，用于存储套餐和菜品的关联关系。具体表结构如下：

流程分析

代码编写

1）根据分类 id 查询并列出菜品

DishController.java

/** * 根据分类条件查询列出菜品 * @param categoryId 分类id * @return 菜品列表 */@GetMapping("/list")@ApiOperation("根据分类条件查询并列出菜品")public Result<List<Dish>> list(Long categoryId) {    log.info("根据分类条件查询并列出菜品: {}", categoryId);    List<Dish> dishList = dishService.list(categoryId);    return Result.success(dishList);}

DishServiceImpl.java

这里注意 status 状态是 ENABLE，一开始写成 DISABLE 了，没有菜品列出，后面发现是状态设置错了。

/** * 根据分类条件查询列出菜品 * @param categoryId 分类id * @return 菜品列表 */@Overridepublic List<Dish> list(Long categoryId) {    Dish dish = Dish.builder()            .status(StatusConstant.ENABLE) // 注意这里是只查询起售状态的菜品            .categoryId(categoryId)            .build();    return dishMapper.list(dish);}

DishMapper.java

/** * 动态条件查询菜品 * @param dish 条件 * @return 菜品列表 */List<Dish> list(Dish dish);

DishMapper.xml

<select id="list" resultType="com.sky.entity.Dish">    select * from dish    <where>        <if test="name != null and name != ''">            and name like concat('%', #{name}, '%')        </if>        <if test="categoryId != null">            and category_id = #{categoryId}        </if>        <if test="status != null">            and status = #{status}        </if>    </where>    order by create_time desc</select>

2）新增套餐

SetmealController.java

package com.sky.controller.admin;import com.sky.dto.SetmealDTO;import com.sky.result.Result;import com.sky.service.SetmealService;import io.swagger.annotations.Api;import io.swagger.annotations.ApiOperation;import lombok.extern.slf4j.Slf4j;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.PostMapping;import org.springframework.web.bind.annotation.RequestBody;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;@RestController@Api(tags = "套餐管理")@RequestMapping("admin/setmeal")@Slf4jpublic class SetmealController {    @Autowired    private SetmealService setmealService;    /**     * 新增套餐     * @param setmealDTO 套餐信息     * @return 结果     */    @PostMapping    @ApiOperation("新增套餐")    public Result<Void> save(@RequestBody SetmealDTO setmealDTO) { // 这里要加 @RequestBody 将前端传递的json数据转换为java对象        log.info("新增套餐: {}", setmealDTO);        setmealService.saveWithDish(setmealDTO);        return Result.success();    }}

SetmealServiceImpl.java

package com.sky.service.impl;import com.sky.dto.SetmealDTO;import com.sky.entity.Setmeal;import com.sky.entity.SetmealDish;import com.sky.mapper.SetmealDishMapper;import com.sky.mapper.SetmealMapper;import com.sky.service.SetmealService;import org.springframework.beans.BeanUtils;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import java.util.List;@Servicepublic class SetmealServiceImpl implements SetmealService {    @Autowired    private SetmealMapper setmealMapper;    @Autowired    private SetmealDishMapper setmealDishMapper;    /**     * 新增套餐     * @param setmealDTO 套餐信息     */    @Override    public void saveWithDish(SetmealDTO setmealDTO) {        Setmeal setmeal = new Setmeal();        BeanUtils.copyProperties(setmealDTO, setmeal);        // 1. 向setmeal表插入套餐        setmealMapper.insert(setmeal);        // 2. 向setmeal_dish表插入套餐和菜品的关联关系        // 先获取套餐id        Long setmealId = setmeal.getId();        // 再获取套餐和菜品的关联关系        List<SetmealDish> setmealDishes = setmealDTO.getSetmealDishes();        // 设置套餐id        setmealDishes.forEach(setmealDish -> setmealDish.setSetmealId(setmealId));        // 批量插入套餐和菜品的关联关系        setmealDishMapper.insertBatch(setmealDishes);    }}

SetmealMapper.java

/** * 插入套餐, 并且将主键回填到实体类对象中 (useGeneratedKeys = true, keyProperty = "id") * @param setmeal 套餐 */@AutoFill(value = OperationType.INSERT)void insert(Setmeal setmeal);

SetmealMapper.xml

<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"        "http://mybatis.org/dtd/mybatis-3-mapper.dtd" ><mapper namespace="com.sky.mapper.SetmealMapper">    <insert id="insert" useGeneratedKeys="true" keyProperty="id">        insert into setmeal (category_id, name, price, description, image, create_time, update_time, create_user, update_user)        values        (#{categoryId}, #{name}, #{price}, #{description}, #{image}, #{createTime}, #{updateTime}, #{createUser}, #{updateUser})    </insert></mapper>

SetmealDishMapper.java

/** * 批量插入套餐和菜品的关联关系 * @param setmealDishes 套餐和菜品的关联关系 */void insertBatch(List<SetmealDish> setmealDishes);

SetmealDishMapper.xml

<insert id="insertBatch">    insert into setmeal_dish (setmeal_id, dish_id, name, price, copies)    values    <foreach collection="setmealDishes" item="sd" separator=",">        (#{sd.setmealId}, #{sd.dishId}, #{sd.name}, #{sd.price}, #{sd.copies})    </foreach></insert>

功能测试

成功在表中插入数据

• 注意 这里有误！！后来在写删除套餐的时候才发现，插入时 status 不应该是 1，之前编写新增套餐代码的时候在 mapper 的 xml 映射文件遗漏了 status 字段，而且在 service 层忘记设置了初始状态为停售 DISABLE（也就是 0）

2. 套餐分页查询

需求分析与接口设计

业务规则：

• 根据页码进行分页展示
• 每页展示 10 条数据
• 可以根据需要，按照套餐名称、分类、售卖状态进行查询

产品原型

注意因为视图需要套餐对应的分类名称，所以分页时 Page 的泛型是 VO 对象，即 SetmealVO。

接口设计：

流程分析

代码编写

SetmealController.java

/** * 分页查询套餐 * @param setmealPageQueryDTO 分页查询参数 * @return 套餐分页结果 */@GetMapping("/page")@ApiOperation("分页查询套餐")public Result<PageResult> page(SetmealPageQueryDTO setmealPageQueryDTO) {    log.info("分页查询套餐: {}", setmealPageQueryDTO);    PageResult pageResult = setmealService.pageQuery(setmealPageQueryDTO);    return Result.success(pageResult);}

SetmealServiceImpl.java

/** * 分页查询套餐 * @param setmealPageQueryDTO 分页查询参数 * @return 套餐分页结果 */@Overridepublic PageResult pageQuery(SetmealPageQueryDTO setmealPageQueryDTO) {    PageHelper.startPage(setmealPageQueryDTO.getPage(), setmealPageQueryDTO.getPageSize());    Page<SetmealVO> page = setmealMapper.pageQuery(setmealPageQueryDTO);    return new PageResult(page.getTotal(), page.getResult());}

SetmealMapper.java

/** * 分页查询套餐 * @param setmealPageQueryDTO 分页查询参数 * @return 套餐分页结果 */Page<SetmealVO> pageQuery(SetmealPageQueryDTO setmealPageQueryDTO);

SetmealMapper.xml

<select id="pageQuery" resultType="com.sky.vo.SetmealVO">    select s.*, c.name as categoryName    from setmeal s left outer join category c    on s.category_id = c.id    <where>        <if test="name != null">            s.name like concat('%', #{name}, '%')        </if>        <if test="status != null">            and s.status = #{status}        </if>        <if test="categoryId != null">            and s.category_id = #{categoryId}        </if>    </where></select>

功能测试

3. 删除套餐

需求分析与接口设计

业务规则：

• 可以一次删除一个套餐，也可以批量删除套餐
• 起售中的套餐不能删除

接口设计：

流程分析

代码编写

SetmealController.java

/** * 删除套餐 * @param ids 套餐id集合 * @return 结果 */@DeleteMapping@ApiOperation("删除套餐")public Result<Void> delete(@RequestParam("ids") List<Long> ids) {    log.info("删除套餐: {}", ids);    setmealService.deleteWithDish(ids);    return Result.success();}

SetmealServiceImpl.java

/** * 删除套餐, 同时删除套餐和菜品的关联数据 * @param ids 套餐id集合 */@Overridepublic void deleteWithDish(List<Long> ids) {    // 起售中的套餐不能删除    // 1. 查询套餐状态, 确认是否可以删除    for (Long id : ids) {        Setmeal setmeal = setmealMapper.getById(id);        if (setmeal != null && Objects.equals(setmeal.getStatus(), StatusConstant.ENABLE)) { // 套餐起售中            throw new DeletionNotAllowedException(MessageConstant.SETMEAL_ON_SALE);        }    }    // 2. 删除套餐表中的数据    // delete from setmeal where id in (1,2,3)    setmealMapper.deleteByIds(ids);    // 3. 删除套餐和菜品的关联数据    // delete from setmeal_dish where setmeal_id in (1,2,3)    setmealDishMapper.deleteBySetmealIds(ids);}

SetmealMapper.java

/** * 根据id查询套餐  (用于删除套餐时, 查询套餐状态) * @param id 套餐id */@Select("select * from setmeal where id = #{id}")Setmeal getById(Long id);/** * 根据id删除套餐 * @param ids 套餐id集合 */void deleteByIds(List<Long> ids);

SetmealMapper.xml

<delete id="deleteByIds" parameterType="list">    delete from setmeal where id in    <foreach collection="ids" item="id" open="(" separator="," close=")">        #{id}    </foreach></delete>

SetmealDishMapper.java

/** * 根据套餐id删除对应的套餐和菜品的关联关系 * @param setmealIds 套餐id集合 */void deleteBySetmealIds(List<Long> setmealIds);

SetmealDishMapper.xml

<delete id="deleteBySetmealIds">    delete from setmeal_dish where setmeal_id in    <foreach collection="setmealIds" item="setmealId" open="(" separator="," close=")">        #{setmealId}    </foreach></delete>

功能测试

起售中无法删除

删除成功

4. 修改套餐

需求分析与接口设计

产品原型：

接口设计（共涉及到5个接口）：

• 根据id查询套餐
• 根据类型查询分类（已完成）
• 根据分类id查询菜品（已完成）
• 图片上传（已完成）
• 修改套餐

流程分析

代码编写

SetmealController.java

/** * 根据id查询套餐信息, 包括套餐和菜品的关联信息 * @param id 套餐id * @return 套餐信息 */@GetMapping("/{id}")@ApiOperation("根据id查询套餐信息(包括套餐和菜品的关联信息)")public Result<SetmealVO> getById(@PathVariable Long id) {  // 这里要加 @PathVariable 将路径参数中的id参数绑定到方法的id参数上    log.info("根据id查询套餐信息: {}", id);    SetmealVO setmealVO = setmealService.getByIdWithDishes(id);    return Result.success(setmealVO);}/** * 修改套餐(包括套餐和菜品的关联信息) * @param setmealDTO 套餐信息 * @return 结果 */@PutMapping@ApiOperation("修改套餐")public Result<Void> update(@RequestBody SetmealDTO setmealDTO) {  // 这里要加 @RequestBody 将前端传递的json数据转换为java对象    log.info("修改套餐: {}", setmealDTO);    setmealService.updateWithDish(setmealDTO);    return Result.success();}

SetmealServiceImpl.java

/** * 根据id查询套餐信息, 包括套餐和菜品的关联信息 * @param id 套餐id * @return 套餐信息 */@Overridepublic SetmealVO getByIdWithDishes(Long id) {    // 1. 查询套餐基本信息    Setmeal setmeal = setmealMapper.getById(id);    // 2. 查询套餐和菜品的关联信息    List<SetmealDish> setmealDishes = setmealDishMapper.getByIdWithDishes(id);    // 3. 将套餐基本信息与套餐菜品信息封装到VO对象中并返回    SetmealVO setmealVO = new SetmealVO();    BeanUtils.copyProperties(setmeal, setmealVO);    setmealVO.setSetmealDishes(setmealDishes);    return setmealVO;}/** * 修改套餐(包括套餐和菜品的关联信息) * @param setmealDTO 套餐信息 */@Overridepublic void updateWithDish(SetmealDTO setmealDTO) {    Setmeal setmeal = new Setmeal();    BeanUtils.copyProperties(setmealDTO, setmeal);    // 1. 首先，更新setmeal表中的基本信息    setmealMapper.updateById(setmeal);    // 2. 然后，更新setmeal_dish表中的关联信息    Long setmealId = setmeal.getId();    // 2.1 先删除原有的关联信息    setmealDishMapper.deleteBySetmealIds(List.of(setmealId));    // 2.2 再重新插入新的关联信息    List<SetmealDish> setmealDishes = setmealDTO.getSetmealDishes();    // 设置套餐id    setmealDishes.forEach(setmealDish -> setmealDish.setSetmealId(setmealId));    // 批量插入套餐和菜品的关联关系    setmealDishMapper.insertBatch(setmealDishes);}

SetmealMapper.java

/** * 根据id动态修改套餐信息 * @param setmeal 套餐信息 */@AutoFill(value = OperationType.UPDATE)void updateById(Setmeal setmeal);

SetmealMapper.xml

<update id="updateById">    update setmeal    <set>        <if test="categoryId != null">category_id = #{categoryId},</if>        <if test="name != null">name = #{name},</if>        <if test="price != null">price = #{price},</if>        <if test="status != null">status = #{status},</if>        <if test="description != null">description = #{description},</if>        <if test="image != null">image = #{image},</if>        update_time = #{updateTime},        update_user = #{updateUser}    </set>    where id = #{id}</update>

SetmealDishMapper.java

/** * 根据套餐id查询对应的套餐和菜品的关联关系 * @param setmealId 套餐id * @return 套餐和菜品的关联关系 */@Select("select * from setmeal_dish where setmeal_id = #{setmealId}")List<SetmealDish> getByIdWithDishes(Long setmealId);

功能测试

5. 起售停售套餐

需求分析与接口设计

业务规则：

• 可以对状态为起售的套餐进行停售操作，可以对状态为停售的套餐进行起售操作
• 起售的套餐可以展示在用户端，停售的套餐不能展示在用户端
• 起售套餐时，如果套餐内包含停售的菜品，则不能起售

接口设计：

流程分析

代码编写

SetmealController

/** * 起售/停售套餐 * @param status 状态 * @param id 套餐id集合 * @return 结果 */@PostMapping("/status/{status}")@ApiOperation("起售/停售套餐")public Result<Void> startOrStop(@PathVariable Integer status, Long id) {    log.info("起售/停售套餐: {}, {}", status, id);    setmealService.startOrStop(status, id);    return Result.success();}

SetmealServiceImpl

/** * 起售/停售套餐 * @param status 套餐状态 * @param id 套餐id */@Overridepublic void startOrStop(Integer status, Long id) {    // 如果要设置为起售，需要检查套餐内的菜品是否都为起售状态    if (Objects.equals(status, StatusConstant.ENABLE)) { // 要起售        // select a.* from dish a        // left join setmeal_dish b on a.id = b.dish_id where b.setmeal_id = ?;        List<Dish> dishList = dishMapper.getBySetmealId(id); // 查询套餐内的菜品        dishList.forEach(dish -> {            if (dish.getStatus().equals(StatusConstant.DISABLE)) {                throw new SetmealEnableFailedException(MessageConstant.SETMEAL_ENABLE_FAILED);            }        }); // 只要有一个菜品是停售状态, 就不能起售    }    // 可以起售，更新套餐状态    Setmeal setmeal = Setmeal.builder()            .id(id)            .status(status)            .build();    setmealMapper.updateById(setmeal);}

DishMapper

/** * 根据套餐id查询对应的菜品 * @param id 套餐id * @return 菜品列表 */@Select("select d.* from dish d " +        "left join setmeal_dish sd on d.id = sd.dish_id " +        "where sd.setmeal_id = #{id} ")List<Dish> getBySetmealId(Long id);

功能测试

【前言】
Day03 的 Task 是 公共字段自动填充 与 菜品管理相关功能 的代码开发，主要的菜品管理部分也是基础 CRUD 的练习，另外就是公共字段自动填充这种偏向技术一点的开发技巧的学习。

公共字段自动填充主要涉及到 枚举、注解、Spring的 AOP 、反射 的知识，用自定义注解实现了当执行 insert新增* 与 *update更新 时在Mapper层对创建人、创建时间和修改人、修改时间的字段的自动填充，避免了在Service设置属性的冗余重复代码。

剩余的菜品管理就是 CRUD 练习了， 只是相比前面的员工管理模块，菜品管理会涉及到菜品Dish与分类Category、套餐Setmeal的多表的联系，分析起来会更比员工管理的单表更复杂一点，要考虑的比较多，但是这部分练习能锻炼到我们对多表的业务功能的分析能力。

Contents

• 公共字段自动填充
• 新增菜品
• 菜品分页查询
• 删除菜品
• 修改菜品

1. 公共字段自动填充

公共字段问题引入

​前面在新增员工或者新增菜品分类时需要设置创建时间、创建人、修改时间、修改人等字段，在编辑员工或者编辑菜品分类时需要设置修改时间、修改人等字段。这些字段属于公共字段，很多表中都会有这些字段，如下：

对于这些字段，我们的赋值方式为：

1). 在新增数据时, 将createTime、updateTime 设置为当前时间, createUser、updateUser设置为当前登录用户ID。

2). 在更新数据时, 将updateTime 设置为当前时间, updateUser设置为当前登录用户ID。

代码层面，复制方式如下，通过set属性来设置这些公共字段的值

Insert时

Update时

如果都按照上述的操作方式来处理这些公共字段, 需要在每一个业务方法中进行操作, 编码相对冗余、繁琐，那能不能对于这些公共字段在某个地方统一处理，来简化开发呢？

• 答案是可以的，我们使用AOP切面编程，实现功能增强，来完成公共字段自动填充功能。

这样做的好处：

• 减少重复代码，提升开发效率；
• 保证字段赋值的一致性（如时间格式、操作人 ID 的来源统一）；
• 降低人为疏忽导致的字段遗漏风险。

实现思路

实现步骤：

1). 自定义注解 AutoFill，用于标识需要进行公共字段自动填充的方法

2). 自定义切面类 AutoFillAspect，统一拦截加入了 AutoFill 注解的方法，通过反射为公共字段赋值

3). 在 Mapper 的方法上加入 AutoFill 注解

实现上述步骤，需掌握以下知识

**技术点：**枚举、注解、AOP、反射

代码编写

1）编写注解，自定义注解AutoFill

在sky-server模块，创建com.sky.annotation包。

package com.sky.annotation;import com.sky.enumeration.OperationType;import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;/** * 自定义公共字段自动填充注解，用于标记需要自动填充公共字段的方法 */@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface AutoFill {    // 数据库操作类型，如插入或更新 INSERT, UPDATE    OperationType value();}

在初始项目的枚举包中已定义了操作类型枚举

2）编写切面类, 自定义AutoFillAspect切面

在sky-server模块，创建com.sky.aspect包。

package com.sky.aspect;import com.sky.annotation.AutoFill;import com.sky.constant.AutoFillConstant;import com.sky.context.BaseContext;import com.sky.enumeration.OperationType;import lombok.extern.slf4j.Slf4j;import org.aspectj.lang.JoinPoint;import org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;import org.aspectj.lang.annotation.Pointcut;import org.aspectj.lang.reflect.MethodSignature;import org.springframework.stereotype.Component;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import java.time.LocalDateTime;/** * 自定义切面类，处理公共字段自动填充逻辑 */@Aspect@Component@Slf4jpublic class AutoFillAspect {    /**     * 切入点，匹配所有标记了 @AutoFill 注解的方法     */    // 切入点表达式，匹配所有在 com.sky.mapper 包下的方法，并且这些方法上有 @AutoFill 注解    // execution(* com.sky.mapper.*.*(..)) 匹配 com.sky.mapper 包及其子包下的所有方法    // && @annotation(com.sky.annotation.AutoFill) 匹配那些被 @AutoFill 注解标记的方法    // 这样，任何调用 com.sky.mapper 包下的方法且这些方法被 @AutoFill 注解标记时，    // 都会触发这个切入点，从而可以在相应的通知中实现自动填充公共字段的逻辑    @Pointcut("execution(* com.sky.mapper.*.*(..)) && @annotation(com.sky.annotation.AutoFill)")    public void autoFillPointCut() {}    /**     * 前置通知，在切入点方法执行前，执行通知--进行公共字段自动填充逻辑 (反射 + AOP)     * @param joinPoint 连接点信息     */    @Before("autoFillPointCut()")    public void autoFill(JoinPoint joinPoint) {        log.info("自动填充公共字段...");        // 1.获取当前拦截方法的数据库操作类型（插入或更新）        // 注意这里自动导包的话要导入 org.aspectj.lang.reflect.MethodSignature，        // 不是 java.lang.reflect.MethodSignature        // 否则调用不了getMethod()方法        MethodSignature signature = (MethodSignature) joinPoint.getSignature();  // 获取方法签名        AutoFill annotation = signature.getMethod().getAnnotation(AutoFill.class);// 获取方法上的注解        OperationType operationType = annotation.value(); // 获取注解的值（操作类型）        // 2.获取当前拦截方法的参数对象（实体类对象）        Object[] args = joinPoint.getArgs(); // 获取方法参数        if (args == null || args.length == 0) {            return; // 如果没有参数，直接返回        }        Object entity = args[0]; // 项目约定第一个参数是实体类对象        // 3.根据操作类型，准备需要填充的公共字段及其值（如创建时间、更新时间、创建人、更新人等）        LocalDateTime now = LocalDateTime.now();        Long currentId = BaseContext.getCurrentId();        // 4.使用反射机制，给实体类对象的公共字段赋值（如创建时间、更新时间、创建人、更新人等）        if(operationType == OperationType.INSERT) {            // 插入操作，准备插入时需要填充的字段及其值 (四个字段)            try {                // 通过反射获取实体类的公共字段的set方法                Method setCreateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_USER, Long.class);                Method setCreateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_CREATE_TIME, LocalDateTime.class);                Method setUpdateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);                Method setUpdateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);                // 调用set方法，给实体类对象的公共字段赋值                setCreateUser.invoke(entity, currentId);                setCreateTime.invoke(entity, now);                setUpdateUser.invoke(entity, currentId);                setUpdateTime.invoke(entity, now);            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {                throw new RuntimeException(e);            }        } else if (operationType == OperationType.UPDATE) {            // 更新操作，准备更新时需要填充的字段及其值 (两个字段)            try {                // 通过反射获取实体类的公共字段的set方法                Method setUpdateUser = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_USER, Long.class);                Method setUpdateTime = entity.getClass().getDeclaredMethod(AutoFillConstant.SET_UPDATE_TIME, LocalDateTime.class);                // 调用set方法，给实体类对象的公共字段赋值                setUpdateUser.invoke(entity, currentId);                setUpdateTime.invoke(entity, now);            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {                throw new RuntimeException(e);            }        }    }}