itheima苍穹外卖项目学习笔记--Day7：缓存商品 / 购物车

一条粉肠与蛋散

已于 2023-08-04 01:04:46 修改

阅读量1.1k

点赞数 2

分类专栏：苍穹外卖开发笔记文章标签：缓存 spring mybatis java intellij-idea maven

于 2023-07-16 22:50:32 首次发布

本文链接：https://blog.csdn.net/weixin_46926189/article/details/131756500

版权

苍穹外卖开发笔记专栏收录该内容

12 篇文章 8 订阅

订阅专栏

缓存商品 / 购物车

Day7：缓存商品、购物车

Day7：缓存商品、购物车

a. 缓存菜品

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

缓存逻辑分析：

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

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

@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);
}

修改管理端接口 DishController 的相关方法，加入清理缓存的逻辑，需要改造的方法：

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

@RestController
@RequestMapping("/admin/dish")
@Api(tags = "菜品相关接口")
@Slf4j
public class DishController {

    @Autowired
    private DishService dishService;

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 新增菜品
     * @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();
    }

    /**
     * 菜品分页查询
     * @param dishPageQueryDTO
     * @return
     */
    @GetMapping("/page")
    @ApiOperation("菜品分页查询")
    public Result<PageResult> page(DishPageQueryDTO dishPageQueryDTO){
        log.info("菜品分页查询，参数为:{}",dishPageQueryDTO);
        PageResult pageResult = dishService.pageQuery(dishPageQueryDTO);
        return Result.success(pageResult);
    }

    /**
     * 菜品批量删除
     * @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();
    }

    /**
     * 根据id查询菜品
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    @ApiOperation("根据id查询菜品")
    public Result<DishVO> getById(@PathVariable Long id){
        log.info("根据id查询菜品：{}", id);
        DishVO dishVO = dishService.getByIdWithFlavor(id);
        return Result.success(dishVO);
    }

    /**
     * 修改菜品和关联的口味数据
     * @param dishDTO
     * @return
     */
    @PutMapping
    @ApiOperation("修改菜品")
    public Result update(@RequestBody DishDTO dishDTO){
        log.info("修改菜品：{}", dishDTO);
        dishService.updateWithFlavor(dishDTO);

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

        return Result.success();
    }

    /**
     * 根据分类id查询菜品
     * @param categoryId
     * @return
     */
    @GetMapping("/list")
    @ApiOperation("根据分类id查询菜品")
    public Result<List<Dish>> list(Long categoryId){
        List<Dish> list = dishService.list(categoryId);
        return Result.success(list);
    }

    /**
     * 启售禁售菜品
     * @param status
     * @param id
     * @return
     */
    @PostMapping("/status/{status}")
    @ApiOperation("启售禁售菜品")
    public Result startOrStop(@PathVariable Integer status, Long id){
        log.info("启售禁售菜品：{}, {}", status, id);
        dishService.startOrStop(status, id);

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

        return Result.success();
    }

    /**
     * 清理缓存数据
     * @param pattern
     */
    private void cleanCache(String pattern){
        Set keys = redisTemplate.keys(pattern);
        redisTemplate.delete(keys);
    }

}

b. 缓存套餐

具体的实现思路如下：

导入Spring Cache和Redis相关maven坐标
在启动类上加入@EnableCaching注解，开启缓存注解功能
在用户端接口SetmealController的 list 方法上加入@Cacheable注解

/**
 * 条件查询
 *
 * @param categoryId
 * @return
 */
