SpringBoot整合Redis操作对象五种数据结构增删改查+设置存活时间_spring boot的redis生存时间

参考: https://blog.csdn.net/qq_52006948/article/details/121665356
参考: https://blog.csdn.net/weixin_43762091/article/details/107710576

1. 什么是SpringDataRedis

Spring-data-redis是spring大家族的一部分，提供了在srping应用中通过简单的配置访问 redis服务，对reids底层开发包(Jedis, JRedis, and RJC)进行了高度封装，RedisTemplate 提供了redis各种操作

2. 环境配置

1. 添加依赖

		<!--redis 配置-->
		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
1
2
3
4
5

2. application.yml 配置文件

# 端口号如果是6379默认端口,那么不需要添加端口号
spring: 
  redis:
    host: 192.168.153.90
1
2
3
4

3. 测试类引入 RedisTemplate

@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class RedisTemTest {
    @Autowired
    private RedisTemplate redisTemplate;
}
1
2
3
4
5
6

4. 测试类 User对象

package com.tensquare.article.pojo;
import java.io.Serializable;

public class User implements Serializable {
    private String id;
    private String name;
    private String hobby;
    private int age;

    public User(String id, String name, String hobby, int age) {
        this.id = id;
        this.name = name;
        this.hobby = hobby;
        this.age = age;
    }

