java-web系列（五）---SpringBoot整合Redis大合集

落日映苍穹つ 2022-05-13 04:58 43阅读 0赞

# 前言 #

这个项目的github地址：[extensible项目的github地址][extensible_github]

extensible项目当前功能模块如下：

[java-web系列（一）—搭建一个基于SSM框架的java-web项目][java-web_SSM_java-web]  
[java-web系列（二）—以dockerfile的方式发布java-web项目][java-web_dockerfile_java-web]  
[java-web系列（三）—(slf4j + logback)进行日志分层][java-web_slf4j _ logback]  
[java-web系列（四）—几种常见的加密算法][java-web]  
[java-web系列（五）—SpringBoot整合Redis][java-web_SpringBoot_Redis]  
[java-web系列（六）—Mybatis动态多数据源配置][java-web_Mybatis]  
[java-web系列（七）—SpringBoot整合Quartz实现多定时任务][java-web_SpringBoot_Quartz]  
[java-web系列（八）—RabbitMQ在java-web中的简单应用][java-web_RabbitMQ_java-web]  
[java-web系列（九）—SpringBoot整合ElasticSearch][java-web_SpringBoot_ElasticSearch]

如对该项目有疑问，可在我的博客/github下面留言，也可以以邮件的方式告知。  
我的联系方式：dzy930724@163.com

## Redis是什么？ ##

Redis是一个基于C语言编写、支持网络交互、可基于内存也可持久化、高性能的Key-Value数据库。Redis支持的数据类型有：字符串（`string`）、链表（`list`）、集合（`set`）、有序集合（`zset`）和哈希表（`hash`）。

我的理解：Redis是非关系型(Nosql)数据库。数据可以放在内存中，进行读写操作时速度非常高（关系型数据库如MySql/Oracle是将数据持久化在磁盘的，相较于Redis而言读写操作速度较慢，当业务的并发量较大时，使用Redis这种类型的数据库来缓解关系型数据库的访问压力是很有必要的）。  
  
对比Memcache，Redis支持的数据类型更多，而且可以将部分数据持久到磁盘上（能够一定程度地避免服务器断电、宕机时数据丢失）。  
  
因此(Spring + Springmvc + Mybatis + Redis)进行java-web开发，是业内最推崇的架构选择。深入学习Redis，是很有必要的。

## Redis的安装 ##

Redis的安装方式和步骤都非常简单。

1.  方式一：可以到Redis的官网[下载redis-X.Y.Z.tar.gz压缩包][redis-X.Y.Z.tar.gz]，然后解压并使用make命令进行安装即可。
2.  方式二：用Docker命令拉取最新的Redis镜像，然后启动容器后就可以使用相关的Redis服务。

# 拉取最新的redis镜像
    docker pull redis
    # 启动提供redis服务的容器（d:后台型容器 name:命名 p:暴露端口）
    docker run -d --name redis-master -p 6379:6379 redis

出现如下图，则说明成功启动Redis容器。

![启动提供Redis服务的容器][Redis]

由于端口映射关系（-p 6379:6379）即将redis-master容器6379端口提供的服务（Redis服务暴露的端口默认就是6379），暴露在服务器的6379端口上。因此**访问服务器的6379端口即可开始使用Redis服务**。在Redis的桌面管理工具(Redis Desktop Manager)测试连接Redis成功如下：

![测试Redis连接][Redis 1]

## Redis的命令 ##

由于项目开发时启动的Redis容器都是后台型的，无法直接实践Redis命令。因此需要另外启动一个链接了Redis服务的Docker容器。

# 启动链接到redis上的服务器(it:交互型容器 link:链接两个容器)
    docker run --rm -it --link redis-master:redis redis /bin/bash
    
    # 用redis-cli工具访问redis(h:主机 p:端口)，这里的端口不指定，它也会默认去访问主机的6379端口
    redis-cli -h redis -p 6379

如下图所示，启动了交互型容器，就可以直接在命令行窗口实践redis命令了：

![redis界面][redis]

常用的Redis命令汇总如下

1.与`key`相关的命令