@GetMapping("/list")
@ApiOperation("根据分类id查询套餐")
@Cacheable(cacheNames = "setmealCache", key = "#categoryId")
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);
}

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

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

    @Autowired
    private SetmealService setmealService;

    /**
     * 新增套餐
     * @param setmealDTO
     * @return
     */
    @PostMapping
    @ApiOperation("新增套餐")
    @CacheEvict(cacheNames = "setmealCache", key = "#setmealDTO.categoryId")
    public Result save(@RequestBody SetmealDTO setmealDTO){
        log.info("新增套餐：{}", setmealDTO);
        setmealService.saveWithDish(setmealDTO);
        return Result.success();
    }

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

    /**
     * 批量删除套餐
     * @param ids
     * @return
     */
    @DeleteMapping
    @ApiOperation("批量删除套餐")
    @CacheEvict(cacheNames = "setmealCache", allEntries = true)
    public Result delete(@RequestParam List<Long> ids){
        log.info("批量删除套餐：{}", ids);
        setmealService.deleteBatch(ids);
        return Result.success();
    }

    /**
     * 根据id查询套餐，用于修改页面回显数据
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    @ApiOperation("根据id查询套餐")
    public Result<SetmealVO> getByID(@PathVariable Long id){
        SetmealVO setmealVO = setmealService.getByIdWithDish(id);
        return Result.success(setmealVO);
    }

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

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

c. 购物车

(1). 添加购物车

数据库设计：

作用：暂时存放所选商品的地方
选的什么商品
每个商品都买了几个
不同用户的购物车需要区分开

在用户端创建ShoppingCartController，实现添加购物车接口

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

    @Autowired
    private ShoppingCartService shoppingCartService;

    /**
     * 添加购物车
     * @param shoppingCartDTO
     * @return
     */
    @PostMapping("/add")
    @ApiOperation("添加购物车")
    public Result add(@RequestBody ShoppingCartDTO shoppingCartDTO){
        log.info("添加购物车，商品信息为：{}", shoppingCartDTO);
        shoppingCartService.addShoppingCart(shoppingCartDTO);
        return Result.success();
    }
}

在ShoppingCartServiceImpl，实现添加购物车方法，及其父类接口

@Service
@Slf4j
public class ShoppingCartServiceImpl implements ShoppingCartService {

    @Autowired
    private ShoppingCartMapper shoppingCartMapper;

    @Autowired
    private DishMapper dishMapper;

    @Autowired
    private SetmealMapper setmealMapper;

    /**
     * 添加购物车
     * @param shoppingCartDTO
     */
    @Override
    public void addShoppingCart(ShoppingCartDTO shoppingCartDTO) {
        // 判断当前加入购物车中的商品是否已经存在
        ShoppingCart shoppingCart = new ShoppingCart();
        BeanUtils.copyProperties(shoppingCartDTO, shoppingCart);
        Long userId = BaseContext.getCurrentId();
        shoppingCart.setUserId(userId);

        List<ShoppingCart> list = shoppingCartMapper.list(shoppingCart);

        // 如果已经存在，只需要数量+1
        if (list != null && list.size() > 0){
            ShoppingCart cart = list.get(0);
            cart.setNumber(cart.getNumber() + 1);
            shoppingCartMapper.updateNumberById(cart);
        }else {
            // 如果不存在，需要插入一条购物车数据
            // 判断本次添加到购物车的是菜品还是套餐
            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 {
                // 本次添加到购物车的是套餐
                Long setmealId = shoppingCartDTO.getSetmealId();
                Setmeal setmeal = setmealMapper.getById(setmealId);
                shoppingCart.setName(setmeal.getName());
                shoppingCart.setImage(setmeal.getImage());
                shoppingCart.setAmount(setmeal.getPrice());

            }
            shoppingCart.setNumber(1);
        	shoppingCart.setCreateTime(LocalDateTime.now());
        	shoppingCartMapper.insert(shoppingCart);
        }
    }
}

在ShoopingCartMapper中，创建动态条件查询购物车的接口

@Mapper
public interface ShoppingCartMapper {
    /**
     * 动态条件查询
     * @param shoppingCart
     * @return
     */
    List<ShoppingCart> list(ShoppingCart shoppingCart);
}

在ShoopingCartMapper.xml中，写入动态查询的SQL语句

<?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" resultType="com.sky.entity.ShoppingCart">
        select * from shopping_cart
        <where>
            <if test="userId != null">and user_id = #{userId}</if>
            <if test="setmealId != null">and setmeal_id = #{setmealId}</if>
            <if test="dishId != null">and dish_id = #{dishId}</if>
            <if test="dishFlavor != null">and dish_flavor = #{dishFlavor}</if>
        </where>
    </select>