    public User() {
    }
    ... GET SET 方法...
    ... toString 方法...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3. 五种类型的值CRUD

3.1 String-字符串类型

package com.tensquare.article;

import com.tensquare.article.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.concurrent.TimeUnit;

@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class RedisTemTest {
    @Autowired
    private RedisTemplate redisTemplate;

    /*
     * String类型的数据增删改查
     * */
    @Test
    public void StringDataTest() {
        // 创建User对象 ,要存入String类型的对象,需要实现 Serializable 接口
        User user = new User("1", "Tom", "打棒球", 15);

        // 添加数据
        redisTemplate.opsForValue().set("user", user);

        // 添加数据并设置有效时间为30s, (30, TimeUnit.SECONDS) 分别代表数字,计量单位
        redisTemplate.opsForValue().set("user1", "Rose", 30, TimeUnit.SECONDS);

        //查找数据 根据key获取value
        User value = (User) redisTemplate.opsForValue().get("user");

        //查找数据 长度
        Long size = redisTemplate.opsForValue().size("user1");

        // 删除数据
        redisTemplate.delete("user1");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

3.2 List-链表类型

 /*
     * List 数据类型的CRUD
     * */
    @Test
    public void ListDataTest() {
        User user = new User("1", "Tom", "打棒球", 15);
        User user1 = new User("2", "Jack", "打网球", 17);

        //从左边添加一个元素
        redisTemplate.opsForList().rightPush("user1", user);
        //从左边添加多个元素
        redisTemplate.opsForList().leftPushAll("user2", user, user1);

        //从右边添加一个元素
        redisTemplate.opsForList().rightPush("user3", user1);
        //从右边添加多个元素
        redisTemplate.opsForList().rightPushAll("user4", user, user1);

		// 定时 设置 user2 数据的存活时间为5秒 测试时注释
        redisTemplate.expire("user2", 5, TimeUnit.SECONDS);

        /* 根据key和元素索引进行查询
         *  0和正数代表从左边开始
         *  负数代表从右边开始
         * */
        // 查询 user3 链表中所有的元素
        List user3 = redisTemplate.opsForList().range("user3", 0, -1);
        // 查询 user3 链表中第一个元素
        User data = (User) redisTemplate.opsForList().index("user3", 0);
        System.out.println(data);

        // 修改 user3 链表中第一个的元素为 user1 对象
        redisTemplate.opsForList().set("user3", 0, user);
  	    
  	    // 删除链表左侧第二个 user 对象
        redisTemplate.opsForList().remove("user3", 2, user);
        //删除 user3 链表中左侧的第一个元素
        redisTemplate.opsForList().leftPop("user3");
        //删除 user3 链表中右侧的第一个元素
        redisTemplate.opsForList().rightPop("user3");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

3.3 Set-集合类型

 /*
     * Set 集合类型CURD
     * */
    @Test
    public void SetDataTest() {
        User user = new User("1", "Tom", "打棒球", 15);
        User user1 = new User("2", "Jack", "打网球", 17);
        User user2 = new User("3", "Rose", "打篮球", 18);
        User user3 = new User("4", "Jerry", "踢足球", 19);

        // 添加 key为user_1的user对象
        redisTemplate.opsForSet().add("user_1", user);
        redisTemplate.opsForSet().add("user_1", user1);

		// 定时 设置 user_1 数据的存活时间为5秒 测试时注释
        redisTemplate.expire("user_1", 5, TimeUnit.SECONDS);

        // 查询 user_1 集合中的所有 value
        Set user1_list = redisTemplate.opsForSet().members("user_1");
        // 查询 user_1 集合中是否有 user 对象
        Boolean result = redisTemplate.opsForSet().isMember("user_1", user);

        // 删除 user_1 集合中的 user对象 ,并返回移除成功数量
        Long success_count = redisTemplate.opsForSet().remove("user_1", user);
        // 删除 user_1 集合中的栈顶元素
        Object user_1 = redisTemplate.opsForSet().pop("user_1");

        // 测试 交集 并集 差集的数据
        redisTemplate.opsForSet().add("names1", user, user1, user2);
        redisTemplate.opsForSet().add("names2", user, user1, user3);
        //取交集
        Set<User> intersect = redisTemplate.opsForSet().intersect("names1", "names2");
        for (User u1 : intersect) {
            System.out.println("交集: " + u1);
        }
        //取并集
        Set<User> union = redisTemplate.opsForSet().union("names1", "names2");
        for (User u2 : union) {
            System.out.println("并集: " + u2);
        }
        //取差集[第一个集合中存在，但第二个集合中不存在的元素]
        Set<User> difference = redisTemplate.opsForSet().difference("names1", "names2");
        for (User u3 : difference) {
            System.out.println("差集: " + u3);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

3.4 Hash-散列类型

    /*
     * Hash集合CRUD
     * */
    @Test
    public void HashDataTest() {
        User user = new User("1", "Tom", "打棒球", 15);
        User user1 = new User("2", "Jack", "打网球", 17);

        // 添加 user 到 hash集合
        redisTemplate.opsForHash().put("hash", "1", user);
        redisTemplate.opsForHash().put("hash", "2", user1);

		// 定时 设置 hash 的数据存活时间为5秒 测试时注释
        redisTemplate.expire("hash", 5, TimeUnit.SECONDS);
        
        // 查询 hash中hashKey 为1的值
        User hash = (User) redisTemplate.opsForHash().get("hash", "1");
        // 查询 hash中 所有hashKey 对应的的值
        List<User> userList = redisTemplate.opsForHash().values("hash");
        // 查询 hash中 所有hashKey 对应的键值对
        Map<String, User> hashKeyMap = redisTemplate.opsForHash().entries("hash");
        // 查询 hash中所有的hashKey
        Set hashKeyList = redisTemplate.opsForHash().keys("hash");
        // 查询 hash 中 是否有 hashKey 为1
        Boolean result = redisTemplate.opsForHash().hasKey("hash", "1");

        // 删除hash 中 HashKey为的1 的值(如需要删除多个,只需要用 "," 隔开
        Long removeSize = redisTemplate.opsForHash().delete("hash", "1");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

3.5 Zset-有序集合类型

/*
     * zSet集合CRUD
     * */
    @Test
    public void zSetDataTest() {
        // 添加值
        redisTemplate.opsForZSet().add("student", "wangwu", 60);
        redisTemplate.opsForZSet().add("student", "lishi", 100);
        redisTemplate.opsForZSet().add("student", "zhangshan", 90);

		// 定时 设置 student 的数据存活时间为5秒 测试时注释
        redisTemplate.expire("student", 5, TimeUnit.SECONDS);

        // 增加分数
        redisTemplate.opsForZSet().incrementScore("student", "wangwu", 30);
        // 减少分数
        redisTemplate.opsForZSet().incrementScore("student", "wangwu", -50);

        //查询 student 下 wangwu 的分数
        Double score = redisTemplate.opsForZSet().score("student", "wangwu");
        //查询 一个元素在集合中的排名  排名从0开始
        Long rank = redisTemplate.opsForZSet().rank("student", "zhangshan");
        // 查询前三个元素
        Set<String> students = redisTemplate.opsForZSet().range("student", 0, 2);
        // 查询  前三个元素的键值对
        Set<ZSetOperations.TypedTuple<String>> student = redisTemplate.opsForZSet().rangeWithScores("student", 0, 2);
        // 查询 根据值的区间查询 key
        Set<String> students1 = redisTemplate.opsForZSet().rangeByScore("student", 50, 100);
        // 查询 根据值区间查询 Set集合
        Set<ZSetOperations.TypedTuple<String>> student1 = redisTemplate.opsForZSet().rangeByScoreWithScores("student", 50, 100);
        //查询 student 中有几个 key
        Long result = redisTemplate.opsForZSet().zCard("student");

        //根据key-value删除 value允许传入多个
        redisTemplate.opsForZSet().remove("student","zhangsan","lisi");
        //根据排名区间删除
        redisTemplate.opsForZSet().removeRange("student",0,1);
        //根据分数区间删除
        redisTemplate.opsForZSet().removeRangeByScore("student",70,90);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40