SpringBoot + Redis 实现增删改查的缓存

Redis 依赖引入

<!--使用redis服务-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

• application.yml文件配置
  设置redis的连接地址和端口号，如果有密码可设置密码

  redis:
    host: 127.0.0.1
    port: 6379
    #password: 123456
    database: 0     #操作的是0号数据库
  cache:
    redis:
      time-to-live: 1800000  #设置缓存数据的过期时间

在springboot中可直接创建变量使用注解注入，springboot会自动将操作redis的对象bean创建出来注入。

@Resource
    private RedisTemplate redisTemplate;

• 新建key序列化配置类
  在直接使用RedisTemplate 对象时创建key和value会使用自带的序列化器，会使key和value前面上传一串字符，可使用配置类重新定义序列化器，使创建key时恢复成设置的名称，value则不用，因为在代码中get出值的时候会自动反序列化，恢复正常。

/**
 * Redis配置类
 */

import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import javax.annotation.Resource;

@Configuration
public class RedisConfig extends CachingConfigurerSupport {
    @Resource
    RedisConnectionFactory redisConnectionFactory;

    @Bean
    public RedisTemplate<Object,Object> redisTemplate(){
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();

        //默认的Key序列化器为：JdkSerializationRedisSerializer
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        redisTemplate.setConnectionFactory(redisConnectionFactory);

        return redisTemplate;
    }
}

• 查询的时候，先从redis中查找数据，没有则在数据库中查询，然后保存到redis中，第二次查找时就可以从redis中找到数据。

@GetMapping("/list")
    public R<List<DishDto>> list(Dish dish){
        List<DishDto> listDishDto = null;

        String key = "dish_" + dish.getCategoryId() + "_" + dish.getStatus();
        //根据key先从redis中获取缓存数据
        listDishDto = (List<DishDto>) redisTemplate.opsForValue().get(key);
        //如果存在，直接返回，无需查询数据库
        if (listDishDto != null){
            return R.success(listDishDto);
        }

        //构造查询条件
        LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(dish.getCategoryId() != null,Dish::getCategoryId,dish.getCategoryId());
        //添加查询条件
        queryWrapper.eq(Dish::getStatus,1);
        //添加排序条件
        queryWrapper.orderByAsc(Dish::getSort).orderByDesc(Dish::getUpdateTime);

        List<Dish> list = dishService.list(queryWrapper);

        listDishDto = list.stream().map((item) -> {
            DishDto dishDto = new DishDto();
            BeanUtils.copyProperties(item,dishDto);

            LambdaQueryWrapper<DishFlavor> queryWrapper1 = new LambdaQueryWrapper<>();
            queryWrapper1.eq(DishFlavor::getDishId,dishDto.getId());
            //根据id查询分类
            List<DishFlavor> dishFlavors = dishFlavorService.list(queryWrapper1);
            dishDto.setFlavors(dishFlavors);

            return dishDto;
        }).collect(Collectors.toList());

        //如果不存在需要查询数据库，将查询到的菜品数据缓存到redis，设置过期时间为60分钟
        redisTemplate.opsForValue().set(key,listDishDto,60, TimeUnit.MINUTES);

        return R.success(listDishDto);

    }

• 删除、新增、修改操作时因为数据改变，所以需要根据保存的key将redis中的缓存数据删除。

 /**
     * 停售、批量停售菜品
     * @param ids
     */
    @PostMapping("/status/{status}")
    public R<String> StopById(@RequestParam List<Long> ids,@PathVariable Integer status){
        //获取所有以setmeal_*开头的key
        Set setmealKeys = redisTemplate.keys("setmeal_*");
        //清理这些key中的所有缓存数据
        redisTemplate.delete(setmealKeys);
        //在数据库中删除
        dishService.stopByIdWithdish(ids, status);
        return R.success("成功");
    }