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

最新推荐文章于 2024-06-14 23:41:47 发布
最新推荐文章于 2024-06-14 23:41:47 发布
阅读量2.5k 收藏 10
点赞数 3
分类专栏： 基于SSM实现的java-web项目 SpringBoot Redis 文章标签： SSM java-web redis SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/UtopiaOfArtoria/article/details/82594054
版权

前言

这个项目的github地址：extensible项目的github地址

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

java-web系列（一）—搭建一个基于SSM框架的java-web项目
java-web系列（二）—以dockerfile的方式发布java-web项目
java-web系列（三）—(slf4j + logback)进行日志分层
java-web系列（四）—几种常见的加密算法
java-web系列（五）—SpringBoot整合Redis
java-web系列（六）—Mybatis动态多数据源配置
java-web系列（七）—SpringBoot整合Quartz实现多定时任务
java-web系列（八）—RabbitMQ在java-web中的简单应用
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压缩包，然后解压并使用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服务的容器

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

测试Redis连接

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命令汇总如下

1.与key相关的命令

命令格式命令描述命令示例
set key value设置指定key的valueset name zhenye
get key获取指定key的valueget name
getset key value替换指定key的value，并返回旧值getset name zhenye163
expire key seconds设置指定key的过期时间,单位为秒expire name 5
ttl key返回指定key的剩余生存时间,单位为秒ttl name
del key value删除指定keydel name

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

key相关命令测试效果

2.与list相关的命令

命令格式命令描述命令示例
lpush key value顺序插入list中的valuelpush database mysql
lrange key start stop返回list相应位置的valuelrange database 0 1
lindex key index通过索引获取列表中的元素lindex database 1
lpop key移出列表中的第一个元素lpop database
llen key获取列表的长度llen database

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

list相关命令测试效果

3.与set相关的命令

命令格式命令描述命令示例
sadd key member向set中插入一个元素sadd language java
scard key返回set中元素的个数scard language
smembers key返回set中所有的元素smembers language
sismember key value判断set中是否存在某个元素sismember language java
srem key value1 value2移除set中一个或多个元素srem language java c

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

set相关命令测试效果

4.与zset相关的命令

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

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

zset相关命令测试效果

5.与hash相关的命令

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

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

hash相关命令测试效果

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

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的服务，就是使用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

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

Redis测试结果

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类型测试效果图

  • 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类型测试效果图

  • 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类型测试效果图

  • 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类型测试效果图