<table> 
 <thead> 
  <tr> 
   <th align="left">命令格式</th> 
   <th align="left">命令描述</th> 
   <th align="left">命令示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">set key value</td> 
   <td align="left">设置指定key的value</td> 
   <td align="left">set name zhenye</td> 
  </tr> 
  <tr> 
   <td align="left">get key</td> 
   <td align="left">获取指定key的value</td> 
   <td align="left">get name</td> 
  </tr> 
  <tr> 
   <td align="left">getset key value</td> 
   <td align="left">替换指定key的value，并返回旧值</td> 
   <td align="left">getset name zhenye163</td> 
  </tr> 
  <tr> 
   <td align="left">expire key seconds</td> 
   <td align="left">设置指定key的过期时间,单位为秒</td> 
   <td align="left">expire name 5</td> 
  </tr> 
  <tr> 
   <td align="left">ttl key</td> 
   <td align="left">返回指定key的剩余生存时间,单位为秒</td> 
   <td align="left">ttl name</td> 
  </tr> 
  <tr> 
   <td align="left">del key value</td> 
   <td align="left">删除指定key</td> 
   <td align="left">del name</td> 
  </tr> 
 </tbody> 
</table>

与`key`相关的命令测试效果如下：

![key相关命令测试效果][key]

2.与`list`相关的命令

<table> 
 <thead> 
  <tr> 
   <th align="left">命令格式</th> 
   <th align="left">命令描述</th> 
   <th align="left">命令示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">lpush key value</td> 
   <td align="left">顺序插入list中的value</td> 
   <td align="left">lpush database mysql</td> 
  </tr> 
  <tr> 
   <td align="left">lrange key start stop</td> 
   <td align="left">返回list相应位置的value</td> 
   <td align="left">lrange database 0 1</td> 
  </tr> 
  <tr> 
   <td align="left">lindex key index</td> 
   <td align="left">通过索引获取列表中的元素</td> 
   <td align="left">lindex database 1</td> 
  </tr> 
  <tr> 
   <td align="left">lpop key</td> 
   <td align="left">移出列表中的第一个元素</td> 
   <td align="left">lpop database</td> 
  </tr> 
  <tr> 
   <td align="left">llen key</td> 
   <td align="left">获取列表的长度</td> 
   <td align="left">llen database</td> 
  </tr> 
 </tbody> 
</table>

与`list`相关的命令测试效果如下：

![list相关命令测试效果][list]

3.与`set`相关的命令

<table> 
 <thead> 
  <tr> 
   <th align="left">命令格式</th> 
   <th align="left">命令描述</th> 
   <th align="left">命令示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">sadd key member</td> 
   <td align="left">向set中插入一个元素</td> 
   <td align="left">sadd language java</td> 
  </tr> 
  <tr> 
   <td align="left">scard key</td> 
   <td align="left">返回set中元素的个数</td> 
   <td align="left">scard language</td> 
  </tr> 
  <tr> 
   <td align="left">smembers key</td> 
   <td align="left">返回set中所有的元素</td> 
   <td align="left">smembers language</td> 
  </tr> 
  <tr> 
   <td align="left">sismember key value</td> 
   <td align="left">判断set中是否存在某个元素</td> 
   <td align="left">sismember language java</td> 
  </tr> 
  <tr> 
   <td align="left">srem key value1 value2</td> 
   <td align="left">移除set中一个或多个元素</td> 
   <td align="left">srem language java c</td> 
  </tr> 
 </tbody> 
</table>

与`set`相关的命令测试效果如下：

![set相关命令测试效果][set]

4.与`zset`相关的命令

<table> 
 <thead> 
  <tr> 
   <th align="left">命令格式</th> 
   <th align="left">命令描述</th> 
   <th align="left">命令示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">zadd key score1 member1</td> 
   <td align="left">向zset中插入一个元素,score为排序时权重</td> 
   <td align="left">zadd week 1 monday</td> 
  </tr> 
  <tr> 
   <td align="left">zcard key</td> 
   <td align="left">返回zset中元素的个数</td> 
   <td align="left">zcard week</td> 
  </tr> 
  <tr> 
   <td align="left">zrange key start stop</td> 
   <td align="left">返回zset索引区间（插入顺序）内所有的元素</td> 
   <td align="left">zrange week 1 3</td> 
  </tr> 
  <tr> 
   <td align="left">zincrby key increment member</td> 
   <td align="left">给zset指定元素的排序权重加increment</td> 
   <td align="left">zincrby week 5 monday</td> 
  </tr> 
  <tr> 
   <td align="left">zrem key value1 value2</td> 
   <td align="left">移除zset中一个或多个元素</td> 
   <td align="left">zrem week tuesday thursday</td> 
  </tr> 
 </tbody> 
