Day-07

最新推荐文章于 2024-03-25 15:00:59 发布

过尽漉雪千山

最新推荐文章于 2024-03-25 15:00:59 发布

阅读量441

点赞数 1

分类专栏：黑马程序员Java项目实战《苍穹外卖》学习笔记文章标签： java spring java-ee 后端 spring boot

本文链接：https://blog.csdn.net/qq_63665506/article/details/131671522

版权

黑马程序员Java项目实战《苍穹外卖》学习笔记专栏收录该内容

13 篇文章 8 订阅

订阅专栏

Spring Cache

Spring Cache 是一个框架，实现了Spring基于注解支持缓存(Cache)功能。Spring Cache 提供了一层抽象，底层可以切换不同的缓存实现，例如：EHCache、Caffeine、Redis(常用)。

常用注解

基本使用

（1）导入依赖

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

然后根据需求导入需要的Cache技术的依赖，Spring Cache会自动以该Cache技术实现缓存。

（2）在启动类上加上@EnableCaching注解，开启注解缓存功能。

（2）在Controller方法上加上需要的注解

有两个属性值，cacheNames和key，若其值分别为userCache和101，则生成在Redis中的key为userCache::101。key的写法是SpEL表达式。

业务功能

缓存菜品

主要是利用Redis对原代码进行优化，加入缓存逻辑。

（1）C端DishController修改

@RestController("userDishController")
@RequestMapping("/user/dish")
@Slf4j
@Api(tags = "C端-菜品浏览接口")
public class DishController {
    @Autowired
    private DishService dishService;

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

为保证管理端和用户端数据的一致性，在管理端对数据进行修改操作后，需要对缓存进行清理。在管理端加入清理缓存逻辑。

（2）抽取清理缓存的方法

@Autowired
private RedisTemplate redisTemplate;

/**
 * 清理缓存数据
 * @param pattern
 */
private void cleanCache(String pattern){
    // 根据key进行批量删除
    Set keys = redisTemplate.keys(pattern);
    redisTemplate.delete(keys);
}

（3）修改管理端Controller层中的方法

新增菜品

    @PostMapping
    @ApiOperation("新增菜品")
    public Result<Void> save(@RequestBody DishDTO dishDTO) {
        log.info("新增菜品：{}", dishDTO);
        dishService.saveWithFlavor(dishDTO);

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

批量删除

    @DeleteMapping
    @ApiOperation("菜品批量删除")
    public Result<Void> deleteBatch(@RequestParam List<Long> ids) {
        log.info("菜品批量删除：{}", ids);
        dishService.deleteBatch(ids);

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

        return Result.success();
    }

修改菜品

    @PutMapping
    @ApiOperation("修改菜品")
    public Result<Void> update(@RequestBody DishDTO dishDTO) {
        log.info("修改菜品：{}", dishDTO);
        dishService.updateWithFlavor(dishDTO);

        // 清理掉所有缓存数据
        cleanCache("dish_*");
        return Result.success();
    }

启售/停售菜品

    @PostMapping("/status/{status}")
    @ApiOperation("启售/停售菜品")
    public Result<Void> startOrStop(@PathVariable("status") Integer status, Long id) {
        log.info("启售/停售菜品：{}, {}", id, status);
        dishService.startOrStop(id, status);

        // 清理掉所有缓存数据
        cleanCache("dish_*");
        return Result.success();
    }

缓存套餐

利用Spring Cahce的注解方式实现缓存，对用户端和管理端的SetmealController层代码进行优化。

（1）在C端的分类查询方法上加上@Cacheable注解

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

可实现先从redis中查询是否存在该套餐的数据，有则直接返回，没有则从数据库查询，将查询结果数据存到redis中并返回。

（2）在管理端的方法上加上@CacheEvict注解

对进行了修改数据操作后清理缓存。

新增套餐

    @PostMapping
    @ApiOperation("新增套餐")
    // 对categoryId分类的数据缓存进行清理
    @CacheEvict(cacheNames = "setmealCache", key = "#setmealDTO.categoryId")
    public Result<Void> save(@RequestBody SetmealDTO setmealDTO) {
        log.info("新增套餐：{}", setmealDTO);
        setmealService.saveWithDish(setmealDTO);
        return Result.success();
    }

批量删除

    @DeleteMapping
    @ApiOperation("批量删除套餐")
    // 对所有分类数据缓存进行清理
    @CacheEvict(cacheNames = "setmealCache", allEntries = true)
    public Result<Void> deleteBatch(@RequestParam List<Long> ids) {
        log.info("批量删除套餐：{}", ids);
        setmealService.deleteBatch(ids);
        return Result.success();
    }

修改套餐

    @PutMapping
    @ApiOperation("修改套餐")
    // 对所有分类数据缓存进行清理
    @CacheEvict(cacheNames = "setmealCache", allEntries = true)
    public Result<Void> update(@RequestBody SetmealDTO setmealDTO) {
        log.info("修改套餐");
        setmealService.update(setmealDTO);
        return Result.success();
    }

启售/停售套餐

    @PostMapping("/status/{status}")
    @ApiOperation("启售/停售套餐")
    // 对所有分类数据缓存进行清理
    @CacheEvict(cacheNames = "setmealCache", allEntries = true)
    public Result<Void> startOrStop(@PathVariable("status") Integer status, Long id) {
        log.info("启售/停售套餐：{}, {}", id, status);
        setmealService.startOrStop(id, status);
        return Result.success();
    }

添加购物车

service层代码

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

        // 利用动态SQL，如果添加的是菜品，则返回菜品结果；如果添加的是套餐，则返回套餐结果。
        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);
        }
    }