苍穹外卖-day07（Spring Cache & 购物车业务逻辑）

内容

• 缓存菜品
  
• 缓存套餐
  
• 添加购物车
  
• 查看购物车
  
• 清空购物车
  

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

1. 缓存菜品

1.1 题目阐明

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

**结果：**系统相应慢、用户体验差
1.2 实现思绪

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

缓存逻辑分析：

• 每个分类下的菜品生存一份缓存数据
  
• 数据库中菜品数据有变更时清算缓存数据
  

1.3 代码开发

修改用户端接口 DishController 的 list 方法，到场缓存处置惩罚逻辑：

1.         @Autowired
2.     private RedisTemplate redisTemplate;
3.         /**
4.      * 根据分类id查询菜品
5.      *
6.      * @param categoryId
7.      * @return
8.      */
9.     @GetMapping("/list")
10.     @ApiOperation("根据分类id查询菜品")
11.     public Result<List<DishVO>> list(Long categoryId) {
13.         //构造redis中的key，规则：dish_分类id
14.         String key = "dish_" + categoryId;
16.         //查询redis中是否存在菜品数据
17.         List<DishVO> list = (List<DishVO>) redisTemplate.opsForValue().get(key);
18.         if(list != null && list.size() > 0){
19.             //如果存在，直接返回，无须查询数据库
20.             return Result.success(list);
21.         }
22.                
23.         Dish dish = new Dish();
24.         dish.setCategoryId(categoryId);
25.         dish.setStatus(StatusConstant.ENABLE);//查询起售中的菜品
27.         //如果不存在，查询数据库，将查询到的数据放入redis中
28.         list = dishService.listWithFlavor(dish);
29.         
30.         redisTemplate.opsForValue().set(key, list);
32.         return Result.success(list);
33.     }

复制代码

为了包管数据库和Redis中的数据保持同等，修改管理端接 DishController 的干系方法，到场清算缓存逻辑。
必要改造的方法：

• 新增菜品
  
• 修改菜品
  
• 批量删除菜品
  
• 起售、停售菜品
  

抽取清算缓存的方法：
在管理端DishController中添加

1.         @Autowired
2.     private RedisTemplate redisTemplate;
3.         /**
4.      * 清理缓存数据
5.      * @param pattern
6.      */
7.     private void cleanCache(String pattern){
8.         Set keys = redisTemplate.keys(pattern);
9.         redisTemplate.delete(keys);
10.     }

复制代码

调用清算缓存的方法，包管数据同等性：
1). 新增菜品优化

1.         /**
2.      * 新增菜品
3.      *
4.      * @param dishDTO
5.      * @return
6.      */
7.     @PostMapping
8.     @ApiOperation("新增菜品")
9.     public Result save(@RequestBody DishDTO dishDTO) {
10.         log.info("新增菜品：{}", dishDTO);
11.         dishService.saveWithFlavor(dishDTO);
13.         //清理缓存数据
14.         String key = "dish_" + dishDTO.getCategoryId();
15.         cleanCache(key);
16.         return Result.success();
17.     }

复制代码

2). 菜品批量删除优化

1.         /**
2.      * 菜品批量删除
3.      *
4.      * @param ids
5.      * @return
6.      */
7.     @DeleteMapping
8.     @ApiOperation("菜品批量删除")
9.     public Result delete(@RequestParam List<Long> ids) {
10.         log.info("菜品批量删除：{}", ids);
11.         dishService.deleteBatch(ids);
13.         //将所有的菜品缓存数据清理掉，所有以dish_开头的key
14.         cleanCache("dish_*");
16.         return Result.success();
17.     }

复制代码

3). 修改菜品优化

1.         /**
2.      * 修改菜品
3.      *
4.      * @param dishDTO
5.      * @return
6.      */
7.     @PutMapping
8.     @ApiOperation("修改菜品")
9.     public Result update(@RequestBody DishDTO dishDTO) {
10.         log.info("修改菜品：{}", dishDTO);
11.         dishService.updateWithFlavor(dishDTO);
13.         //将所有的菜品缓存数据清理掉，所有以dish_开头的key
14.         cleanCache("dish_*");
16.         return Result.success();
17.     }

复制代码

4). 菜品起售停售优化

1.         /**
2.      * 菜品起售停售
3.      *
4.      * @param status
5.      * @param id
6.      * @return
7.      */
8.     @PostMapping("/status/{status}")
9.     @ApiOperation("菜品起售停售")
10.     public Result<String> startOrStop(@PathVariable Integer status, Long id) {
11.         dishService.startOrStop(status, id);
13.         //将所有的菜品缓存数据清理掉，所有以dish_开头的key
14.         cleanCache("dish_*");
16.         return Result.success();
17.     }

