【SpringBoot】结合Redis实现缓存

Redis经常用于缓存。接下来，我们以Springboot框架为例。实现一些Redis的基础操作，创建完SpingBoot项目后，具体步骤如下图：

 

 

pom中添加项目依赖

<!-- Redis 缓存-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>2.5.15</version>
</dependency>
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>2.5.12</version>
</dependency>

配置Redis连接

打开配置文件（以application.yml为例）

spring:
  redis:
    database: 0     # 数据库索引，默认为0
    host: 127.0.0.1 # redis地址
    port: 6379      # redis服务器端口地址 
    # sping.redis.password 表示密码，因为密码为空，这里不设置
    jedis:
      pool:
        max-wait: 3000  # 连接池最大阻塞等待时间，单位毫秒（使用负值表示没有限制）
        min-idle: 0     # 连接池最小空闲时间
    timeout: 3000       # 连接超时时间（毫秒）

编写Redis配置文件

新建配置文件。这里实现了连接配置工厂和序列化。（需要序列化，否则存储的中文，不可阅读）

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * RedisTemplate相关配置
     * 使redis支持插入对象
     *
     * @param factory
     * @return 方法缓存 Methods the cache
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);
        // 序列化 key 和hashKey采用String序列化；value和hashValue采用JSON序列化
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        // value和hashvalue采用JSON序列化
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(jsonRedisSerializer);
        return template;
    }
}

测试Redis缓存

写入测试方法，发现能够完成Redis的存储与读取。

@SpringBootTest
public class RedisTest {
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private RedisUtils redisUtils;
    /**
     * 测试添加String类型
     * @author lyj
     * @date 2024-09-28
     */
    @Test
    public void testAddString(){
        String key = "redisTest:user:name";
        String value = "张三";
        redisTemplate.opsForValue().set(key,value);
        System.out.println(redisTemplate.opsForValue().get(key));
    }
    /**
     * 测试添加Object类型
     * @author lyj
     * @date 2024-09-28
     */
    @Test
    public void testAddObject(){
        String key = "redisTest:user:1";
        SysUser sysUser = new SysUser();
        sysUser.setId(1);
        sysUser.setUsername("林冲");
        sysUser.setPassword("123456");
        redisTemplate.opsForValue().set(key,sysUser);
    }
    
    /**
     * 测试读取redis
     * @author lyj
     * @date 2024-09-28
     */
    @Test
    public void testGet(){
        String key = "redisTest:user:name";
        System.out.println( redisTemplate.opsForValue().get(key));      // 张三
    }
}

 

发现，能够实现类的创建和读取。

 

创建Redis缓存工具类

上面案例都是直接用RedisTemplate操作Redis。我们可以实现，RedisUtils交给Spring容器实例化，使用时直接注解注入，使用方便简单，减少使用难度。

@Component
public class RedisUtils {
    @Autowired
    private RedisTemplate redisTemplate;

