苍穹外卖Day7深度解析：从缓存优化到购物车全流程实现

在构建高性能外卖系统时，后端架构的每一个细节都至关重要。今天，我们将深入苍穹外卖项目的Day7内容，聚焦于如何通过Redis缓存优化菜品与套餐查询、利用Spring Cache简化缓存管理，并完整实现购物车的增删查功能。本文不仅会拆解核心代码逻辑，还会分享一些生产环境下的最佳实践与常见问题解决方案。

1. 缓存菜品：从数据库到Redis的性能飞跃

在服务端开发中，数据库往往是性能瓶颈。对于菜品这类变动频率低、查询频率高的数据，引入缓存是提升API响应速度的经典手段。

实现思路：我们利用Redis作为中间件，为每个分类下的菜品保存一份缓存数据。当用户通过分类ID查询菜品时，优先从Redis读取，只有当缓存未命中时才查询数据库。同时，为了保证数据一致性，任何对菜品的增删改操作都必须及时清理对应的缓存。

⚠️ 缓存逻辑分析：

• 每个分类下的菜品保存一份独立缓存，减少内存占用
• 数据库中的菜品数据发生变更时，必须清理缓存，避免脏读
• 批量清理（如修改、删除菜品）可简化代码，但需权衡缓存重建的开销

具体到代码实现，首先修改user.DishController中的list方法，加入缓存读取逻辑：

/**
* 根据分类id查询菜品
*
* @param categoryId
* @return
*/
@GetMapping("/list")
@ApiOperation("根据分类id查询菜品")
public Result<List<DishVO>> list(Long categoryId) {
  //构造Redis中的key
  String key = "dish_" + categoryId;
  //查询Redis中是否存在菜品数据
  List<DishVO> list = (List<DishVO>)redisTemplate.opsForValue().get(key);
    if(list != null && list.size() != 0){
    //若存在就直接返回，无需查询数据库
    return Result.success(list);
    }
    //若不存在，查询数据库，将查询到的数据放入Redis中
    Dish dish = new Dish();
    dish.setCategoryId(categoryId);
    dish.setStatus(StatusConstant.ENABLE);//查询起售中的菜品
    list = dishService.listWithFlavor(dish);
    redisTemplate.opsForValue().set(key,list);
    return Result.success(list);
    }

接着，在admin.DishController中改造新增、修改、批量删除、起售/停售等接口，确保每次操作后清理缓存。为了简化开发，我们可以选择清理全部缓存，虽然会短暂增加数据库压力，但能有效避免数据不一致：

@Autowired
private RedisTemplate redisTemplate;

最终修改后的DishController完整代码示例如下：

@RestController
@RequestMapping("/admin/dish")
@Slf4j
public class DishController {
@Autowired
private DishService dishService;
@Autowired
private RedisTemplate redisTemplate;
//新增菜品
@PostMapping
public Result save(@RequestBody DishDTO dishDTO) {
log.info("新增菜品：{}",dishDTO);
dishService.saveWithFlavor(dishDTO);
//清理缓存数据
String key = "dish_" + dishDTO.getCategoryId();
cleanCache(key);
return Result.success();
}
//菜品分页查询
@GetMapping("/page")
public Result<PageResult> page(DishPageQueryDTO dishPageQueryDTO){
  log.info("菜品分页查询：{}",dishPageQueryDTO);
  PageResult pageResult = dishService.pageQuery(dishPageQueryDTO);
  return Result.success(pageResult);
  }
  //菜品删除
  @DeleteMapping
  public Result delete(@RequestParam List<Long> ids){
    log.info("菜品批量删除：{}",ids);
    dishService.deleteBatch(ids);
    //将所有菜品缓存数据都清理掉
    cleanCache("dish_*");
    return Result.success();
    }
    //根据id查询数据
    @GetMapping("/{id}")
    public Result<DishVO> getById(@PathVariable Long id) {
      log.info("根据id查询商品：{}",id);
      DishVO dishVO = dishService.getByIdWithFlavor(id);
      return Result.success(dishVO);
      }
      //修改菜品
      @PutMapping
      public Result update(@RequestBody DishDTO dishDTO) {
      log.info("修改菜品：{}",dishDTO);
      dishService.updateWithFlavor(dishDTO);
      //将所有菜品缓存数据都清理掉
      cleanCache("dish_*");
      return Result.success();
      }
      //起售停售
      @PostMapping("/status/{status}")
      public Result updateStatus(@PathVariable Integer status, Long id){
      log.info("修改id菜品起售停售：{}",id);
      dishService.updateStatus(status,id);
      //将所有的菜品缓存全部清理
      cleanCache("dish_*");
      return Result.success();
      }
      //根据分类id查询菜品
      @GetMapping("/list")
      public Result<List<Dish>> list(Long categoryId){
        log.info("根据分类id查询菜品：{}",categoryId);
        List<Dish> dishList = dishService.list(categoryId);
          return Result.success(dishList);
          }
          private void cleanCache(String pattern) {
          //将所有菜品缓存数据都清理掉
          Set keys = redisTemplate.keys(pattern);
          redisTemplate.delete(keys);
          }
          }