复制代码

1.4 功能测试

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

• 查看控制台sql
  
• 前后端联调
  
• 查看Redis中的缓存数据
  

以到场缓存、菜品修改两个功能测试为例，通过前后端联调方式，查看控制台sql的打印和Redis中的缓存数据变革。
1). 到场缓存
当第一次查询某个分类的菜品时，会从数据为中举行查询，同时将查询的结果存储到Redis中，在后绪的访问，若查询雷同分类的菜品时，直接从Redis缓存中查询，不再查询数据库。
登录小程序： 选择蜀味牛蛙(id=17)

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

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

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

阐明是从Redis中查询的数据。
2). 菜品修改
当在背景修改菜品数据时，为了包管Redis缓存中的数据和数据库中的数据时候保持同等，当修改后，必要清空对应的缓存数据。用户再次访问时，还是先从数据库中查询，同时再把查询的结果存储到Redis中，这样，就能包管缓存和数据库的数据保持同等。
进入背景： 修改蜀味牛蛙分类下的任意一个菜品，当前分类的菜品数据已在Redis中缓存

修改：

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

用户再次访问同一个菜品分类时，必要先查询数据库，再把结果同步到Redis中，包管了两者数据同等性。
别的功能测试步骤根本同等，自已测试即可。
2. 缓存套餐

2.1 Spring Cache

2.1.1 介绍

Spring Cache 是一个框架，实现了基于注解的缓存功能，只必要简单地加一个注解，就能实现缓存功能。
Spring Cache 提供了一层抽象，底层可以切换差别的缓存实现，比方：

• EHCache
  
• Caffeine
  
• Redis(常用)
  

起步依赖：

1. <dependency>
2.         <groupId>org.springframework.boot</groupId>
3.         <artifactId>spring-boot-starter-cache</artifactId>                                                              <version>2.7.3</version>
4. </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：

1. package com.itheima;
3. import lombok.extern.slf4j.Slf4j;
4. import org.springframework.boot.SpringApplication;
5. import org.springframework.boot.autoconfigure.SpringBootApplication;
6. import org.springframework.cache.annotation.EnableCaching;
8. @Slf4j
9. @SpringBootApplication
10. @EnableCaching//开启缓存注解功能
11. public class CacheDemoApplication {
12.     public static void main(String[] args) {
13.         SpringApplication.run(CacheDemoApplication.class,args);
14.         log.info("项目启动成功...");
15.     }
16. }

复制代码

2). @CachePut注解
@CachePut 阐明：
作用: 将方法返回值，放入缓存
value: 缓存的名称, 每个缓存名称下面可以有很多key
key: 缓存的key ----------> 支持Spring的表达式语言SPEL语法
在save方法上加注解@CachePut
当前UserController的save方法是用来生存用户信息的，我们希望在该用户信息生存到数据库的同时，也往缓存中缓存一份数据，我们可以在save方法上加上注解@CachePut，用法如下：

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

复制代码

阐明： 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

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

复制代码

重启服务,通过swagger接口文档测试，访问UserController的getById()方法
第一次访问，会请求我们controller的方法，查询数据库。后面再查询雷同的id，就直接从Redis中查询数据，不用再查询数据库了，就阐明缓存生效了。
提前在redis中手动删除掉id=1的用户数据

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

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

4). @CacheEvict注解
@CacheEvict 阐明：
作用: 清算指定缓存
value: 缓存的名称，每个缓存名称下面可以有多个key
key: 缓存的key ----------> 支持Spring的表达式语言SPEL语法
在 delete 方法上加注解@CacheEvict

1.         @DeleteMapping
2.     @CacheEvict(cacheNames = "userCache",key = "#id")//删除某个key对应的缓存数据
3.     public void deleteById(Long id){
4.         userMapper.deleteById(id);
5.     }
7.         @DeleteMapping("/delAll")
8.     @CacheEvict(cacheNames = "userCache",allEntries = true)//删除userCache下所有的缓存数据
9.     public void deleteAll(){
10.         userMapper.deleteAll();
11.     }

复制代码

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

查看user表： 数据清空

查询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坐标(已实现)

