Hexo

day07缓存，购物车

  • ~13.57K 字
  1. 1. 购物车表shopping_cart:
  2. 2. 1. 缓存菜品
    1. 2.1. 1.1 实现思路
    2. 2.2. 1.2 代码实现
  3. 3. 2.缓存套餐
    1. 3.1. 2.1 Spring Cache
      1. 3.1.1. 2.1.1 介绍
      2. 3.1.2. 2.1.2 常用注解
    2. 3.2. 2.2 实现思路
    3. 3.3. 2.3 代码开发
  4. 4. 3.添加购物车
    1. 4.1. 3.1 代码开发
      1. 4.1.1. 3.1.1 Controller层
      2. 4.1.2. 3.1.2 Service层接口
      3. 4.1.3. 3.1.3 Service层实现类
      4. 4.1.4. 3.1.4 Mapper层
  5. 5. 4. 查看购物车
  6. 6. 5.清空购物车

购物车表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即可

1. 缓存菜品

1.1 实现思路

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

缓存逻辑分析：

  • 每个分类下的菜品保存一份缓存数据
  • 数据库中菜品数据有变更时清理缓存数据
key value
dish_1 string(…)
dish_2 string(…)

1.2 代码实现

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
@Autowired
   private RedisTemplate redisTemplate;
/**
    * 根据分类id查询菜品
    *
    * @param categoryId
    * @return
    */
   @GetMapping("/list")
   @ApiOperation("根据分类id查询菜品")
   public Result<List<DishVO>> list(Long categoryId) {

       //构造redis中的key，规则：dish_分类id
       String key = "dish_" + categoryId;

       //查询redis中是否存在菜品数据
       List<DishVO> list = (List<DishVO>) redisTemplate.opsForValue().get(key);
       if(list != null && list.size() > 0){
           //如果存在，直接返回，无须查询数据库
           return Result.success(list);
       }
	////////////////////////////////////////////////////////
       Dish dish = new Dish();
       dish.setCategoryId(categoryId);
       dish.setStatus(StatusConstant.ENABLE);//查询起售中的菜品

       //如果不存在，查询数据库，将查询到的数据放入redis中
       list = dishService.listWithFlavor(dish);
       ////////////////////////////////////////////////////////
       redisTemplate.opsForValue().set(key, list);

       return Result.success(list);
   }

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

需要改造的方法：

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

抽取清理缓存的方法：

在管理端DishController中添加

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

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

1). 新增菜品优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
    * 新增菜品
    *
    * @param dishDTO
    * @return
    */
   @PostMapping
   @ApiOperation("新增菜品")
   public Result save(@RequestBody DishDTO dishDTO) {
       log.info("新增菜品：{}", dishDTO);
       dishService.saveWithFlavor(dishDTO);

       //清理缓存数据
       String key = "dish_" + dishDTO.getCategoryId();
       cleanCache(key);
       return Result.success();
   }

2). 菜品批量删除优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
    * 菜品批量删除
    *
    * @param ids
    * @return
    */
   @DeleteMapping
   @ApiOperation("菜品批量删除")
   public Result delete(@RequestParam List<Long> ids) {
       log.info("菜品批量删除：{}", ids);
       dishService.deleteBatch(ids);

       //将所有的菜品缓存数据清理掉，所有以dish_开头的key
       cleanCache("dish_*");

       return Result.success();
   }

3). 修改菜品优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
    * 修改菜品
    *
    * @param dishDTO
    * @return
    */
   @PutMapping
   @ApiOperation("修改菜品")
   public Result update(@RequestBody DishDTO dishDTO) {
       log.info("修改菜品：{}", dishDTO);
       dishService.updateWithFlavor(dishDTO);

       //将所有的菜品缓存数据清理掉，所有以dish_开头的key
       cleanCache("dish_*");

       return Result.success();
   }