</table>

与`zset`相关的命令测试效果如下：

![zset相关命令测试效果][zset]

5.与`hash`相关的命令

<table> 
 <thead> 
  <tr> 
   <th align="left">命令格式</th> 
   <th align="left">命令描述</th> 
   <th align="left">命令示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">hmset key field1 value1</td> 
   <td align="left">同时往hash表中存储多个键值对</td> 
   <td align="left">hmset person name zhenye age 25</td> 
  </tr> 
  <tr> 
   <td align="left">hexists key field</td> 
   <td align="left">判断hash表中是否存在字段field</td> 
   <td align="left">hexists person name</td> 
  </tr> 
  <tr> 
   <td align="left">hkeys key</td> 
   <td align="left">取出hash表中所有字段</td> 
   <td align="left">hkeys person</td> 
  </tr> 
  <tr> 
   <td align="left">hgetall key</td> 
   <td align="left">获取hash表中的所有信息</td> 
   <td align="left">lpop person</td> 
  </tr> 
  <tr> 
   <td align="left">hdel key field</td> 
   <td align="left">删除hash表中的某些字段</td> 
   <td align="left">hdel person address</td> 
  </tr> 
 </tbody> 
</table>

与`hash`相关的命令测试效果如下：

![hash相关命令测试效果][hash]

这里只是摘取了部分常用的命令，其他的命令及用户可参考[Redis官网的命令汇总][Redis 2]

## SpringBoot项目中简单使用Redis ##

1.首先在项目的pom文件中加入redis依赖

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

2.在配置文件（application-dev.properties）中加入如下配置:

# 配置Redis
    spring.redis.host=192.168.139.141
    spring.redis.database=1
    # 设置debug=true，可以看SpringBoot帮我们做了哪些自动配置
    debug=true

启动项目可以发现，positive matches里面有：

![Redis自动配置][Redis 3]

而真正使用Redis的服务，就是使用`RestTemplate/StringRestTemplate`类提供的方法。这里SpringBoot帮我们进行了Redis的相关配置，因此我们只需要注入这两个类，就可以使用Redis服务了。

3.测试代码

@Service
    @Slf4j
    public class StudentServiceImpl implements StudentService{ 
      @Resource
      private StudentMapper studentMapper;
      @Resource
      private ClassroomMapper classroomMapper;
      @Autowired
      private StringRedisTemplate redisTemplate;
    
      @Transactional(rollbackFor = Exception.class)
      @Override
      public String insertOne(Student student) { 
        log.info("插入一条新的学生数据");
        Integer classroomId = student.getClassroomId();
        Classroom classroom = classroomMapper.findById(classroomId);
        if (classroom == null){ 
          log.error("找不到这个班级");
          throw new RuntimeException("学生信息不全，无法入库");
        }
        Integer studentId = studentMapper.insertOne(student);
        student.setId(studentId);
        redisTemplate.opsForHash().put("student",String.valueOf(studentId),student.toString());
        return "SUCCESS";
      }
    }

这里的做法是：在将student的信息插入MySql后，同时将student的信息（studentId:student）也插入Redis中。

4.在Postman中进行如下测试：

![测试Redis参数即URL][Redis_URL]

返回值为SUCCESS，说明方法走通，也说明student的信息存入了Redis中，用Redis桌面管理工具（Redis-Desktop-Manager）查看如下图，说明成功插入数据。

![Redis测试结果][Redis 4]

5.将常用的Redis操作汇总成工具类