_artoria_
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java系列之SpringBoot整合redis
m0_61027348的博客
11-24 651
srpingboot整合redis,包括自定义配置，序列化解决和工具类封装、测试
springboot-整合redis
azto的博客
02-13 70
需要的依赖
java（SpringBoot）中操作Redis的两种方式
从零开始的博客
06-25 2156
之前我们介绍过了redis的五中基本类型以及在可视化界面进行操作，那么在开发中（在代码中）我们通常使用，jedis进行操作redis,要是springboot 项目，我们通常使用redisTemplte进行操作首先将redis启动。
redis整合SpringBoot实现数据缓存
Young_深情不及里子的博客
09-08 3635
redis进阶！redis在springboot项目中作为缓存的具体实现与使用，深刻认识redis'的其他作用。
如何使用Spring Boot框架整合Redis：超详细案例教程
最新发布
光就是羁绊之力，它会再度被某人继承，散发出耀眼的光。
06-14 4812
成功在 Spring Boot 项目中整合了 Redis 并配置了连接池。我们使用连接池可以显著提高 Redis 操作的性能和资源管理效率。启动应用程序后，可以选中通过 Postman 或浏览器访问以下 URL，验证 Redis 操作是否成功。保持 Redis 操作类和控制器不变。它们已经实现了基本的 Redis 操作。是用于 Lettuce 连接池配置的依赖。目录下，添加 Redis 连接池的配置。确保你的项目包含了以下依赖。，这里就无需再次添加。类以支持连接池即可。
【SpringBoot高级篇】SpringBoot集成redis缓存
输入技术、输出想法
05-03 4045
SpringBoot整合redis1. Redis概述1.1 什么是Redis1.2 redis的应用场景2. Redis安装2.1 在线安装2.2 安装包安装2.2.1 在Ubuntu上安装GCC2.2.2 tar安装docker安装拉取镜像启动镜像3. 命令操作3.1 redis的数据结构：3.1.1 字符串类型 String3.1.2 哈希类型 hash3.1.3 列表类型 list3.1.4 集合类型 set3.1.5 有序集合类型 sortedset3.1.6 通用命令4. 持久化5. Java客
Spring Boot 集成Redis
m0_54239478的博客
09-22 867
java要通过程序访问redis服务器。需要一个中间件或驱动包，初代使用的就是jedis，Jedis Client是Redis官网推荐的一个面向java客户端，库文件实现了对各类API进行封装调用，随着出现一些问题，如线程池不安全等，就出现了lettuce，是一个Redis的java驱动包，是对jedis的优化，之后出现了redisTemplate，使用spring整合了redis，redisTemplate底层包含了lettuce。
Redis的基本使用和SpringBoot集成Redis
y516369的博客
09-18 3505
Redis的基本使用和SpringBoot集成Redis
springBoot-mybatis-redis 整合解决乱码问题.rar
08-19
在IT行业中，Spring Boot、MyBatis和Redis的整合是一个常见的任务，特别是在构建高效、可扩展的Web应用程序时。这个压缩包"springBoot-mybatis-redis 整合解决乱码问题.rar"似乎提供了一个示例工程，展示了如何解决...
springboot-shiro-redis
02-04
标题“springboot-shiro-redis”表明我们正在讨论一个基于Spring Boot的应用程序，该应用程序集成了Apache Shiro安全框架，并利用Redis作为缓存层。这是一个常见的架构选择，因为Spring Boot简化了开发流程，Shiro...
springboot-redis分布式锁
08-03
【SpringBoot整合Redis实现分布式锁】 在分布式系统中，锁是控制并发操作的重要工具，而SpringBoot结合Redis可以轻松地实现高效、可靠的分布式锁。SpringBoot以其轻量级和便捷的特性，使得开发者能快速搭建应用，而...
springboot-nginx-redis-session共享、TCPUDP负载均衡.zip
06-09
本资料包“springboot-nginx-redis-session共享、TCPUDP负载均衡.zip”提供了一套完整的解决方案，涉及到Spring Boot、Nginx、Redis以及TCP/UDP负载均衡的整合。下面将详细解释这些技术及其在实际应用中的作用。 ...
Springboot 2.X中Spring-cache与redis整合
04-02
**Spring Boot 2.X 中 Spring Cache 与 Redis 整合详解** 在现代的 Web 应用开发中，缓存机制是提升系统性能的关键技术之一。Spring Cache 是 Spring 框架提供的一种统一的缓存抽象，它允许开发者通过简单的注解来...
springBoot整合redis以及事务的处理
Sanlianerluxiaoyu的博客
05-05 978
Jedis Jedis是一个java的模块，用来连接和操作我们的Redis数据库。类似于以前我们用我们的jdbc操作我们的mysql数据库。 在使用Jedis 连接redis之前，需要修改redis.conf的配置文件： redis.conf中注释掉bind 127.0.0.1（127.0.0.1表示只支持localhost连接，不支持远程连接） protected-mode no（关闭protected-mode模式，此时外部网络可以直接访问；开启protected-mode保护模式，需配置bin
微服务Spring Boot 整合Redis 阻塞队列实现异步秒杀下单
wanghuichen的博客
10-31 9452
Redis 秒杀下单如何进行性能优化，通过 阻塞队列实现Redis异步秒杀下单优化！
Java及SpringBoot对redis的使用
qq_50896786的博客
08-02 969
springboot对redis的操作封装了两个StringRedisTemplate和RedisTemplate类，StringRedisTemplate是RedisTemplate的子类，StringRedisTemplate它只能存储字符串类型，无法存储对象类型。还有就是放行对应的端口：6001、6002、6003、6004、6005、6006，因为之前放行的实在10000端口，注意以上两点，才可以使用idea创建成功。该类把对每种数据类型的操作，单独封了相应的内部类。(1) 引入相关的依赖。...
【Java】SpringBoot快速整合Redis
m0_64210833的博客
01-18 1780
SpringBoot快速整合Redis， 测试从数据查询和从redis缓存中查询的效率差别。
Spring Boot 整合 Redis 超详细教程
weixin_44966143的博客
02-28 4163
Redis 是一种高性能的键值存储数据库，而 Spring Boot 是一个简化了开发过程的 Java 框架。将两者结合，可以轻松地在 Spring Boot 项目中使用 Redis 来实现数据缓存、会话管理和分布式锁等功能。话不多说直接干货！！！
Springboot Redis使用pipeline进行批量插入数据优化
进步让人兴奋
08-24 3726
一、前言 之前做一个业务，需要把缓存数据存到redis中，一开始使用了for循环，检测后发现数据量一大，就会很慢，1w条数据就需要快2分钟。 原始的代码如下： LOG.info("开始写入新增数据缓存"); for (int i = 0; i < addCompList.size(); i++) { AddDataCacheVo addDataCacheVo = new AddDataCacheVo(); CompanyImportVo companyImportVo = addCom
springboot整合mybatis-plus redis
09-02
Spring Boot整合MyBatis-Plus和Redis可以通过以下步骤实现： 1. 添加依赖：在pom.xml文件中添加Spring Boot、MyBatis-Plus和Redis的依赖。 ```xml <!-- Spring Boot --> <groupId>org.springframework.boot ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值