4). 菜品起售停售优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
    * 菜品起售停售
    *
    * @param status
    * @param id
    * @return
    */
   @PostMapping("/status/{status}")
   @ApiOperation("菜品起售停售")
   public Result<String> startOrStop(@PathVariable Integer status, Long id) {
       dishService.startOrStop(status, id);

       //将所有的菜品缓存数据清理掉，所有以dish_开头的key
       cleanCache("dish_*");

       return Result.success();
   }

2.缓存套餐

2.1 Spring Cache

2.1.1 介绍

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

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

  • EHCache
  • Caffeine
  • Redis(常用)

起步依赖：

1
2
3
4
5
<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坐标即可。

1). @CachePut注解

@CachePut 说明：

  • 作用: 将方法返回值，放入缓存
  • value: 缓存的名称, 每个缓存名称下面可以有很多key
  • key: 缓存的key ———-> 支持Spring的表达式语言SPEL语法

在save方法上加注解@CachePut
说明： 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 ;

2). @Cacheable注解

@Cacheable 说明:

  • 作用: 在方法执行前，spring先查看缓存中是否有数据，如果有数据，则直接返回缓存数据；若没有数据，调用方法并将方法返回值放到缓存中
  • value: 缓存的名称，每个缓存名称下面可以有多个key
  • key: 缓存的key ———-> 支持Spring的表达式语言SPEL语法

在getById上加注解@Cacheable

3). @CacheEvict注解

@CacheEvict 说明：

  • 作用: 清理指定缓存
  • value: 缓存的名称，每个缓存名称下面可以有多个key
  • key: 缓存的key ———-> 支持Spring的表达式语言SPEL语法

在 delete 方法上加注解@CacheEvict

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
2
3
4
5
6
7
8
9
<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注解，开启缓存注解功能

1
2
3
4
5
@SpringBootApplication
@EnableTransactionManagement //开启注解方式的事务管理
@Slf4j
@EnableCaching
public class SkyApplication ...

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

1
2
3
4
5
6
7
8
9
/**
    * 条件查询
    * @param categoryId
    * @return
    */
   @GetMapping("/list")
   @ApiOperation("根据分类id查询套餐")
   @Cacheable(cacheNames = "setmealCache",key = "#categoryId") //key: setmealCache::100
   public Result<List<Setmeal>> list(Long categoryId) ...

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/**
    * 新增套餐
    * @param setmealDTO
    * @return
    */
   @PostMapping
   @ApiOperation("新增套餐")
   @CacheEvict(cacheNames = "setmealCache",key = "#setmealDTO.categoryId")//key: setmealCache::100
   public Result save(@RequestBody SetmealDTO setmealDTO) ...
   
/**
    * 批量删除套餐
    * @param ids
    * @return
    */
   @DeleteMapping
   @ApiOperation("批量删除套餐")
   @CacheEvict(cacheNames = "setmealCache",allEntries = true)
   public Result delete(@RequestParam List<Long> ids) ...
   
/**
    * 修改套餐
    * @param setmealDTO
    * @return
    */
   @PutMapping
   @ApiOperation("修改套餐")
   @CacheEvict(cacheNames = "setmealCache",allEntries = true)
   public Result update(@RequestBody SetmealDTO setmealDTO) ...

   /**
    * 套餐起售停售
    * @param status
    * @param id
    * @return
    */
   @PostMapping("/status/{status}")
   @ApiOperation("套餐起售停售")
   @CacheEvict(cacheNames = "setmealCache",allEntries = true)
   public Result startOrStop(@PathVariable Integer status, Long id) ...

3.添加购物车

3.1 代码开发

3.1.1 Controller层

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
 * 购物车
 */
@RestController
@RequestMapping("/user/shoppingCart")
@Slf4j
@Api(tags = "C端-购物车接口")
public class ShoppingCartController {

    @Autowired
    private ShoppingCartService shoppingCartService;