/** * 将常用的Redis操作汇聚成工具类 * @author zhenye 2018/9/7 */
    @Configuration
    @Slf4j
    public class RedisUtil { 
    
        /** * StringRedisTemplate继承RedisTemplate<String, String>，两种的区别仅仅是序列化方式不一样。 * 这里选用StringRedisTemplate，能够避免乱码问题。 */
        @Autowired
        private StringRedisTemplate stringRedisTemplate;
    
        /** * 判断key是否存在 * @param key 键 * @return true 存在 false不存在 */
        public boolean hasKey(String key){ 
            try { 
                return stringRedisTemplate.hasKey(key);
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.hasKey(String key) ---> ",e);
                return false;
            }
        }
    
        /** * 指定key的过期时间为time，单位是秒 * @param key 键 * @param time 时间(秒) * @return */
        public boolean setExpire(String key, long time){ 
            try { 
                if(time > 0){ 
                    stringRedisTemplate.expire(key, time, TimeUnit.SECONDS);
                }
                return true;
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.setExpire(String key, long time) ---> ",e);
                return false;
            }
        }
    
        /** * 根据key 获取过期时间 * @param key 键 不能为null * @return 时间(秒) 返回0代表为永不过期 */
        public long getExpire(String key){ 
            return stringRedisTemplate.getExpire(key,TimeUnit.SECONDS);
        }
    
        /** * 删除key * @param key 可以传一个值 或多个 */
        public void del(String... key){ 
            if(key != null && key.length > 0){ 
                if(key.length == 1){ 
                    stringRedisTemplate.delete(key[0]);
                }else{ 
                    stringRedisTemplate.delete(CollectionUtils.arrayToList(key));
                }
            }
        }
    
        //============================String类型的方法=============================
        //存储格式为： key = value
        /** * 获取指定键的值 * @param key 键 * @return 值 */
        public Object get(String key){ 
            return key == null ? null : stringRedisTemplate.opsForValue().get(key);
        }
    
        /** * 设置指定键的值，如果存在就是更新操作 * @param key 键 * @param value 值 * @return true成功 false失败 */
        public boolean set(String key,String value) { 
            try { 
                stringRedisTemplate.opsForValue().set(key, value);
                return true;
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.set(String key,String value) ---> ",e);
                return false;
            }
    
        }
    
        /** * 设置指定键的值，同时设置过期时间 * @param key 键 * @param value 值 * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期 * @return true成功 false 失败 */
        public boolean set(String key,String value,long time){ 
            try { 
                if(time > 0){ 
                    stringRedisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
                }else{ 
                    set(key, value);
                }
                return true;
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.set(String key,String value,long time) ---> ",e);
                return false;
            }
        }
    
        /** * 改变键的排序权重 * @param key 键 * @param delta 权重数 * @return */
        public long incrBy(String key, long delta){ 
            return stringRedisTemplate.opsForValue().increment(key, delta);
        }
    
        //============================Hash类型的方法=============================
        //存储格式为： key = {field1: value1,field2: value2}
        // Redis中的Hash结构可以类比数据库（key是表名，field是列表）
        /** * HashGet * @param key 键 * @param field 项 * @return 该键某项的值value */
        public Object hget(String key,String field){ 
            return stringRedisTemplate.opsForHash().get(key, field);
        }
    
        /** * 获取该键的所有项值对{field1: value1,field2: value2} * @param key 键 * @return 所有项值对 */
        public Map<Object,Object> hmget(String key){ 
            return stringRedisTemplate.opsForHash().entries(key);
        }
    
        /** * 以键值对的方式把map信息保存在键key中 * @param key 键 * @param map 对应多个键值 * @return true 成功 false 失败 */
        public boolean hmset(String key, Map<String,Object> map){ 
            try { 
                stringRedisTemplate.opsForHash().putAll(key, map);
                return true;
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.hmset(String key, Map<String,Object> map) ---> ",e);
                return false;
            }
        }
    
        /** * 以键值对的方式把map信息保存在键key中，同时设置该键的过期时间 * @param key 键 * @param map 对应多个键值 * @param time 时间(秒) * @return true成功 false失败 */
        public boolean hmset(String key, Map<String,Object> map, long time){ 
            try { 
                stringRedisTemplate.opsForHash().putAll(key, map);
                if(time > 0){ 
                    setExpire(key, time);
                }
                return true;
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.hmset(String key, Map<String,Object> map, long time) ---> ",e);
                return false;
            }
        }
    
        /** * 向一张hash表中放入数据,如果不存在将创建 * @param key 键 * @param field 项 * @param value 值 * @return true 成功 false失败 */
        public boolean hset(String key,String field,String value) { 
            try { 
                stringRedisTemplate.opsForHash().put(key, field, value);
                return true;
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.hset(String key,String field,Object value) ---> ",e);
                return false;
            }
        }
    
        /** * 向一张hash表中放入数据,如果不存在将创建 * @param key 键 * @param field 项 * @param value 值 * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间 * @return true 成功 false失败 */
        public boolean hset(String key,String field,String value,long time) { 
            try { 
                stringRedisTemplate.opsForHash().put(key, field, value);
                if(time>0){ 
                    setExpire(key, time);
                }
                return true;
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.hset(String key,String field,String value,long time) ---> ",e);
                return false;
            }
        }
    
        /** * 删除hash表中的值 * @param key 键 不能为null * @param field 项 不能为null */
        public void hdel(String key, String field){ 
            stringRedisTemplate.opsForHash().delete(key,field);
        }
    
        /** * 判断hash表中是否有该项的值 * @param key 键 不能为null * @param field 项 不能为null * @return true 存在 false不存在 */
        public boolean hHasKey(String key, String field){ 
            return stringRedisTemplate.opsForHash().hasKey(key, field);
        }
    
        /** * hash递增 如果不存在,就会创建一个 并把新增后的值返回 * @param key 键 * @param field 项 * @param by 排序权重改变值 * @return */
        public double hincr(String key, String field, double by){ 
            return stringRedisTemplate.opsForHash().increment(key, field, by);
        }
    
        //============================Set类型的操作=============================
        /** * 根据key获取Set中的所有值 * @param key 键 * @return */
        public Set<String> sGet(String key){ 
            try { 
                return stringRedisTemplate.opsForSet().members(key);
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.sGet(String key) ---> ",e);
                return null;
            }
        }
    
        /** * 根据value从一个set中查询,是否存在 * @param key 键 * @param value 值 * @return true 存在 false不存在 */
        public boolean sHasKey(String key,String value){ 
            try { 
                return stringRedisTemplate.opsForSet().isMember(key, value);
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.sHasKey(String key,String value) ---> ",e);
                return false;
            }
        }
    
        /** * 将数据放入set缓存 * @param key 键 * @param values 值 可以是多个 * @return 成功个数 */
        public long sSet(String key, String...values) { 
            try { 
                return stringRedisTemplate.opsForSet().add(key, values);
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.sSet(String key, String...values) ---> ",e);
                return 0;
            }
        }
    
        /** * 将set数据放入缓存 * @param key 键 * @param time 时间(秒) * @param values 值 可以是多个 * @return 成功个数 */
        public long sSetAndTime(String key,long time,String...values) { 
            try { 
                Long count = stringRedisTemplate.opsForSet().add(key, values);
                if(time>0) { 
                    setExpire(key, time);
                }
                return count;
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.sSetAndTime(String key,long time,String...values) ---> ",e);
                return 0;
            }
        }
    
        /** * 获取set缓存的长度 * @param key 键 * @return */
        public long sGetSetSize(String key){ 
            try { 
                return stringRedisTemplate.opsForSet().size(key);
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.sGetSetSize(String key) ---> ",e);
                return 0;
            }
        }
    
        /** * 移除值为value的 * @param key 键 * @param values 值 可以是多个 * @return 移除的个数 */
        public long setRemove(String key, Object ...values) { 
            try { 
                Long count = stringRedisTemplate.opsForSet().remove(key, values);
                return count;
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.setRemove(String key, Object ...values) ---> ",e);
                return 0;
            }
        }
    
        //============================List类型的操作=============================
        /** * 获取list缓存的内容 * @param key 键 * @param start 开始 * @param end 结束 0 到 -1代表所有值 * @return */
        public List<String> lGet(String key, long start, long end){ 
            try { 
                return stringRedisTemplate.opsForList().range(key, start, end);
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.lGet(String key, long start, long end) ---> ",e);
                return null;
            }
        }
    
        /** * 获取list缓存的长度 * @param key 键 * @return */
        public long lGetListSize(String key){ 
            try { 
                return stringRedisTemplate.opsForList().size(key);
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.lGetListSize(String key) ---> ",e);
                return 0;
            }
        }
    
        /** * 通过索引 获取list中的值 * @param key 键 * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推 * @return */
        public Object lGetIndex(String key,long index){ 
            try { 
                return stringRedisTemplate.opsForList().index(key, index);
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.lGetIndex(String key,long index) ---> ",e);
                return null;
            }
        }
    
        /** * 将list放入缓存 * @param key 键 * @param value 值 * @return */
        public boolean lSet(String key, String value) { 
            try { 
                stringRedisTemplate.opsForList().rightPush(key, value);
                return true;
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.lSet(String key, String value) ---> ",e);
                return false;
            }
        }
    
        /** * 将list放入缓存 * @param key 键 * @param value 值 * @param time 时间(秒) * @return */
        public boolean lSet(String key, String value, long time) { 
            try { 
                stringRedisTemplate.opsForList().rightPush(key, value);
                if (time > 0) { 
                    setExpire(key, time);
                }
                return true;
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.lSet(String key, String value, long time) ---> ",e);
                return false;
            }
        }
    
        /** * 将list放入缓存 * @param key 键 * @param value 值 * @return */
        public boolean lSet(String key, List<String> value) { 
            try { 
                stringRedisTemplate.opsForList().rightPushAll(key, value);
                return true;
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.lSet(String key, List<String> value) ---> ",e);
                return false;
            }
        }
    
        /** * 将list放入缓存 * @param key 键 * @param value 值 * @return */
        public boolean lSet(String key, List<String> value, long time) { 
            try { 
                stringRedisTemplate.opsForList().rightPushAll(key, value);
                if (time > 0) { 
                    setExpire(key, time);
                }
                return true;
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.lSet(String key, List<String> value, long time) ---> ",e);
                return false;
            }
        }
    
        /** * 根据索引修改list中的某条数据 * @param key 键 * @param index 索引 * @param value 值 * @return */
        public boolean lUpdateIndex(String key, long index,String value) { 
            try { 
                stringRedisTemplate.opsForList().set(key, index, value);
                return true;
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.lUpdateIndex(String key, long index,String value) ---> ",e);
                return false;
            }
        }
    
        /** * 移除N个值为value * @param key 键 * @param count 移除多少个 * @param value 值 * @return 移除的个数 */
        public Long lRemove(String key,long count,String value) { 
            try { 
                return stringRedisTemplate.opsForList().remove(key, count, value);
            } catch (Exception e) { 
                log.error("error occurred in RedisUtil.lRemove(String key,long count,String value) ---> ",e);
                return 0L;
            }
        }
    }