1. <dependency>
2.       <groupId>org.springframework.boot</groupId>
3.       <artifactId>spring-boot-starter-data-redis</artifactId>
4. </dependency>
6. <dependency>
7.       <groupId>org.springframework.boot</groupId>
8.       <artifactId>spring-boot-starter-cache</artifactId>
9. </dependency>

复制代码

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

1. package com.sky;
3. import lombok.extern.slf4j.Slf4j;
4. import org.springframework.boot.SpringApplication;
5. import org.springframework.boot.autoconfigure.SpringBootApplication;
6. import org.springframework.cache.annotation.EnableCaching;
7. import org.springframework.transaction.annotation.EnableTransactionManagement;
9. @SpringBootApplication
10. @EnableTransactionManagement //开启注解方式的事务管理
11. @Slf4j
12. @EnableCaching
13. public class SkyApplication {
14.     public static void main(String[] args) {
15.         SpringApplication.run(SkyApplication.class, args);
16.         log.info("server started");
17.     }
18. }

复制代码

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

1.         /**
2.      * 条件查询
3.      *
4.      * @param categoryId
5.      * @return
6.      */
7.     @GetMapping("/list")
8.     @ApiOperation("根据分类id查询套餐")
9.     @Cacheable(cacheNames = "setmealCache",key = "#categoryId") //key: setmealCache::100
10.     public Result<List<Setmeal>> list(Long categoryId) {
11.         Setmeal setmeal = new Setmeal();
12.         setmeal.setCategoryId(categoryId);
13.         setmeal.setStatus(StatusConstant.ENABLE);
15.         List<Setmeal> list = setmealService.list(setmeal);
16.         return Result.success(list);
17.     }

复制代码

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

1.         /**
2.      * 新增套餐
3.      *
4.      * @param setmealDTO
5.      * @return
6.      */
7.     @PostMapping
8.     @ApiOperation("新增套餐")
9.     @CacheEvict(cacheNames = "setmealCache",key = "#setmealDTO.categoryId")//key: setmealCache::100
10.     public Result save(@RequestBody SetmealDTO setmealDTO) {
11.         setmealService.saveWithDish(setmealDTO);
12.         return Result.success();
13.     }
14.         /**
15.      * 批量删除套餐
16.      *
17.      * @param ids
18.      * @return
19.      */
20.     @DeleteMapping
21.     @ApiOperation("批量删除套餐")
22.     @CacheEvict(cacheNames = "setmealCache",allEntries = true)
23.     public Result delete(@RequestParam List<Long> ids) {
24.         setmealService.deleteBatch(ids);
25.         return Result.success();
26.     }
27.         /**
28.      * 修改套餐
29.      *
30.      * @param setmealDTO
31.      * @return
32.      */
33.     @PutMapping
34.     @ApiOperation("修改套餐")
35.     @CacheEvict(cacheNames = "setmealCache",allEntries = true)
36.     public Result update(@RequestBody SetmealDTO setmealDTO) {
37.         setmealService.update(setmealDTO);
38.         return Result.success();
39.     }
41.     /**
42.      * 套餐起售停售
43.      *
44.      * @param status
45.      * @param id
46.      * @return
47.      */
48.     @PostMapping("/status/{status}")
49.     @ApiOperation("套餐起售停售")
50.     @CacheEvict(cacheNames = "setmealCache",allEntries = true)
51.     public Result startOrStop(@PathVariable Integer status, Long id) {
52.         setmealService.startOrStop(status, id);
53.         return Result.success();
54.     }

复制代码

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已定义

1. package com.sky.dto;
3. import lombok.Data;
4. import java.io.Serializable;
6. @Data
7. public class ShoppingCartDTO implements Serializable {
9.     private Long dishId;
10.     private Long setmealId;
11.     private String dishFlavor;
13. }

复制代码

3.2.2 Controller层

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

1. package com.sky.controller.user;
4. import com.sky.dto.ShoppingCartDTO;
5. import com.sky.result.Result;
6. import io.swagger.annotations.Api;
7. import io.swagger.annotations.ApiOperation;
8. import lombok.extern.slf4j.Slf4j;
9. import org.springframework.beans.factory.annotation.Autowired;
10. import org.springframework.web.bind.annotation.PostMapping;
11. import org.springframework.web.bind.annotation.RequestBody;
12. import org.springframework.web.bind.annotation.RequestMapping;
13. import org.springframework.web.bind.annotation.RestController;
15. /**
16. * 购物车
17. */
18. @RestController
19. @RequestMapping("/user/shoppingCart")
20. @Slf4j
21. @Api(tags = "C端-购物车接口")
22. public class ShoppingCartController {
24.     @Autowired
25.     private ShoppingCartService shoppingCartService;
27.     /**
28.      * 添加购物车
29.      * @param shoppingCartDTO
30.      * @return
31.      */
32.     @PostMapping("/add")
33.     @ApiOperation("添加购物车")
34.     public Result<String> add(@RequestBody ShoppingCartDTO shoppingCartDTO){
35.         log.info("添加购物车：{}", shoppingCartDTO);
36.         shoppingCartService.addShoppingCart(shoppingCartDTO);//后绪步骤实现
37.         return Result.success();
38.     }
39. }

