Redis中数据类型在客户端应用-不过是从头再来罢了

1.准备

我们来学习如何使用Spring Data Redis来操作Redis的各种数据类型.

在Redis中有五种常见类型,SpringData Redis对每一种数据类型都提供了一个xxxOperations的API,他们分别是:

ValueOperations :用来操作字符串类型数据
HashOperations:用来操作hash类型数据
ListOperations:用来操作list类型数据
SetOperations:用来操作set类型数据
ZSetOperations:用来操作zset类型数据

2.String类型

@SpringBootTest
public class RedisStringTest {
    ObjectMapper objectMapper = new ObjectMapper();
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    public void testString() throws JsonProcessingException {
        //获取ValueOperations对象
        ValueOperations<String, String> operations = stringRedisTemplate.opsForValue();

        //向Redis中保存 aa:bb
        operations.set("aa", "bb");

        //相关Redis保存 aa1-- bb1  有效时间为10s
        operations.set("aa1", "bb1", 10, TimeUnit.SECONDS);

        //替换 bb    --->   cc   offset 索引位置是从0开始
        operations.set("aa", "XX", 1);

        //当key不存在的时候,执行保存操作; 当key存在的时候,什么都不做
        operations.setIfAbsent("aa1", "ddd");

        //批量保存
        Map map = new HashMap();
        map.put("aa2", "aa2");
        map.put("aa3", "aa3");
        map.put("aa4", "aa4");

        operations.multiSet(map);

        //追加 当key存在时,会执行追加操作;当key不存在时,会执行保存操作
        operations.append("aa5", "aa5");

        UserEntity user = new UserEntity();
        user.setUsername("张三");
        user.setAge(22);

        String key = "user:info:1001";
        // 保存
        operations.set(key, objectMapper.writeValueAsString(user), 10, TimeUnit.MINUTES);
    }

    @Test
    public void testGet() {
        ValueOperations<String, String> operations = stringRedisTemplate.opsForValue();

        //根据key获取value
        String value = operations.get("aa");
        System.out.println(value);

        //首先根据key获取value,然后再根据value进行截取,从start位置截取到end位置[包含start和end]
        String value2 = operations.get("aa", 5, 7);
        System.out.println(value2);

        //批量获取
        List<String> keys = new ArrayList<>();
        keys.add("aa2");
        keys.add("aa3");
        keys.add("aa4");
        List<String> values = operations.multiGet(keys);
        for (String s : values) {
            System.out.println(s);
        }

        //根据key获取value的长度
        Long size = operations.size("aa");
        System.out.println(size);
    }

    //自增
    @Test
    public void testIncrement() {
        ValueOperations<String, String> operations = stringRedisTemplate.opsForValue();

        operations.set("age", "18");
        operations.increment("age");//自增1--->19
        System.out.println(operations.get("age"));
        operations.increment("age", 5);//自增5
        System.out.println(operations.get("age"));//---->24

        //自减
        operations.decrement("age");
    }

    //删除
    @Test
    public void testDelete() {
        //单个删除
        stringRedisTemplate.delete("aa");

        List<String> keys = new ArrayList<>();
        keys.add("aa2");
        keys.add("aa3");
        keys.add("aa4");

        //批量删除
        stringRedisTemplate.delete(keys);
    }
}

3.Hash类型

@SpringBootTest(classes = RedisApplication.class)
public class RedisHashTest {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    //保存
    @Test
    public void testPut() {
        HashOperations<String, String, Object> operations = stringRedisTemplate.opsForHash();

        Map<String, Object> map = new HashMap<>();
        map.put("id", String.valueOf(System.currentTimeMillis()));
        map.put("title", "我的奋斗");
        map.put("author", "李四");
        map.put("createTime", String.valueOf(new Date().getTime()));

        operations.putAll("article:1001", map);
    }

    //获取
    @Test
    public void testGet() {
        HashOperations<String, String, String> operations = stringRedisTemplate.opsForHash();

        String key = "article:1001";
        //判断hashkey是否存在
        Boolean idFlag = operations.hasKey(key, "id");
        System.out.println("idFlag=" + idFlag);

        //根据key和hash kay获取操作
        Object id = operations.get(key, "id");
        System.out.println("id=" + id);

        //根据key获取所有的 hash key
        Set<String> set = operations.keys(key);
        for (String s : set) {
            System.out.println("hash key:" + s);
        }

        List<String> values = operations.values(key);
        for (Object art : values) {
            System.out.println("hash value:" + art);
        }

        Map<String, String> entries = operations.entries(key);
        System.out.println("------------x------------");
        for (Map.Entry<String, String> entry : entries.entrySet()) {
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }

    //删除
    @Test
    public void testDelete() {
        HashOperations<String, String, String> operations = stringRedisTemplate.opsForHash();
        String key = "article:1001";
        //当hash中的数据全部被删除后,整个hash就没了
        operations.delete(key, "title", "createTime");
    }
}

4.List类型

@SpringBootTest(classes = RedisApplication.class)
public class RedisListTest {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    //增加
    @Test
    public void testAdd() {
        ListOperations<String, String> operations = stringRedisTemplate.opsForList();
        // 将所有指定的值插入存储在键的列表的头部（或尾部）。
        // 如果键不存在，则在执行推送操作之前将其创建为空列表。
        operations.leftPush("names", "zhangsan");
        operations.leftPushAll("names", "lisi", "wangwu", "zhaoliu");

        operations.rightPush("names", "sunqi");
        operations.rightPushAll("names", "lisi", "wangwu", "zhaoliu");
    }