</mapper>

如果商品已经存在，数量加1。ShoopingCartMapper中写update方法

/**
 * 根据id修改商品数量
 * @param shoppingCart
 */
@Update("update shooping_cart set number = #{number} where id = #{id}")
void updateNumberById(ShoppingCart shoppingCart);

如果不存在，需要插入一条购物车数据。ShoopingCartMapper中写Insert方法

/**
 * 插入购物车数据
 * @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);

(2). 查看购物车

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

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

在ShoppingCartServiceImpl中实现查看购物车的方法，及其父类接口

/**
 * 查看购物车
 * @return
 */
@Override
public List<ShoppingCart> showShoppingCart() {
    // 获取当前用户的id
    Long userId = BaseContext.getCurrentId();
    ShoppingCart cart = ShoppingCart.builder()
                    .userId(userId)
                    .build();

    List<ShoppingCart> list = shoppingCartMapper.list(cart);
    return list;
}

(3). 清空购物车

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

/**
 * 清空购物车
 * @return
 */
@DeleteMapping("/clean")
@ApiOperation("清空购物车")
public Result delete(){
    shoppingCartService.cleanShoppingCart();
    return Result.success();
}

在ShoppingCartServiceImpl中实现清空购物车的方法，及其父类接口

/**
 * 清空购物车
 */
@Override
public void cleanShoppingCart() {
    // 获取当前用户的id
    Long userId = BaseContext.getCurrentId();
    ShoppingCart cart = ShoppingCart.builder()
            .userId(userId)
            .build();
    shoppingCartMapper.deleteByUserId(userId);
}

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

/**
 * 清空购物车
 * @param userId
 */
@Delete("Delete from shopping_cart where user_id = #{userId}")
void deleteByUserId(Long userId);

(4). 删除购物车中一个商品

在ShoppingCartController中，创建删除购物车中一个商品的方法

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

在ShoppingCartServiceImpl中，实现删除购物车中一个商品的方法，及其父类接口

/**
 * 删除购物车中一个商品
 * @param shoppingCartDTO
 */
@Override
public void subShoppingCart(ShoppingCartDTO shoppingCartDTO) {
    ShoppingCart shoppingCart = new ShoppingCart();
    BeanUtils.copyProperties(shoppingCartDTO, shoppingCart);
    //设置查询条件，查询当前登录用户的购物车数据
    shoppingCart.setUserId(BaseContext.getCurrentId());

    List<ShoppingCart> list = shoppingCartMapper.list(shoppingCart);

    if(list != null && list.size() > 0){
        shoppingCart = list.get(0);

        Integer number = shoppingCart.getNumber();
        if(number == 1){
            //当前商品在购物车中的份数为1，直接删除当前记录
            shoppingCartMapper.deleteById(shoppingCart.getId());
        }else {
            //当前商品在购物车中的份数不为1，修改份数即可
            shoppingCart.setNumber(shoppingCart.getNumber() - 1);
            shoppingCartMapper.updateNumberById(shoppingCart);
        }
    }
}

在ShoppingCartMapper中，当前商品在购物车中的份数为1，直接删除当前记录

/**
 * 根据id删除购物车数据
 * @param id
 */
@Delete("delete from shopping_cart where id = #{id}")
void deleteById(Long id);

一条粉肠与蛋散

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
3
评论
itheima苍穹外卖项目学习笔记--Day7：缓存商品 / 购物车

在ShoppingCartServiceImpl中，实现删除购物车中一个商品的方法，及其父类接口。如果不存在，需要插入一条购物车数据。在ShoppingCartMapper中，当前商品在购物车中的份数为1，直接删除当前记录。在ShoppingCartServiceImpl中实现查看购物车的方法，及其父类接口。如果商品已经存在，数量加1。在ShoppingCartServiceImpl中实现清空购物车的方法，及其父类接口。在ShoppingCartController中，创建删除购物车中一个商品的方法。
复制链接

扫一扫