6.这些Redis工具方法的单元测试如下

在配置文件(test.properties)中配置好redis的地址后，测试代码即效果图汇总如下：

*  `key`及`String`类型

测试代码如下：

/** * @author zhenye 2018/9/10 */
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class RedisTest { 
    
        private static final Logger log = LoggerFactory.getLogger(RedisTest.class);
    
        @Autowired
        private RedisUtil redisUtil;
    
        /** * 进行Redis的Key以及String类型数据操作的测试如下： */
        @Test
        public void redisKeyTest() throws Exception { 
            log.info("开始进行Redis工具类RedisUtil的Key以及String类型数据操作相关方法的测试如下：");
            String key1 = "person1";
            boolean hasKey = redisUtil.hasKey(key1);
            log.info("检测redis中是否有Key[{}],检测结果为:{}.",key1,hasKey);
            if (hasKey){ 
                String key1Value = (String) redisUtil.get(key1);
                log.info("Key[{}]的值为:",key1Value);
            }
            String value1 = "zhenye1";
            redisUtil.set(key1,value1);
            hasKey = redisUtil.hasKey(key1);
            log.info("设置了Key[{}]的值为:{},此时再判断是否存在Key值结果为:{}",key1,value1,hasKey);
            Long toBeExpiredTime0 = redisUtil.getExpire(key1);
            log.info("不设置Key[{}]的过期时间，即表示永不过期---其过期时间默认值为{}",key1,toBeExpiredTime0);
            Long time1 = 10L;
            redisUtil.setExpire(key1,time1);
            log.info("设置了Key[{}]的过期时间为:{}",key1,time1);
            Long toBeExpiredTime1 = redisUtil.getExpire(key1);
            log.info("此时Key[{}]的剩余过期时间为:{}",key1,toBeExpiredTime1);
            Thread.sleep(5000L);
            Long toBeExpiredTime2 = redisUtil.getExpire(key1);
            log.info("此时Key[{}]的剩余过期时间为:{}",key1,toBeExpiredTime2);
            Thread.sleep(6000L);
            Long toBeExpiredTime3 = redisUtil.getExpire(key1);
            log.info("此时Key[{}]的剩余过期时间为:{},此时该键已经过期",key1,toBeExpiredTime3);
            String key2 = "person2";
            String value2 = "zhenye2";
            String key3 = "person3";
            String value3 = "zhenye3";
            redisUtil.set(key2,value2);
            redisUtil.set(key3,value3);
            log.info("设置Key2[{}]和Key3[{}]后，判断其是否存在:{}",key2,key3,(redisUtil.hasKey(key2) || redisUtil.hasKey(key3)));
            redisUtil.del(key2,key3);
            log.info("删除了Key2[{}]和Key3[{}]后,判断其是否存在:{}",key2,key3,(redisUtil.hasKey(key2) || redisUtil.hasKey(key3)));
        }
    }

