苍穹外卖-缓存商品、购物车功能

目录

[1. 缓存菜品](#1. 缓存菜品)

[1.1 问题说明](#1.1 问题说明)

[1.2 实现思路](#1.2 实现思路)

[1.3 代码开发](#1.3 代码开发)

[1.4 功能测试](#1.4 功能测试)

​编辑

[2. 缓存套餐](#2. 缓存套餐)

[2.1 Spring Cache](#2.1 Spring Cache)

[2.1.1 介绍](#2.1.1 介绍)

[2.1.2 常用注解](#2.1.2 常用注解)

[2.1.3 入门案例](#2.1.3 入门案例)

[2.2 实现思路](#2.2 实现思路)

[2.3 代码开发](#2.3 代码开发)

[2.4 功能测试](#2.4 功能测试)

[3. 添加购物车](#3. 添加购物车)

[3.1 需求分析和设计](#3.1 需求分析和设计)

[3.1.1 产品原型](#3.1.1 产品原型)

[3.1.2 接口设计](#3.1.2 接口设计)

[3.1.3 表设计](#3.1.3 表设计)

[3.2 代码开发](#3.2 代码开发)

[3.2.1 DTO设计](#3.2.1 DTO设计)

[3.2.2 Controller层](#3.2.2 Controller层)

[3.2.3 Service层接口](#3.2.3 Service层接口)

[3.2.4 Service层实现类](#3.2.4 Service层实现类)

[3.2.5 Mapper层](#3.2.5 Mapper层)

[3.3 功能测试](#3.3 功能测试)

[4. 查看购物车](#4. 查看购物车)

[4.1 需求分析和设计](#4.1 需求分析和设计)

[4.1.1 产品原型](#4.1.1 产品原型)

[4.1.2 接口设计](#4.1.2 接口设计)

[4.2 代码开发](#4.2 代码开发)

[4.2.1 Controller层](#4.2.1 Controller层)

[4.2.2 Service层接口](#4.2.2 Service层接口)

[4.2.3 Service层实现类](#4.2.3 Service层实现类)

[4.3 功能测试](#4.3 功能测试)

[5. 清空购物车](#5. 清空购物车)

[5.1 需求分析和设计](#5.1 需求分析和设计)

[5.1.1 产品原型](#5.1.1 产品原型)

[5.1.2 接口设计](#5.1.2 接口设计)

[5.2 代码开发](#5.2 代码开发)

[5.2.1 Controller层](#5.2.1 Controller层)

[5.2.2 Service层接口](#5.2.2 Service层接口)

[5.2.3 Service层实现类](#5.2.3 Service层实现类)

[5.3 功能测试](#5.3 功能测试)

[6. 删除购物车中一个商品](#6. 删除购物车中一个商品)

[6.1 产品原型](#6.1 产品原型)

[6.2 接口设计](#6.2 接口设计)

[6.3 数据模型](#6.3 数据模型)

[6.4 代码开发](#6.4 代码开发)

[6.4.1 ShoppingCartController层](#6.4.1 ShoppingCartController层)

[6.4.2 ShoppingCartService](#6.4.2 ShoppingCartService)

[6.4.3 ShoppingCartServiceImpl](#6.4.3 ShoppingCartServiceImpl)

[6.4.4 ShoppingCartMapper](#6.4.4 ShoppingCartMapper)

[6.4.5 ShoppingCartMapper.xml](#6.4.5 ShoppingCartMapper.xml)

• 缓存菜品

• 缓存套餐

• 添加购物车

• 查看购物车

• 清空购物车

功能实现：缓存商品 、购物车

效果图：

1. 缓存菜品

1.1 问题说明

用户端小程序展示的菜品数据都是通过查询数据库获得，如果用户端访问量比较大，数据库访问压力随之增大。

**结果：**系统响应慢、用户体验差

1.2 实现思路

通过Redis来缓存菜品数据，减少数据库查询操作。

缓存逻辑分析：

• 每个分类下的菜品保存一份缓存数据

• 数据库中菜品数据有变更时清理缓存数据

1.3 代码开发

修改用户端接口 DishController 的 list 方法，加入缓存处理逻辑：

 /**
     * 根据分类id查询菜品
     *
     * @param categoryId
     * @return
     */
    @GetMapping("/list")
    @ApiOperation("根据分类id查询菜品")
    public Result<List<DishVO>> list(Long categoryId) {
        //缓存优化
        //查询MySQL数据库前，先判断redis缓存中是否存在数据
        String key = "dish_" + categoryId;
        List<DishVO> dishVOList = (List<DishVO>)redisTemplate.opsForValue().get(key);
        //如果有缓存数据，直接返回
        if (dishVOList != null && dishVOList.size() > 0) {
            return Result.success(dishVOList);
        }

        //如果缓存中没有数据，查询MySQL数据库
        Dish dish = new Dish();
        dish.setCategoryId(categoryId);
        dish.setStatus(StatusConstant.ENABLE);//查询起售中的菜品
        List<DishVO> list = dishService.listWithFlavor(dish);

        //将MySQL数据库查询到的数据缓存到redis中
        redisTemplate.opsForValue().set(key, list);

        return Result.success(list);
    }

redis数据库中如下图所示：

为了保证数据库 和Redis 中的数据保持一致，修改管理端接口 DishController 的相关方法，加入清理缓存逻辑。

需要改造的方法：

• 新增菜品

• 修改菜品

• 批量删除菜品

• 起售、停售菜品

调用清理缓存的方法，保证数据一致性：

1). 新增菜品优化

/**
     * 新增菜品
     * @param dto
     * @return
     */
    @ApiOperation("新增菜品")
    @PostMapping
    public Result<String> addDish(@RequestBody DishDTO dto) {
        log.info("新增菜品：{}", dto);
        dishService.addDish(dto);

        //缓存优化---清理缓存
        redisTemplate.delete("dish_" + dto.getCategoryId());

        return Result.success();
    }

在新增菜品清理缓存时，我们用redisTemplate的delete方法，那么我们是应该将缓存中的分类全部删除，还是只删除一个分类对应的value？

因为在新增菜品时，一个菜品只会对应一个分类，而不会对应多个分类，所以最终导致变化的也只有一个分类id对应的菜品，所以我们只需要把新增菜品所选择的分类中对应的菜品缓存清理掉就够了。

/**
     * 新增菜品
     *
     * @param dto
     */
    public void addDish(DishDTO dto) {
        //1.构造菜品基本信息数据，将其存入dish表中
        Dish dish = new Dish();
        //拷贝属性值
        BeanUtils.copyProperties(dto, dish);
        //调用mapper保存方法
        dishMapper.insert(dish);
        //TODO
        log.info("dishID={}", dish.getId());


        //2.构造菜品口味列表数据，将其存入dish_flavor表中
        List<DishFlavor> dishFlavorList = dto.getFlavors();
        if (dishFlavorList != null && dishFlavorList.size() > 0) {
            //2.1 关联菜品id
            dishFlavorList.forEach(flavor -> {
                flavor.setDishId(dish.getId());
            });
            //2.2 调用mapper保存方法,批量插入口味列表数据
            dishFlavorMapper.insertBatch(dishFlavorList);
        }

    }

if (dishFlavorList != null && dishFlavorList.size() > 0) ，满足条件才进行插入口味的操作，这个判断条件如何理解？

这个判断条件 if (dishFlavorList != null && dishFlavorList.size() > 0) 的作用是确保 dishFlavorList 不为 null 并且其中包含至少一个元素。具体解释如下：

dishFlavorList != null：防止空指针异常（NullPointerException），确保变量已初始化。

dishFlavorList.size() > 0：确保列表中有至少一个元素，避免对空列表进行不必要的操作。

2). 菜品批量删除优化

/**
     * 删除菜品
     * @param ids
     * @return
     */
    @ApiOperation("删除菜品")
    @DeleteMapping
    public Result delete(@RequestParam List<Long> ids) {
        log.info("删除菜品：{}", ids);
        dishService.delete(ids);

        //缓存优化---清理缓存---将菜品缓存全部删除
        Set keys = redisTemplate.keys("dish_*");
        redisTemplate.delete(keys);

        return Result.success();
    }

删除菜品时，为什么我们采用暴力删除法将菜品缓存数据全部删除？

因为删除菜品可能是删除单个菜品，也有可能是批量删除，所以最简单的方法就是全部删除

3). 修改菜品优化

/**
     * 修改菜品
     * @param dto
     * @return
     */
    @ApiOperation("修改菜品")
    @PutMapping
    public Result update(@RequestBody DishDTO dto) {
        log.info("修改菜品：{}",dto);
        dishService.update(dto);

        //缓存优化---清理缓存---将菜品缓存全部删除
        Set keys = redisTemplate.keys("dish_*");
        redisTemplate.delete(keys);

        return Result.success();
    }

修改菜品时，是删除一个分类缓存菜品还是全部删除？

全部删除，因为修改菜品不仅仅修改了当前分类下的菜品，如果修改了对应的分类，也要修改分类相应的菜品缓存，所以我们应该采用全部删除。

4). 菜品起售停售优化

 /**
     * 菜品起售停售
     * @param status
     * @param id
     * @return
     */
    @PostMapping("/status/{status}")
    @ApiOperation("菜品起售停售")
    public Result<String> startOrStop(@PathVariable Integer status, Long id){
        dishService.startOrStop(status,id);

        //缓存优化---清理缓存---将菜品缓存全部删除
        Set keys = redisTemplate.keys("dish_*");
        redisTemplate.delete(keys);

        return Result.success();
    }

1.4 功能测试

可以通过如下方式进行测试：

• 查看控制台sql

• 前后端联调

• 查看Redis中的缓存数据

以加入缓存 、菜品修改两个功能测试为例，通过前后端联调方式，查看控制台sql的打印和Redis中的缓存数据变化。

1). 加入缓存

当第一次查询某个分类的菜品时，会从数据为中进行查询，同时将查询的结果存储到Redis中，在后绪的访问，若查询相同分类的菜品时，直接从Redis缓存中查询，不再查询数据库。

**登录小程序：**选择蜀味牛蛙(id=17)

**查看控制台sql：**有查询语句，说明是从数据库中进行查询

**查看Redis中的缓存数据：**说明缓存成功

**再次访问：**选择蜀味牛蛙(id=17)

说明是从Redis中查询的数据。

2). 菜品修改

当在后台修改菜品数据时，为了保证Redis缓存中的数据和数据库中的数据时刻保持一致，当修改后，需要清空对应的缓存数据。用户再次访问时，还是先从数据库中查询，同时再把查询的结果存储到Redis中，这样，就能保证缓存和数据库的数据保持一致。

**进入后台：**修改蜀味牛蛙分类下的任意一个菜品，当前分类的菜品数据已在Redis中缓存

修改：

**查看Redis中的缓存数据：**说明修改时，已清空缓存

2. 缓存套餐

2.1 Spring Cache

2.1.1 介绍

Spring Cache 是一个框架，实现了基于注解的缓存功能，只需要简单地加一个注解，就能实现缓存功能。

Spring Cache 提供了一层抽象，底层可以切换不同的缓存实现，例如：

• EHCache

• Caffeine

• Redis(常用)

起步依赖：

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-cache</artifactId>  		            		       	 <version>2.7.3</version> 
</dependency>

2.1.2 常用注解

在SpringCache中提供了很多缓存操作的注解，常见的是以下的几个：

注解	说明
@EnableCaching	开启缓存注解功能，通常加在启动类上
@Cacheable	在方法执行前先查询缓存中是否有数据，如果有数据，则直接返回缓存数据；如果没有缓存数据，调用方法并将方法返回值放到缓存中
@CachePut	将方法的返回值放到缓存中
@CacheEvict	将一条或多条数据从缓存中删除

在spring boot项目中，使用缓存技术只需在项目中导入相关缓存技术的依赖包，并在启动类上使用@EnableCaching开启缓存支持即可。

例如，使用Redis作为缓存技术，只需要导入Spring data Redis的maven坐标即可。

2.1.3 入门案例

1). 环境准备

**导入基础工程:**底层已使用Redis缓存实现

数据库准备:

创建名为spring_cache_demo数据库，将springcachedemo.sql脚本直接导入数据库中。

引导类上加@EnableCaching:

@Slf4j
@SpringBootApplication
@EnableCaching//开启缓存注解功能
public class CacheDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(CacheDemoApplication.class,args);
        log.info("项目启动成功...");
    }
}

2). @CachePut注解

@CachePut 说明：

作用: 将方法返回值，放入缓存

value: 缓存的名称, 每个缓存名称下面可以有很多key

key: 缓存的key ----------> 支持Spring的表达式语言SPEL语法

在save方法上加注解@CachePut

当前UserController的save方法是用来保存用户信息的，我们希望在该用户信息保存到数据库的同时，也往缓存中缓存一份数据，我们可以在save方法上加上注解 @CachePut，用法如下：

	/**
	* CachePut：将方法返回值放入缓存
	* value：缓存的名称，每个缓存名称下面可以有多个key
	* key：缓存的key
	*/
	@PostMapping
    @CachePut(value = "userCache", key = "#user.id")//key的生成：userCache::1
    public User save(@RequestBody User user){
        userMapper.insert(user);
        return user;
    }

**说明：**key的写法如下

#user.id : #user指的是方法形参的名称, id指的是user的id属性 , 也就是使用user的id属性作为key ;

#result.id : #result代表方法返回值，该表达式 代表以返回对象的id属性作为key ；

#p0.id：#p0指的是方法中的第一个参数，id指的是第一个参数的id属性,也就是使用第一个参数的id属性作为key ;

#a0.id：#a0指的是方法中的第一个参数，id指的是第一个参数的id属性,也就是使用第一个参数的id属性作为key ;

#root.args[0].id:#root.args[0]指的是方法中的第一个参数，id指的是第一个参数的id属性,也就是使用第一个参数

的id属性作为key ;

启动服务,通过swagger接口文档测试，访问UserController的save()方法

因为id是自增，所以不需要设置id属性

查看user表中的数据

查看Redis中的数据

3). @Cacheable注解

@Cacheable 说明:

作用: 在方法执行前，spring先查看缓存中是否有数据，如果有数据，则直接返回缓存数据；若没有数据，调用方法并将方法返回值放到缓存中

value: 缓存的名称，每个缓存名称下面可以有多个key

key: 缓存的key ----------> 支持Spring的表达式语言SPEL语法

在getById上加注解@Cacheable

	/**
	* Cacheable：在方法执行前spring先查看缓存中是否有数据，如果有数据，
//则直接返回缓存数据；若没有数据，	  *调用方法并将方法返回值放到缓存中
	* value：缓存的名称，每个缓存名称下面可以有多个key
	* key：缓存的key
	*/
	@GetMapping
    @Cacheable(cacheNames = "userCache",key="#id")
    public User getById(Long id){
        User user = userMapper.getById(id);
        return user;
    }

重启服务,通过swagger接口文档测试，访问UserController的getById()方法

第一次访问，会请求我们controller的方法，查询数据库。后面再查询相同的id，就直接从Redis中查询数据，不用再查询数据库了，就说明缓存生效了。

提前在redis中手动删除掉id=1的用户数据

**查看控制台sql语句：**说明从数据库查询的用户数据

**查看Redis中的缓存数据：**说明已成功缓存

再次查询相同id的数据时，直接从redis中直接获取，不再查询数据库。

4). @CacheEvict注解

@CacheEvict 说明：

作用: 清理指定缓存

value: 缓存的名称，每个缓存名称下面可以有多个key

key: 缓存的key ----------> 支持Spring的表达式语言SPEL语法

在 delete 方法上加注解@CacheEvict

	@DeleteMapping
    @CacheEvict(cacheNames = "userCache",key = "#id")//删除某个key对应的缓存数据
    public void deleteById(Long id){
        userMapper.deleteById(id);
    }

	@DeleteMapping("/delAll")
    @CacheEvict(cacheNames = "userCache",allEntries = true)//删除userCache下所有的缓存数据
    public void deleteAll(){
        userMapper.deleteAll();
    }

重启服务,通过swagger接口文档测试，访问UserController的deleteAll()方法

查询Redis缓存数据

2.2 实现思路

实现步骤：

1). 导入Spring Cache和Redis相关maven坐标

2). 在启动类上加入@EnableCaching注解，开启缓存注解功能

3). 在用户端接口SetmealController的 list 方法上加入@Cacheable注解

4). 在管理端接口SetmealController的 save、delete、update、startOrStop等方法上加入CacheEvict注解

2.3 代码开发

按照上述实现步骤：

1). 导入Spring Cache和Redis相关maven坐标(已实现)

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

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

2). 在启动类上加入@EnableCaching注解，开启缓存注解功能

@EnableCaching                //开启缓存注解功能
@MapperScan("com.sky.mapper") //指定扫描mapper
@SpringBootApplication
@EnableTransactionManagement //开启注解方式的事务管理
@Slf4j
public class SkyApplication {
    public static void main(String[] args) {
        SpringApplication.run(SkyApplication.class, args);
        log.info("server started");
    }
}

3). 在用户端接口SetmealController的 list 方法上加入@Cacheable注解

/**
     * 条件查询
     *
     * @param categoryId
     * @return
     */
    //SpringCache作用，@Cacheable作用先查缓存，命中直接返回，否则调用方法，并将返回值存入缓存
    @Cacheable(cacheNames = "setmeal", key = "#categoryId")
    @GetMapping("/list")
    @ApiOperation("根据分类id查询套餐")
    public Result<List<Setmeal>> list(Long categoryId) {
        Setmeal setmeal = new Setmeal();
        setmeal.setCategoryId(categoryId);
        setmeal.setStatus(StatusConstant.ENABLE);

        List<Setmeal> list = setmealService.list(setmeal);
        return Result.success(list);
    }

4). 在管理端接口SetmealController的 save、delete、update、startOrStop等方法上加入CacheEvict注解

@RestController
@RequestMapping("/admin/setmeal")
@Api(tags = "套餐相关接口")
@Slf4j
public class SetmealController {

    @Autowired
    private SetmealService setmealService;

    /**
     * 新增套餐
     * @param setmealDTO
     * @return
     */
    //@CacheEvict: 清理指定分类下面的套餐缓存
    @CacheEvict(cacheNames = "setmeal", key = "#setmealDTO.categoryId")
    @ApiOperation("新增套餐")
    @PostMapping
    public Result save(@RequestBody SetmealDTO setmealDTO) {
        log.info("新增套餐：{}", setmealDTO);
        setmealService.saveWithDish(setmealDTO);
        return Result.success();
    }


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

    /**
     * 批量删除套餐
     * @param ids
     * @return
     */
    //@CacheEvict: 清理setmeal所有套餐缓存
    @CacheEvict(cacheNames = "setmeal", allEntries = true)
    @ApiOperation("批量删除套餐")
    @DeleteMapping
    public Result dalete(@RequestParam List<Long> ids) {
        log.info("批量删除：{}", ids);
        setmealService.delete(ids);
        return Result.success();
    }

    /**
     * 套餐回显
     * @param id
     * @return
     */
    @ApiOperation("套餐回显")
    @GetMapping("/{id}")
    public Result<SetmealVO> getByIdWithDish(@PathVariable Long id) {
        log.info("回显套餐：{}",id);
        SetmealVO setmealVO = setmealService.getByIdWithDish(id);
        return Result.success(setmealVO);
    }

    /**
     * 修改套餐
     * @param setmealDTO
     * @return
     */
    @CacheEvict(cacheNames = "setmeal", allEntries = true)
    @ApiOperation("修改套餐")
    @PutMapping
    public Result update(@RequestBody SetmealDTO setmealDTO) {
        log.info("修改套餐：{}", setmealDTO);
        setmealService.update(setmealDTO);
        return Result.success();
    }

    /**
     * 套餐起售、停售
     * @param status
     * @param id
     * @return
     */
    @CacheEvict(cacheNames = "setmeal", allEntries = true)
    @ApiOperation("套餐起售、停售")
    @PostMapping("/status/{status}")
    public Result startOrStop(@PathVariable Integer status, Long id) {
        log.info("套餐起售、停售：{}", status, id);
        setmealService.startOrStop(status, id);
        return Result.success();
    }
}

2.4 功能测试

通过前后端联调方式来进行测试，同时观察redis中缓存的套餐数据。和缓存菜品功能测试基本一致，不再赘述。

3. 添加购物车

3.1 需求分析和设计

3.1.1 产品原型

用户可以将菜品或者套餐添加到购物车。对于菜品来说，如果设置了口味信息，则需要选择规格后才能加入购物车;对于套餐来说，可以直接点击

将当前套餐加入购物车。在购物车中可以修改菜品和套餐的数量，也可以清空购物车。

效果图：

3.1.2 接口设计

通过上述原型图，设计出对应的添加购物车接口。

**说明：**添加购物车时，有可能添加菜品，也有可能添加套餐。故传入参数要么是菜品id，要么是套餐id。

3.1.3 表设计

用户的购物车数据，也是需要保存在数据库中的，购物车对应的数据表为shopping_cart表，具体表结构如下：

字段名	数据类型	说明	备注
id	bigint	主键	自增
name	varchar(32)	商品名称	冗余字段
image	varchar(255)	商品图片路径	冗余字段
user_id	bigint	用户id	逻辑外键
dish_id	bigint	菜品id	逻辑外键
setmeal_id	bigint	套餐id	逻辑外键
dish_flavor	varchar(50)	菜品口味
number	int	商品数量
amount	decimal(10,2)	商品单价	冗余字段
create_time	datetime	创建时间

说明：

• 购物车数据是关联用户的，在表结构中，我们需要记录，每一个用户的购物车数据是哪些

• 菜品列表展示出来的既有套餐，又有菜品，如果用户选择的是套餐，就保存套餐ID(setmeal_id)，如果用户选择的是菜品，就保存菜品ID(dish_id)

• 对同一个菜品/套餐，如果选择多份不需要添加多条记录，增加数量number即可

3.2 代码开发

3.2.1 DTO设计

根据添加购物车接口的参数设计DTO：

在sky-pojo模块，ShoppingCartDTO.java已定义

package com.sky.dto;

import lombok.Data;
import java.io.Serializable;

@Data
public class ShoppingCartDTO implements Serializable {

    private Long dishId;
    private Long setmealId;
    private String dishFlavor;

}

3.2.2 Controller层

根据添加购物车接口创建ShoppingCartController：

@Slf4j
@Api(tags = "C端-购物车相关接口")
@RestController
@RequestMapping("/user/shoppingCart")
public class ShoppingCartController {

    @Autowired
    private ShoppingCartService shoppingCartService;

    /**
     * 添加购物车
     * @param dto
     * @return
     */
    @ApiOperation("添加购物车")
    @RequestMapping("/add")
    public Result addCart(@RequestBody ShoppingCartDTO dto) {
        log.info("加入购物车：{}", dto);
        shoppingCartService.addCart(dto);
        return Result.success();
    }
}

3.2.3 Service层接口

创建ShoppingCartService接口：

package com.sky.service;

import com.sky.dto.ShoppingCartDTO;
import org.springframework.stereotype.Service;


public interface ShoppingCartService {

    /**
     * 添加购物车
     * @param dto
     */
    void addCart(ShoppingCartDTO dto);
}

3.2.4 Service层实现类

创建ShoppingCartServiceImpl实现类，并实现add方法：

@Service
public class ShoppingCartServiceImpl implements ShoppingCartService {

    @Autowired
    private DishMapper dishMapper;

    @Autowired
    private ShoppingCartMapper shoppingCartMapper;

    @Autowired
    private SetmealMapper setmealMapper;

    @Override
    public void addCart(ShoppingCartDTO dto) {

        //创建ShoppingCart对象
        ShoppingCart shoppingCart = new ShoppingCart();
        //拷贝属性值
        BeanUtils.copyProperties(dto, shoppingCart);

        //1.判断该商品是否已经存在购物车--条件：dishId + dishFlavor + userId
        // 只查当前用户自己的购物车
        shoppingCart.setUserId(BaseContext.getCurrentId()); //从ThreadLocal中获取用户id
        ShoppingCart cart = shoppingCartMapper.selectBy(shoppingCart);
        if (cart == null) { //代表购物车中没有该条商品数据
            // 2.补充缺失的属性值
            // 判断是新增套餐还是新增菜品
            if (dto.getDishId() != null) { //代表新增的是菜品
                //根据菜品的id查询菜品表获取菜品的相关信息
                Dish dish = dishMapper.getById(dto.getDishId());
                shoppingCart.setName(dish.getName());
                shoppingCart.setImage(dish.getImage());
                shoppingCart.setAmount(dish.getPrice());
            } else {                          //代表新增的是套餐
                //根据菜品的id查询菜品表获取菜品的相关信息
                Setmeal setmeal = setmealMapper.getById(dto.getSetmealId());
                shoppingCart.setName(setmeal.getName());
                shoppingCart.setImage(setmeal.getImage());
                shoppingCart.setAmount(setmeal.getPrice());
            }
            //把if和else中的共同代码提取出来
            shoppingCart.setNumber(1);  //数量-->到底是1还是加1？判断该商品是否已经存在购物车
            shoppingCart.setCreateTime(LocalDateTime.now());

            //将商品数据存入到shopping_cart表中
            shoppingCartMapper.insert(shoppingCart);
        } else {  //代表购物车中有该条商品数据
            // 3.如果已经存在，则数量加1
            cart.setNumber(cart.getNumber() + 1);
            //4.将原来的购物车商品数量+1，调用mapper的更新方法
            shoppingCartMapper.update(cart);
        }

        // 最终目的：将用户添加的商品，存入到购物车表中shopping_cart
    }
}

3.2.5 Mapper层

创建ShoppingCartMapper接口:

package com.sky.mapper;

import com.sky.entity.ShoppingCart;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Update;

public interface ShoppingCartMapper {

    /**
     * 查询购物车数据
     * @param shoppingCart
     */
    ShoppingCart selectBy(ShoppingCart shoppingCart);

    /**
     * 插入购物车数据
     * @param shoppingCart
     */
    @Insert("insert into shopping_cart (name, user_id, dish_id, setmeal_id, " +
            "dish_flavor, number, amount, image, create_time) " +
            " values (#{name},#{userId},#{dishId},#{setmealId}," +
            "#{dishFlavor},#{number},#{amount},#{image},#{createTime})")
    void insert(ShoppingCart shoppingCart);

    /**
     * 更新id购物车数据
     * @param cart
     */
    @Update("update shopping_cart set number = #{number} where id = #{id}")
    void update(ShoppingCart cart);
}

3.3 功能测试

进入小程序，添加菜品

加入购物车，查询数据库

因为现在没有实现查看购物车功能，所以只能在表中进行查看。

在前后联调时，后台可通断点方式启动，查看运行的每一步。

4. 查看购物车

4.1 需求分析和设计

4.1.1 产品原型

当用户添加完菜品和套餐后，可进入到购物车中，查看购物中的菜品和套餐。

4.1.2 接口设计

4.2 代码开发

4.2.1 Controller层

在ShoppingCartController中创建查看购物车的方法：

/**
     * 查看购物车
     * @return
     */
    @ApiOperation("查看购物车")
    @GetMapping("list")
    public Result list() {
        log.info("查看购物车");
        List<ShoppingCart> list = shoppingCartService.list();
        return Result.success(list);
    }

4.2.2 Service层接口

在ShoppingCartService接口中声明查看购物车的方法：

/**
     * 查看购物车
     * @return
     */
    List<ShoppingCart> list();

4.2.3 Service层实现类

在ShoppingCartServiceImpl中实现查看购物车的方法：

/**
     * 查看购物车
     *
     * @return
     */
    @Override
    public List<ShoppingCart> list() {
        //注意：只能查看自己名下的购物车
        return shoppingCartMapper.list(BaseContext.getCurrentId());
    }

4.3 功能测试

当进入小程序时，就会发起查看购物车的请求

点击购物车图标

5. 清空购物车

5.1 需求分析和设计

5.1.1 产品原型

当点击清空按钮时，会把购物车中的数据全部清空。

5.1.2 接口设计

5.2 代码开发

5.2.1 Controller层

在ShoppingCartController中创建清空购物车的方法：

/**
     * 清空购物车
     * @return
     */
    @ApiOperation("清空购物车")
    @DeleteMapping("/clean")
    public Result clean() {
        log.info("清空购物车");
        shoppingCartService.clean();
        return null;
    }

5.2.2 Service层接口

在ShoppingCartService接口中声明清空购物车的方法：

/**
     * 清空购物车
     */
    void clean();

5.2.3 Service层实现类

在ShoppingCartServiceImpl中实现清空购物车的方法：

 /**
     * 清空购物车
     */
    @Override
    public void clean() {
        //注意：只能清空自己名下的购物车
        shoppingCartMapper.delete(BaseContext.getCurrentId());
    }

5.3 功能测试

进入到购物车页面

点击清空

查看数据库中的数据

说明当前用户的购物车数据已全部删除。

6. 删除购物车中一个商品

6.1 产品原型

6.2 接口设计

6.3 数据模型

6.4 代码开发

6.4.1 ShoppingCartController层

/**
     * 删除购物车一个商品
     * @param dto
     * @return
     */
    @ApiOperation("删除购物车商品")
    @PostMapping("/sub")
    public Result sub(@RequestBody ShoppingCartDTO dto) {
        log.info("删除购物车商品：{}", dto);
        shoppingCartService.delete(dto);
        return Result.success();
    }

6.4.2 ShoppingCartService

/**
     * 删除购物车
     * @param dto
     */
    void delete(ShoppingCartDTO dto);

6.4.3 ShoppingCartServiceImpl

/**
     * 删除购物车数据
     * @param dto
     */
    @Override
    public void delete(ShoppingCartDTO dto) {
        ShoppingCart shoppingcart = new ShoppingCart();
        BeanUtils.copyProperties(dto, shoppingcart);
        //设置查询条件，查询当前登录用户的购物车数据
        shoppingcart.setUserId(BaseContext.getCurrentId());
        ShoppingCart cart = shoppingCartMapper.selectBy(shoppingcart);
        Integer number = cart.getNumber();
        log.info("number:{}", number);
        //1.菜品数量大于1的减1
        if (number > 1) {
            cart.setNumber(number - 1);
            shoppingCartMapper.update(cart);
        }else {           //2.菜品数量等于1的删除
            shoppingCartMapper.delete(cart);
        }

    }

6.4.4 ShoppingCartMapper

/**
     * 根据用户id、菜品id或者套餐id、口味删除当前菜品数据
     * @param shoppingcart
     */
    void delete(ShoppingCart shoppingcart);

6.4.5 ShoppingCartMapper.xml

<!--    根据用户id、菜品id或者套餐id、口味查询当前菜品数量-->
    <select id="getNumber" resultType="java.lang.Integer">
        select number from shopping_cart where user_id = #{userId}
        <if test="dishId != null">
            and dish_id = #{dishId}
        </if>
        <if test="setmealId != null">
            and setmeal_id = #{setmealId}
        </if>
        <if test="dishFlavor != null">
            and dish_flavor = #{dishFlavor}
        </if>
        order by create_time desc
    </select>