    public RedisUtils(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    //region 基础操作
    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间（秒）
     * @return
     */
    public  boolean expire(String key,long time){
        try {
            if(time > 0){
                redisTemplate.expire(key,time, TimeUnit.SECONDS);
            }
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据可以获取过期时间
     * @param key 键（不能为null)
     * @return 返回单位秒，返回 -1 代表永久有效
     */
    public long getExpire(String key){
        return  redisTemplate.getExpire(key,TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     * @param key 键
     * @return
     */
    public boolean hasKey(String key){
        try{
            return redisTemplate.hasKey(key);
        }catch (Exception e){
            e.printStackTrace();
            return  false;
        }
    }

    /**
     * 删除1个或多个缓存
     * @param keys
     */
    public long del(String ...keys){
        if(keys != null && keys.length > 0){
            if(keys.length ==1){
                return  redisTemplate.delete(keys[0]) ? 1L:0L;
            }else {
               return redisTemplate.delete(CollectionUtils.arrayToList(keys)) ;
            }
        }
        return  0L;
    }

    /**
     * 模糊查询获取key值
     * @param pattern
     * @return
     */
    public Set keys(String pattern){
        return  redisTemplate.keys(pattern);
    }

    /**
     * 使用redis的消息队列
     * @param channel
     * @param message 消息内容
     */
    public  void  convertAndSend(String channel, Object message){
        redisTemplate.convertAndSend(channel,message);
    }
    //endregion
    //region String

    /**
     * 获取普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key){
        return key == null? null: redisTemplate.opsForValue().get(key);
    }

    /**
     * 设置普通缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public boolean set(String key, Object value){
        try{
            redisTemplate.opsForValue().set(key,value);
            return  true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 设置缓存放入，并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间秒（time值小于0，怎设置无限期）
     * @return
     */
    public  boolean set(String key,Object value, long time){
        try{
            if(time > 0){
                redisTemplate.opsForValue().set(key,value,time,TimeUnit.SECONDS);
            }else {
                redisTemplate.opsForValue().set(key,value);
            }
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     * @param key 键
     * @param delta 要增加的值
     * @return
     */
    public long incr(String key,long delta){
        if(delta < 0){
            throw new RuntimeException("递增因子，必须大于0");
        }
        return  redisTemplate.opsForValue().increment(key,delta);
    }

    /**
     * 递减
     * @param key 键
     * @param delta 要减小的值
     * @return
     */
    public long descr(String key ,long delta){
        if(delta < 0){
            throw new RuntimeException("递减因子，必须大于0");
        }
        return  redisTemplate.opsForValue().increment(key,-delta);
    }
    //endregion
    //region hash
    /**
     * 向一张hash表中放入数据，如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @return
     */
    public  boolean hset(String key, String item, Object value){
        try{
            redisTemplate.opsForHash().put(key,item,value);
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 向一张表中放入数据，如果不存在，则创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @param time 时间（秒），如果已存在的hash表有时间，这里将会替换原有的时间
     * @return
     */
    public boolean hset(String key, String item, Object value, long time){
        try{
            redisTemplate.opsForHash().put(key,item,value);
            if(time > 0){
                redisTemplate.expire(key,time, TimeUnit.SECONDS);
            }
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 删除hash表中的值
     * @param key 键
     * @param items 项，可以多个，不能为空
     */
    public  void hdel(String key, Object ...items){
        redisTemplate.opsForHash().delete(key, items);
    }

    /**
     * 获取Hash值
     * @param key 键，不能为空
     * @param item 项目不能为空
     * @return
     */
    public  Object hget(String key, String item){
        return redisTemplate.opsForHash().get(key,item);
    }

    /**
     * 获取HashKey的所有键值
     * @param key 键
     * @return
     */
    public  Map<Object,Object> hmget(String key){
        return  redisTemplate.opsForHash().entries(key);
    }
    /**
     * 设置HashKey的所有键值
     * @param key 键
     * @param map 对应多个键值
     * @return
     */
    public  boolean hmset(String key, Map<String , Object> map){
        try {
            redisTemplate.opsForHash().putAll(key,map);
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
        return  true;
    }

    /**
     * HashSet 并设置时间
     * @param key 键
     * @param map 对应多个键值
     * @param time 时间（秒）
     * @return
     */
    public  boolean hmset(String key, Map<String , Object> map,long time){
        try {
            redisTemplate.opsForHash().putAll(key,map);
            if(time > 0){
                redisTemplate.expire(key,time,TimeUnit.SECONDS);
            }
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
        return  true;
    }

    /**
     * 判断hash表中是否有该项值
     * @param key 键，不能为空
     * @param item 项，不能为空
     * @return
     */
    public  boolean hHashKey(String  key,String item){
        return  redisTemplate.opsForHash().hasKey(key,item);
    }

    /**
     * hash递增，如果不存在就会创建一个，并把新增后的值返回
     * @param key 键
     * @param item 项
     * @param by 要增大几（大于0）
     * @return
     */
    public double hinc(String key, String item, double by){
        return  redisTemplate.opsForHash().increment(key,item,by);
    }

    /**
     * hash递减
     * @param key 键
     * @param item 项
     * @param by 要减小几（大于0）
     * @return
     */
    public double hdescr(String key, String item, double by){
        return  redisTemplate.opsForHash().increment(key,item,-by);
    }
    //endregion
    //region set
    /**
     * 根据key，获取set的所有值
     * @param key 键
     * @return
     */
    public  Set<Object> sGet(String key){
        try {
            return redisTemplate.opsForSet().members(key);
        }catch (Exception e){
            e.printStackTrace();
            return  null;
        }
    }

    /**
     * 根据value一个set查询，是否存在
     * @param key 键
     * @param value 值
     * @return
     */
    public boolean sHashKey(String key, Object value){
        try {
            return redisTemplate.opsForSet().isMember(key,value);
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     * @param key 键
     * @param values 值，可以时多个
     * @return
     */
    public  long sSet(String key, Object... values){
        try {
            return  redisTemplate.opsForSet().add(key,values);
        }catch (Exception e){
            e.printStackTrace();
            return  0;
        }
    }
    /**
     * 将数据放入set缓存,并设置时间
     * @param key 键
     * @param time 时间（秒）
     * @param values 值，可以时多个
     * @return
     */
    public  long sSetAndTime(String key,long time, Object... values){
        try {
            long count =  redisTemplate.opsForSet().add(key,values);
            if(time > 0){
                redisTemplate.expire(key,time,TimeUnit.SECONDS);
            }
            return  count;
        }catch (Exception e){
            e.printStackTrace();
            return  0;
        }
    }

    /***
     * 获取Set缓存长度
     * @param key
     * @return
     */
    public  long sGetSetSize(String key){
        try {
            return  redisTemplate.opsForSet().size(key);
        }catch (Exception e){
            e.printStackTrace();
            return  0;
        }
    }

    /**
     * 移除值为value的缓存
     * @param key
     * @param values
     * @return
     */
    public  long setRemove(String key, Object ... values){
        try {
            return  redisTemplate.opsForSet().remove(key,values);
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }
    //endregion
    //region list

    /**
     * 获取list 缓存内容
     * @param key 键
     * @param start 开始位置
     * @param end 结束位置 0 到-1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end){
        try {
            return redisTemplate.opsForList().range(key,start,end);
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存长度
     * @param key 键
     * @return
     */
    public  long lGetListSize(String key){
        try{
            return  redisTemplate.opsForList().size(key);
        }catch (Exception e){
            e.printStackTrace();
            return  0;
        }
    }

    /**
     * 通过索引获取list的值
     * @param key 键
     * @param index 索引（> 0，索引），-1表尾，-2倒数第二个元素，以此类推
     * @return
     */
    public  Object lGetIndex(String key,long index){
        try{
            return redisTemplate.opsForList().index(key,index);
        }catch (Exception e){
            e.printStackTrace();
            return  null;
        }
    }

    /**
     * 将list缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public long lSet(String key, Object value){
        try{
           return redisTemplate.opsForList().rightPush(key,value);
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将list缓存，并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间（秒）
     * @return
     */
    public  long lSet(String key, Object value, long time){
        try{
            long result =  redisTemplate.opsForList().rightPush(key,value);
            if(time > 0){
                redisTemplate.expire(key,time,TimeUnit.SECONDS);
            }
            return result;
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    public long  lSet(String key, List<Object> value){
        try{
            return redisTemplate.opsForList().rightPushAll(key,value);
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间（秒）
     * @return
     */
    public long  lSet(String key, List<Object> value,long time){
        try{
            long result =  redisTemplate.opsForList().rightPushAll(key,value);
            if(time > 0){
                redisTemplate.expire(key,time,TimeUnit.SECONDS);
            }
            return result;
        }catch (Exception e){
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 根据索引修改list的某条数据
     * @param key 键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key,long index, Object value){
        try{
            redisTemplate.opsForList().set(key,index,value);
            return  true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     * @param key 键
     * @param count 移除多少个
     * @param value 值
     * @return
     */
    public long lRemove(String key, long count, String value){
       try {
           return  redisTemplate.opsForList().remove(key,count,value);
       }catch (Exception e){
           e.printStackTrace();
           return  0;
       }
    }
    // endregion
}