测试效果图如下：

![Key及String类型测试效果图][Key_String]

*  `Hash`类型

测试代码如下：

/** * 进行Redis的Hash类型数据操作的测试如下： */
    @Test
    public void redisHashTest(){ 
        log.info("开始进行Redis工具类RedisUtil的Hash类型数据操作相关方法的测试如下：");
        log.info("下面的操作是往表[user]存入相应的信息");
        redisUtil.hset("user","userId1","{userId:1,name:zhenye1,age:25}");
        redisUtil.hset("user","userId2","{userId:2,name:zhenye2,age:26}");
        redisUtil.hset("user","userId3","{userId:3,name:zhenye3,age:27}");
        Map<Object,Object> map = redisUtil.hmget("user");
        log.info("获取表[user]的全表数据如下：{}",map);
        boolean hasField = redisUtil.hHasKey("user","userId3");
        log.info("判断表[user]是否存在Field[user3],其结果为:{}",hasField);
        String userId3Info = (String) redisUtil.hget("user","userId3");
        log.info("获取表[user]中Field[userId3]的值如下：{}",userId3Info);
        redisUtil.hset("user","userId3","{userId:4,name:zhenye4,age:25}");
        userId3Info = (String) redisUtil.hget("user","userId3");
        log.info("测试更改表[user]中Field[userId3]的值成功后，其值如下：{}",userId3Info);
        redisUtil.hdel("user","user3");
        hasField = redisUtil.hHasKey("user","user3");
        log.info("测试表[user]已经删除Field[user3],判断其是否还存在的结果为:{}",hasField);
    }

