一、redis缓存

1.1 缓存验证码

不用sesiion，而使用redis来存放验证码。
首先在用户请求验证码，将验证码保存在sesion中，当登录成功之后，将redis中的验证码删除掉。

   @Autowired
    private RedisTemplate redisTemplate;
    @PostMapping("/sendMsg")
    public R<String> snedMsg(@RequestBody User user,HttpSession httpSession){
        log.info(user.toString());
        //获取手机号
        String phone = user.getPhone().toString();
        if (StringUtils.isNotEmpty(phone)) {
            //手机号不为空发送验证码
            String code = ValidateCodeUtils.generateValidateCode(4).toString();
            log.info(code.toString());
//            SMSUtils.sendMessage("","",phone,"");//发送手机验证码
            //httpSession.setAttribute(phone,code); //将生成的验证码保存到session中


            //将验证码保存到redis中 并设置时间为5分钟
            redisTemplate.opsForValue().set(phone,code,5, TimeUnit.MINUTES);
            return R.success("验证码发送成功");

        }
        return R.error("验证码发送失败");
    }

    @PostMapping("/login")
    public R<User> login(@RequestBody Map map,HttpSession session){
        //获得手机号
        String phone = map.get("phone").toString();
        //获得验证码
        String code = map.get("code").toString();
       // Object sessionCode = session.getAttribute(phone);
        //从redis中获取验证码
        Object sessionCode = redisTemplate.opsForValue().get(phone);
        //比对验证码是否一致
        if (sessionCode!=null && sessionCode.equals(code)) {
            //看数据库中是否有该用户
            LambdaUpdateWrapper<User> lambdaUpdateWrapper=new LambdaUpdateWrapper<>();
            lambdaUpdateWrapper.eq(User::getPhone,phone);
            User user = userService.getOne(lambdaUpdateWrapper);
            if (user ==null) {
                //没有，保存一个
                user=new User();
                user.setPhone(phone);
                user.setStatus(1);
                userService.save(user);

            }
            session.setAttribute("user",user.getId());
            //用户登陆成功 则将验证码删除
            redisTemplate.delete(phone);
            return R.success(user);
        }
        return R.error("验证失败");
    }

1.2 缓存菜品数据

如果我们不放入redis，就会导致每次发送ajax请求，都需要去查询数据库，造成很大负担。
我们可以先去redis中查询，如果没有，再去数据库中查，如果有则直接返回。
没有的话，将其保存到redis中。

还有就是更新和保存的时候，要把redis中的数据清空，保证数据一致性。

    /**
     * 保存 修改过的菜品和菜品对应的口味信息
     * @param dishDto
     * @return
     */
    @PutMapping
    public R<String> updateDish(@RequestBody DishDto dishDto){
        dishService.updatewithFlavor(dishDto);
        //清除所有菜品缓存数据
        Set keys = redisTemplate.keys("dish_ID*");
        redisTemplate.delete(keys);
        //清除某个分类
        String key="dish_ID"+dishDto.getCategoryId()+"_1";
        redisTemplate.delete(key);
        return R.success("修改菜品成功");
    }

 /**
     * 增加菜品信息
     * @param dishDto
     * @return
     */
    @PostMapping
    public R<String> addDish(@RequestBody DishDto dishDto){
        dishService.addwithFlavor(dishDto);
        //清除某个分类
        String key="dish_ID"+dishDto.getCategoryId()+"_1";
        redisTemplate.delete(key);
        return R.success("新增菜品成功");
    }

二、spring-cache

个人觉得了解即可吧，没深究
就是spring提供的一个缓存机制。可以直接通过注解的方式使用缓存，不用注入redis。

首先导入pom

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

不导入redis 的则使用默认的
如果导入redis 则使用redis的

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

二、Spring Cache注解一览

1. @Cacheable
   @Cacheable 是最常用的注解之一，用于标记可缓存的方法。当一个方法被@Cacheable 注解后，Spring会在方法执行前检查缓存中是否存在已缓存的结果，如果存在，则直接从缓存中返回；若不存在，则执行方法并将结果放入缓存中。

@Service
public class UserService {

    @Cacheable(value = "userCache", key = "#id")
    public User getUserById(Long id) {
        // 查询数据库或其他资源的操作
    }

在这个例子中，value 参数指定了缓存名称，而 key 参数定义了缓存键的生成规则，这里使用SpEL表达式表示传入方法的参数值。

2. @CacheEvict
   @CacheEvict 注解用于删除缓存项。它可以单独使用或与@Cacheable 结合，实现数据更新后的缓存同步。

@Service
public class UserService {

    @CacheEvict(value = "userCache", key = "#id")
    public void updateUser(User user) {
        // 更新用户信息操作
    }
}

此处，当调用updateUser方法时，会根据指定的key策略清除对应缓存项。

3. @CachePut
   @CachePut 注解则用于强制执行方法并始终更新缓存，无论方法是否返回null或者已经存在缓存。

@Service
public class ProductService {

    @CachePut(value = "productCache", key = "#product.id")
    public Product updateProduct(Product product) {
        // 更新产品信息操作
        return product;
    }
}

4. @Caching
   @Caching 注解允许在一个方法上组合多个缓存操作，例如同时进行缓存读取和清理。

@Service
public class OrderService {

    @Caching(evict = {
            @CacheEvict(value = "orderCache", allEntries = true),
            @CacheEvict(value = "itemCache", key = "#orderId")
    }, put = @CachePut(value = "orderSummaryCache", key = "#summaryId"))
    public void processOrder(Order order, Long summaryId) {
        // 处理订单及其相关项操作
    }