最佳实践：生产环境中建议采用精确缓存失效策略，即只清理受影响分类的缓存，避免大面积缓存击穿。同时，可以设置合理的过期时间（如30分钟）作为兜底方案。

2. 缓存套餐：Spring Cache的优雅注解

套餐数据与菜品类似，同样适合缓存。但这次我们引入Spring Cache框架，它提供了一套声明式缓存注解，底层可无缝切换Redis、EHCache、Caffeine等实现，极大简化了缓存代码。

✅ 常用注解：

• @Cacheable：将方法结果缓存，下次直接返回缓存值
• @CacheEvict：清理缓存，常用于更新或删除操作
• @CachePut：更新缓存，不干扰方法执行

实现步骤如下：

1. 在sky-server模块的启动类上添加@EnableCaching注解，开启缓存功能：

@EnableCaching

2. 在用户端SetmealController的list方法上添加@Cacheable，缓存套餐列表：

@Cacheable(cacheNames="setmealCache",key="#categoryId") //key: setmealCache::100

3. 在管理端SetmealController的save方法上添加@CacheEvict，新增后清理缓存：

@CacheEvict(cacheNames="setmealCache",key="#setmealDTO.categoryId")

4. 同样，在update、delete、startOrStop等方法上也添加@CacheEvict：

@CacheEvict(cacheNames = "setmealCache",allEntries = true)

常见问题：如果缓存未能按预期清理，请检查注解的key属性是否与@Cacheable中的一致。此外，Spring Cache默认使用SimpleKeyGenerator，当方法参数为基本类型时，key会自动拼接参数值。

[AFFILIATE_SLOT_1]

3. 购物车核心功能：添加、查看与清空

购物车是外卖系统的核心模块，它作为临时数据容器，记录了用户选择的商品、数量及规格。在设计后端架构时，我们需要为购物车表设计合理的字段，并确保不同用户的购物车数据相互隔离。

3.1 数据库设计与实体类

首先，在实体类中新增购物车相关字段，包括商品ID、数量、口味、是否套餐等：

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

3.2 添加购物车

在ShoppingCartServiceImpl中实现添加逻辑：先查询该用户是否已存在相同商品，若存在则增加数量，否则新增记录：

//添加购物车
@Override
public void addShoppingCart(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 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);
  }
  }

Mapper层需要提供插入和查询接口：

//动态条件查询数据
List<ShoppingCart> list(ShoppingCart shoppingCart);
  //根据id修改商品数量
  @Update("update shopping_cart set number = #{number} where id = #{id}")
  void updateNumberById(ShoppingCart cart);
  //插入商品到购物车
  @Insert("insert into shopping_cart(name,user_id,dish_id,setmeal_id,dish_flavor,number,amount,image,create_time)" +
  "value (#{name},#{userId},#{dishId},#{setmealId},#{dishFlavor},#{number},#{amount},#{image},#{createTime})")
  void insert(ShoppingCart shoppingCart);
  //根据用户id删除数据
  @Delete("delete from shopping_cart where user_id = #{userId}")
  void deleteByUserId(Long userId);

对应的XML映射文件编写动态SQL，支持按用户ID、商品ID等条件查询：

<?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>

3.3 查看购物车

Controller层接收用户ID，调用Service层查询：

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

Service实现类直接通过Mapper查询当前用户的购物车列表：

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

3.4 清空购物车

清空操作通常发生在用户下单后，Controller层如下：

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

Service层执行删除操作，注意必须限定用户ID，防止误删其他用户数据：

//清空购物车
@Override
public void cleanShoppingCart() {
Long userId = BaseContext.getCurrentId();
shoppingCartMapper.deleteByUserId(userId);
}

⚠️ 安全提示：所有购物车操作都应在Service层或通过AOP获取当前登录用户ID，避免依赖前端传入，防止越权操作。

4. 总结与下一步优化方向

本文完整梳理了苍穹外卖Day7的核心内容：通过Redis缓存菜品与套餐，利用Spring Cache注解简化缓存管理，并实现了购物车的增删查功能。这些实践不仅提升了API响应速度，也展示了如何在后端架构中优雅地处理数据一致性与并发问题。

未来可以探索：

• 使用Redis的Hash结构存储购物车，支持更灵活的字段扩展
• 引入消息队列实现缓存与数据库的最终一致性
• 对购物车接口进行限流与幂等性设计，防止重复提交

[AFFILIATE_SLOT_2]

完整项目代码可在GitHub上查看：rannn-1127/sky-take-out（持续更新中）。希望本文能帮助你在实际项目中少走弯路，构建更稳定、高效的服务端应用。