测试效果图如下：

![Hash类型测试效果图][Hash]

*  `Set`类型

测试代码如下：

/** * 进行Redis的Hash类型数据操作的测试如下： */
    @Test
    public void redisSetTest(){ 
        log.info("开始进行Redis工具类RedisUtil的Set类型数据操作相关方法的测试如下：");
        log.info("下面的操作是往Set[number]中批量插入多条数据");
        redisUtil.sSet("number","1","2","3");
        Set<String> numbers = redisUtil.sGet("number");
        log.info("测试获取Set[number]中的所有数据，其结果为:{}",numbers);
        boolean hasNumber = redisUtil.sHasKey("number","2");
        log.info("测试Set[number]中是否有'2'，结果为:{}",hasNumber);
        Long setSize = redisUtil.sGetSetSize("number");
        log.info("测试获取Set[number]的长度为:{}",setSize);
        redisUtil.setRemove("number","2","3","4");
        numbers = redisUtil.sGet("number");
        log.info("测试批量删除Set[number]中的多条数据后，其数据为:{}",numbers);
    }

测试效果图如下：

![Set类型测试效果图][Set]

*  `List`类型

测试代码如下：

/** * 进行Redis的List类型数据操作的测试如下： */
    @Test
    public void redisListTest() { 
        log.info("开始进行Redis工具类RedisUtil的List类型数据操作相关方法的测试如下：");
        log.info("下面的操作是往List[color]中批量插入多条数据");
        redisUtil.lSet("color", Arrays.asList("red","blue","green","blue","green","blue"));
        String indexValue = (String) redisUtil.lGetIndex("color",2L);
        log.info("测试获取List[color]中指定下标[2L]的值：{}",indexValue);
        Long listSize = redisUtil.lGetListSize("color");
        log.info("测试获取List[color]的长度：{}",listSize);
        List<String> listValue = redisUtil.lGet("color",1L,10L);
        log.info("测试获取List[color]中指定下标范围start[1L]-end[10L]的值：{}",listValue);
        redisUtil.lRemove("color",2L,"blue");
        listValue = redisUtil.lGet("color",1L,10L);
        log.info("测试删除List[color]中2个'blue'后List的值为：{}",listValue);
        listValue = redisUtil.lGet("color",1L,10L);
        log.info("测试删除List[color]中2个'blue'后List的值为：{}",listValue);
    }