    //根据索引查询元素
    @Test
    public void testFind() {
        ListOperations<String, String> operations = stringRedisTemplate.opsForList();
        //0代表左边开始第一个元素
        String name1 = operations.index("names", 0);
        System.out.println(name1);

        //-1代表右边开始第一个元素
        String name2 = operations.index("names", -1);
        System.out.println(name2);

        //range代表一个范围(包含开始索引,结束索引)
        List<String> names = operations.range("names", 0, 1);
        for (String name : names) {
            System.out.println(name);
        }
    }

    //移除某个元素的值
    @Test
    public void testRemove() {
        ListOperations<String, String> operations = stringRedisTemplate.opsForList();
        //从坐标或者右边弹出第一个元素
        operations.rightPop("names");

        //弹出指定的元素
        // count > 0：删除左边起第几个等于指定值的元素
        // count < 0：删除右边起第几个等于指定值的元素
        // count = 0：删除所有等于value的元素。
        operations.remove("names", 1, "zhangsan");
    }
}

5.Set类型

@SpringBootTest(classes = RedisApplication.class)
public class RedisSetTest {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    //添加
    @Test
    public void testAdd() {
        SetOperations<String, String> operations = stringRedisTemplate.opsForSet();

        operations.add("names", "zhangsan", "li", "wangwu");
    }

    //查看集合中元素
    @Test
    public void testFind() {
        SetOperations<String, String> operations = stringRedisTemplate.opsForSet();

        //查询集合中的所有元素
        operations.members("names");

        //随机获取集合中的一个元素
        String name = operations.randomMember("names");
        System.out.println(name);

        //随机获取集合中的多个元素
        operations.randomMembers("names", 2).stream().forEach(System.out::println);
    }

    //移除元素
    @Test
    public void testRemove() {
        SetOperations<String, String> operations = stringRedisTemplate.opsForSet();

        //根据指定的key--value进行移除
        operations.remove("names", "zhangsan", "li");

        //根据key随机移除并返回value
        String name = operations.pop("names");
        System.out.println(name);
    }

    //多集合的操作
    @Test
    public void testMoreSet() {
        SetOperations<String, String> operations = stringRedisTemplate.opsForSet();

        operations.add("names1", "zhangsan", "li", "wangwu");
        operations.add("names2", "zhangsan", "li", "zhaoliu");

        //取交集
        operations.intersect("names1", "names2").stream().forEach(System.out::println);

        //取并集
        operations.union("names1", "names2").stream().forEach(System.out::println);

        //取差集
        operations.difference("names1", "names2").stream().forEach(System.out::println);
    }

}

6.ZSet类型

@SpringBootTest
public class RedisZSetTest {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    //添加
    @Test
    public void testAdd() {
        ZSetOperations<String, String> operations = stringRedisTemplate.opsForZSet();

        operations.add("students", "zhangsan", 100);
        operations.add("students", "lisi", 80);
        operations.add("students", "wangwu", 90);
    }

    //增减分数
    @Test
    public void testScore() {
        ZSetOperations<String, String> operations = stringRedisTemplate.opsForZSet();
        //根据key-value来增减分数
        operations.incrementScore("students", "lisi", -50);
    }

    //查询一个元素的信息
    @Test
    public void testFindOne() {
        ZSetOperations<String, String> operations = stringRedisTemplate.opsForZSet();
        //查询个人分数
        Double score = operations.score("students", "lisi");
        System.out.println(score);

        //查询个人排名
        Long rank = operations.rank("students", "lisi");
        System.out.println(rank);
    }

    //列表查询:分为两大类，正序和逆序。以下只列表正序的，逆序的只需在方法前加上reverse即可
    @Test
    public void testFindList() {
        ZSetOperations<String, String> operations = stringRedisTemplate.opsForZSet();
        //通过排名区间获取集合元素
        Set<String> students1 = operations.range("students", 1, 2);
        for (String stu : students1) {
            System.out.println(stu);
        }

        //通过排名区间获取集合元素和分数
        Set<ZSetOperations.TypedTuple<String>> students2 =
                operations.rangeWithScores("students", 1, 2);
        for (ZSetOperations.TypedTuple<String> tuple : students2) {
            String value = tuple.getValue();
            Double score = tuple.getScore();
            System.out.println("value-->" + value + ",score-->" + score);
        }

        //通过分数区间获取集合元素
        Set<String> students3 = operations.rangeByScore("students", 80, 90);
        for (String stu : students3) {
            System.out.println(stu);
        }

        //通过分数区间获取集合元素和分数
        Set<ZSetOperations.TypedTuple<String>> students4 =
                operations.rangeByScoreWithScores("students", 80, 90);
        for (ZSetOperations.TypedTuple<String> tuple : students4) {
            String value = tuple.getValue();
            Double score = tuple.getScore();
            System.out.println("value-->" + value + ",score-->" + score);
        }
    }

    //统计元素
    @Test
    public void testCount() {
        ZSetOperations<String, String> operations = stringRedisTemplate.opsForZSet();
        //统计集合大小
        Long zCard = operations.zCard("students");
        System.out.println(zCard);

        //统计分数区间的元素数量
        Long count = operations.count("students", 85, 95);
        System.out.println(count);
    }

    //移除元素
    @Test
    public void testRemove() {
        ZSetOperations<String, String> operations = stringRedisTemplate.opsForZSet();
        //通过key--value删除
        operations.remove("students", "zhangsan");

        //通过排名区间删除
        operations.removeRange("students", 0, 1);

        //通过分数区间删除
        operations.removeRangeByScore("students", 80, 90);
    }
}

目录CONTENT

Redis中数据类型在客户端应用

1.准备

2.String类型

3.Hash类型

4.List类型

5.Set类型

6.ZSet类型

7.小结

评论区