复制代码

3.2.3 Service层接口

创建ShoppingCartService接口：

1. package com.sky.service;
3. import com.sky.dto.ShoppingCartDTO;
4. import com.sky.entity.ShoppingCart;
5. import java.util.List;
7. public interface ShoppingCartService {
9.     /**
10.      * 添加购物车
11.      * @param shoppingCartDTO
12.      */
13.     void addShoppingCart(ShoppingCartDTO shoppingCartDTO);
14. }

复制代码

3.2.4 Service层实现类

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

1. package com.sky.service.impl;
4. import com.sky.context.BaseContext;
5. import com.sky.dto.ShoppingCartDTO;
6. import com.sky.entity.Dish;
7. import com.sky.entity.Setmeal;
8. import com.sky.entity.ShoppingCart;
9. import com.sky.mapper.DishMapper;
10. import com.sky.mapper.SetmealMapper;
11. import com.sky.service.ShoppingCartService;
12. import org.springframework.beans.BeanUtils;
13. import org.springframework.beans.factory.annotation.Autowired;
14. import org.springframework.stereotype.Service;
15. import java.time.LocalDateTime;
16. import java.util.List;
18. @Service
19. public class ShoppingCartServiceImpl implements ShoppingCartService {
21.     @Autowired
22.     private ShoppingCartMapper shoppingCartMapper;
23.     @Autowired
24.     private DishMapper dishMapper;
25.     @Autowired
26.     private SetmealMapper setmealMapper;
27.    
28.     /**
29.      * 添加购物车
30.      *
31.      * @param shoppingCartDTO
32.      */
33.     public void addShoppingCart(ShoppingCartDTO shoppingCartDTO) {
34.         ShoppingCart shoppingCart = new ShoppingCart();
35.         BeanUtils.copyProperties(shoppingCartDTO, shoppingCart);
36.         //只能查询自己的购物车数据
37.         shoppingCart.setUserId(BaseContext.getCurrentId());
39.         //判断当前商品是否在购物车中
40.         List<ShoppingCart> shoppingCartList = shoppingCartMapper.list(shoppingCart);
42.         if (shoppingCartList != null && shoppingCartList.size() == 1) {
43.             //如果已经存在，就更新数量，数量加1
44.             shoppingCart = shoppingCartList.get(0);
45.             shoppingCart.setNumber(shoppingCart.getNumber() + 1);
46.             shoppingCartMapper.updateNumberById(shoppingCart);
47.         } else {
48.             //如果不存在，插入数据，数量就是1
50.             //判断当前添加到购物车的是菜品还是套餐
51.             Long dishId = shoppingCartDTO.getDishId();
52.             if (dishId != null) {
53.                 //添加到购物车的是菜品
54.                 Dish dish = dishMapper.getById(dishId);
55.                 shoppingCart.setName(dish.getName());
56.                 shoppingCart.setImage(dish.getImage());
57.                 shoppingCart.setAmount(dish.getPrice());
58.             } else {
59.                 //添加到购物车的是套餐
60.                 Setmeal setmeal = setmealMapper.getById(shoppingCartDTO.getSetmealId());
61.                 shoppingCart.setName(setmeal.getName());
62.                 shoppingCart.setImage(setmeal.getImage());
63.                 shoppingCart.setAmount(setmeal.getPrice());
64.             }
65.             shoppingCart.setNumber(1);
66.             shoppingCart.setCreateTime(LocalDateTime.now());
67.             shoppingCartMapper.insert(shoppingCart);
68.         }
69.     }
70. }

复制代码

3.2.5 Mapper层

创建ShoppingCartMapper接口:

1. package com.sky.mapper;
3. import com.sky.entity.ShoppingCart;
4. import org.apache.ibatis.annotations.Delete;
5. import org.apache.ibatis.annotations.Insert;
6. import org.apache.ibatis.annotations.Mapper;
7. import org.apache.ibatis.annotations.Update;
8. import java.util.List;
10. @Mapper
11. public interface ShoppingCartMapper {
12.     /**
13.      * 条件查询
14.      *
15.      * @param shoppingCart
16.      * @return
17.      */
18.     List<ShoppingCart> list(ShoppingCart shoppingCart);
20.     /**
21.      * 更新商品数量
22.      *
23.      * @param shoppingCart
24.      */
25.     @Update("update shopping_cart set number = #{number} where id = #{id}")
26.     void updateNumberById(ShoppingCart shoppingCart);
28.     /**
29.      * 插入购物车数据
30.      *
31.      * @param shoppingCart
32.      */
33.     @Insert("insert into shopping_cart (name, user_id, dish_id, setmeal_id, dish_flavor, number, amount, image, create_time) " +
34.             " values (#{name},#{userId},#{dishId},#{setmealId},#{dishFlavor},#{number},#{amount},#{image},#{createTime})")
35.     void insert(ShoppingCart shoppingCart);
37. }

复制代码

创建ShoppingCartMapper.xml：

1. <?xml version="1.0" encoding="UTF-8" ?>
2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
3. <mapper namespace="com.sky.mapper.ShoppingCartMapper">
4.     <select id="list" parameterType="ShoppingCart" resultType="ShoppingCart">
5.         select * from shopping_cart
6.         <where>
7.             <if test="userId != null">
8.                 and user_id = #{userId}
9.             </if>
10.             <if test="dishId != null">
11.                 and dish_id = #{dishId}
12.             </if>
13.             <if test="setmealId != null">
14.                 and setmeal_id = #{setmealId}
15.             </if>
16.             <if test="dishFlavor != null">
17.                 and dish_flavor = #{dishFlavor}
18.             </if>
19.         </where>
20.         order by create_time desc
21.     </select>
22. </mapper>

复制代码

3.3 功能测试

进入小程序，添加菜品

到场购物车，查询数据库

由于现在没有实现查看购物车功能，所以只能在表中举行查看。
在前后联调时，背景可通断点方式启动，查看运行的每一步。
4. 查看购物车

4.1 需求分析和设计

4.1.1 产物原型

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

4.1.2 接口设计

4.2 代码开发

4.2.1 Controller层

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

1.         /**
2.      * 查看购物车
3.      * @return
4.      */
5.     @GetMapping("/list")
6.     @ApiOperation("查看购物车")
7.     public Result<List<ShoppingCart>> list(){
8.         return Result.success(shoppingCartService.showShoppingCart());
9.     }

复制代码

4.2.2 Service层接口

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

1.         /**
2.      * 查看购物车
3.      * @return
4.      */
5.     List<ShoppingCart> showShoppingCart();

复制代码

4.2.3 Service层实现类

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

1.         /**
2.      * 查看购物车
3.      * @return
4.      */
5.     public List<ShoppingCart> showShoppingCart() {
6.         return shoppingCartMapper.list(ShoppingCart.
7.                                        builder().
8.                                        userId(BaseContext.getCurrentId()).
9.                                        build());
10.     }

复制代码

4.3 功能测试

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

点击购物车图标

测试成功。
5. 清空购物车

5.1 需求分析和设计

5.1.1 产物原型

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

5.1.2 接口设计

5.2 代码开发

5.2.1 Controller层

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

1.         /**
2.      * 清空购物车商品
3.      * @return
4.      */
5.     @DeleteMapping("/clean")
6.     @ApiOperation("清空购物车商品")
7.     public Result<String> clean(){
8.         shoppingCartService.cleanShoppingCart();
9.         return Result.success();
10.     }

复制代码

5.2.2 Service层接口

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

1.         /**
2.      * 清空购物车商品
3.      */
4.     void cleanShoppingCart();

复制代码

5.2.3 Service层实现类

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

1.         /**
2.      * 清空购物车商品
3.      */
4.     public void cleanShoppingCart() {
5.         shoppingCartMapper.deleteByUserId(BaseContext.getCurrentId());
6.     }

复制代码

5.2.4 Mapper层

在ShoppingCartMapper接口中创建删除购物车数据的方法：

1.         /**
2.      * 根据用户id删除购物车数据
3.      *
4.      * @param userId
5.      */
6.     @Delete("delete from shopping_cart where user_id = #{userId}")
7.     void deleteByUserId(Long userId);

复制代码

5.3 功能测试

进入到购物车页面

点击清空

查看数据库中的数据

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

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。