测试效果图如下：

![List类型测试效果图][List]

[extensible_github]: https://github.com/zhenye163/extensible
[java-web_SSM_java-web]: https://blog.csdn.net/UtopiaOfArtoria/article/details/82150584
[java-web_dockerfile_java-web]: https://blog.csdn.net/UtopiaOfArtoria/article/details/82150811
[java-web_slf4j _ logback]: https://blog.csdn.net/UtopiaOfArtoria/article/details/82151006
[java-web]: https://blog.csdn.net/UtopiaOfArtoria/article/details/82429467
[java-web_SpringBoot_Redis]: https://blog.csdn.net/UtopiaOfArtoria/article/details/82594054
[java-web_Mybatis]: https://blog.csdn.net/UtopiaOfArtoria/article/details/82787572
[java-web_SpringBoot_Quartz]: https://blog.csdn.net/UtopiaOfArtoria/article/details/82867193
[java-web_RabbitMQ_java-web]: https://blog.csdn.net/UtopiaOfArtoria/article/details/82981979
[java-web_SpringBoot_ElasticSearch]: https://blog.csdn.net/UtopiaOfArtoria/article/details/88403459
[redis-X.Y.Z.tar.gz]: https://redis.io/download
[Redis]: /images/20220513/38809e64792c40ceb6beb6946cfab4c6.png
[Redis 1]: /images/20220513/cb7e34b66f1b4aea8356ff0f4ee1b40e.png
[redis]: /images/20220513/0f21757f1c4648b2a9fc9c76bea71a30.png
[key]: /images/20220513/074990d9dc3b4a16b5cdf6dcc89e6269.png
[list]: /images/20220513/06f30079ca124e8097625b9327ffe818.png
[set]: /images/20220513/e31d48d51a104c6f9238476971c91983.png
[zset]: /images/20220513/2572e1027c904dbb9f8b792c5e85f70e.png
[hash]: /images/20220513/382c234e84e74ee9960be04db581d127.png
[Redis 2]: https://redis.io/commands#
[Redis 3]: /images/20220513/1e6bbebb8d1c400f9ac8354abcd54ff9.png
[Redis_URL]: /images/20220513/bea7b471c96a42cf8341588b998109fb.png
[Redis 4]: /images/20220513/15b4102fc48247ad84d535d5ee07bf0d.png
[Key_String]: /images/20220513/42644c1984854e5abcc8e09d6e0973c1.png
[Hash]: /images/20220513/4b2f4e0e53eb43d1a9ed7d0509901884.png
[Set]: /images/20220513/124ea3fa0e8e4f388e46dd120dc524c3.png
[List]: /images/20220513/49e8e482a1ae497e983cec2650a7ca00.png