    /**
     * 添加购物车
     * @param shoppingCartDTO
     * @return
     */
    @PostMapping("/add")
    @ApiOperation("添加购物车")
    public Result<String> add(@RequestBody ShoppingCartDTO shoppingCartDTO){
        log.info("添加购物车：{}", shoppingCartDTO);
        shoppingCartService.addShoppingCart(shoppingCartDTO);//后绪步骤实现
        return Result.success();
    }
}

3.1.2 Service层接口

创建ShoppingCartService接口：

1
2
3
4
5
6
7
8
public interface ShoppingCartService {

    /**
     * 添加购物车
     * @param shoppingCartDTO
     */
    void addShoppingCart(ShoppingCartDTO shoppingCartDTO);
}

3.1.3 Service层实现类

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
@Service
public class ShoppingCartServiceImpl implements ShoppingCartService {

    @Autowired
    private ShoppingCartMapper shoppingCartMapper;
    @Autowired
    private DishMapper dishMapper;
    @Autowired
    private SetmealMapper setmealMapper;
    
    /**
     * 添加购物车
     *
     * @param shoppingCartDTO
     */
    public void addShoppingCart(ShoppingCartDTO shoppingCartDTO) {
        ShoppingCart shoppingCart = new ShoppingCart();
        BeanUtils.copyProperties(shoppingCartDTO, shoppingCart);
        //只能查询自己的购物车数据
        shoppingCart.setUserId(BaseContext.getCurrentId());

        //判断当前商品是否在购物车中
        List<ShoppingCart> shoppingCartList = shoppingCartMapper.list(shoppingCart);

        if (shoppingCartList != null && shoppingCartList.size() == 1) {
            //如果已经存在，就更新数量，数量加1
            shoppingCart = shoppingCartList.get(0);
            shoppingCart.setNumber(shoppingCart.getNumber() + 1);
            shoppingCartMapper.updateNumberById(shoppingCart);
        } else {
            //如果不存在，插入数据，数量就是1

            //判断当前添加到购物车的是菜品还是套餐
            Long dishId = shoppingCartDTO.getDishId();
            if (dishId != null) {
                //添加到购物车的是菜品
                Dish dish = dishMapper.getById(dishId);
                shoppingCart.setName(dish.getName());
                shoppingCart.setImage(dish.getImage());
                shoppingCart.setAmount(dish.getPrice());
            } else {
                //添加到购物车的是套餐
                Setmeal setmeal = setmealMapper.getById(shoppingCartDTO.getSetmealId());
                shoppingCart.setName(setmeal.getName());
                shoppingCart.setImage(setmeal.getImage());
                shoppingCart.setAmount(setmeal.getPrice());
            }
            shoppingCart.setNumber(1);
            shoppingCart.setCreateTime(LocalDateTime.now());
            shoppingCartMapper.insert(shoppingCart);
        }
    }
}

3.1.4 Mapper层

创建ShoppingCartMapper接口:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@Mapper
public interface ShoppingCartMapper {
    /**
     * 条件查询
     *
     * @param shoppingCart
     * @return
     */
    List<ShoppingCart> list(ShoppingCart shoppingCart);

    /**
     * 更新商品数量
     *
     * @param shoppingCart
     */
    @Update("update shopping_cart set number = #{number} where id = #{id}")
    void updateNumberById(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);

}

创建ShoppingCartMapper.xml：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?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.ShoppingCartMapper">
    <select id="list" parameterType="ShoppingCart" resultType="ShoppingCart">
        select * from shopping_cart
        <where>
            <if test="userId != null">
                and user_id = #{userId}
            </if>
            <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>
        </where>
        order by create_time desc
    </select>
</mapper>

4. 查看购物车

Impl实现类：

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

5.清空购物车

Impl实现类：

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

Mapper接口：

1
2
3
4
5
6
7
/**
    * 根据用户id删除购物车数据
    *
    * @param userId
    */
   @Delete("delete from shopping_cart where user_id = #{userId}")
   void deleteByUserId(Long userId);
本作品采用 知识共享署名-相同方式共享 4.0 国际许可协议 进行许可
, , , ,