RedisTemplate操作Redis

RedisTemplate

Redis 可以存储键与5种不同数据结构类型之间的映射，这5种数据结构类型分别为String（字符串）、List（列表）、Set（集合）、Hash（散列）和 Zset（有序集合）。

String：可以是字符串、整数或者浮点数

List：一个链表，链表上的每个节点都包含了一个字符串

Set：包含字符串的无序收集器(unorderedcollection)，并且被包含的每个字符串都是独一无二的、各不相同

Hash：包含键值对的无序散列表

Zset：字符串成员(member)与浮点数分值(score)之间的有序映射，元素的排列顺序由分值的大小决定

RedisTemplate中定义了对5种数据结构操作

redisTemplate.opsForValue();//操作字符串

redisTemplate.opsForHash();//操作hash

redisTemplate.opsForList();//操作list

redisTemplate.opsForSet();//操作set

redisTemplate.opsForZSet();//操作有序set

StringRedisTemplate与RedisTemplate

两者的关系是StringRedisTemplate继承RedisTemplate。

RedisTemplate 的 String 数据结构

        valueOperations.set("name", "tom");
        System.out.println(valueOperations.get("name"));
        delete("name");

        // 设置的是10秒失效，十秒之内查询有结果，十秒之后返回为 null
        valueOperations.set("name", "tom", 10, TimeUnit.SECONDS);
        System.out.println(valueOperations.get("name"));
        delete("name");

        // 第三个参数是 offset，偏移量
        valueOperations.set("key", "hello world");
        valueOperations.set("key", "redis", 6);
        // 输出 hello redis
        System.out.println(valueOperations.get("key"));
        delete("key");

        // 该方法的特点是如果redis中已有该数据,不保存返回false,不存在该数据，保存返回true
        Boolean aBoolean = valueOperations.setIfAbsent("setIfAbsent", "setIfAbsent");
        System.out.println(aBoolean);
        Boolean bBoolean = valueOperations.setIfAbsent("setIfAbsent", "setIfAbsent");
        System.out.println(bBoolean);
        delete("setIfAbsent");

        // 批量 set get
        Map<String, String> maps = new HashMap<>(4);
        maps.put("multi1", "multi1");
        maps.put("multi2", "multi2");
        maps.put("multi3", "multi3");
        valueOperations.multiSet(maps);
        List<String> keys = new ArrayList<>();
        keys.add("multi1");
        keys.add("multi2");
        keys.add("multi3");
        List<String> multiSetList = valueOperations.multiGet(keys);
        System.out.println(multiSetList);
        delete("multi1");
        delete("multi2");
        delete("multi3");

        // 计数器 支持整数和浮点数
        valueOperations.increment("increment", 1);
        valueOperations.increment("increment", 1.2);
        System.out.println(valueOperations.get("increment"));
        delete("increment");

        // 如果key已经存在并且是一个字符串，则该命令将该值追加到字符串的末尾。
        // 如果键不存在，则它被创建并设置为空字符串，因此APPEND在这种特殊情况下将类似于SET。
        valueOperations.append("append", "hello");
        valueOperations.append("append", " world");
        System.out.println(valueOperations.get("append"));
        delete("append");

        // 截取key所对应的value字符串
        valueOperations.set("hello", "hello world");
        // hello
        System.out.println(valueOperations.get("hello", 0, 4));
        // 也支持这种负数形式，不好用
        System.out.println(valueOperations.get("hello", -3, -1));

        // 返回key所对应的value值得长度
        System.out.println(valueOperations.size("hello"));
        delete("hello");

        // 对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit)
        // key键对应的值 value 对应的 ascii 码,在 offset 的位置(从左向右数)变为 value
        valueOperations.set("bitTest", "a");
        // 'a' 的ASCII码是 97。转换为二进制是：01100001
        // 'b' 的ASCII码是 98  转换为二进制是：01100010
        // 'c' 的ASCII码是 99  转换为二进制是：01100011
        // 因为二进制 0 和 1，在 setbit 中 true 为 1，false 为 0，因此我要变为 'b' 的话第六位设置为 1，第七位设置为 0
        valueOperations.setBit("bitTest", 6, true);
        valueOperations.setBit("bitTest", 7, false);
        // 输出 b
        System.out.println(valueOperations.get("bitTest"));

        // 获取键对应值的ascii码的在offset处位值
        System.out.println(valueOperations.getBit("bitTest", 7));
        delete("bitTest");

RedisTemplate 的 List 数据结构

        // 将所有指定的值插入存储在键的列表的头部。如果键不存在，则在执行推送操作之前将其创建为空列表。（从左边插入）
        listOperations.leftPush("list", "1");
        listOperations.leftPush("list", "2");
        listOperations.leftPush("list", "3");
        listOperations.leftPush("list", "4");
        // 只有存在key对应的列表才能将这个value值插入到key所对应的列表中
        listOperations.leftPushIfPresent("list", "4");
        // 在列表中index的位置设置value值
        listOperations.set("list", 3, "100");
        // 从存储在键中的列表中删除等于值的元素的第一个计数事件。将删除列表中存储的列表中第一次次出现的 "100"。
        // count> 0：删除等于从头到尾移动的值的元素。
        // count <0：删除等于从尾到头移动的值的元素。
        // count = 0：删除等于value的所有元素。
        listOperations.remove("list", 1, "100");

        // 批量把一个数组插入到列表中
        String[] stringarrays = new String[]{"1", "2", "3"};
        listOperations.leftPushAll("list2", stringarrays);
        delete("list2");

        // 批量把一个 list 插入到列表中 List<Object> 类型才可以
        List<Object> list3 = new ArrayList<>();
        list3.add("1");
        list3.add("2");
        list3.add("3");
        list3.add("4");
        listOperations.leftPushAll("list3", list3);
        delete("list3");

        // 返回存储在键中的列表的指定元素。偏移开始和停止是基于零的索引，其中0是列表的第一个元素（列表的头部），1是下一个元素
        System.out.println(listOperations.range("list", 0, 2));

        // 修剪现有列表，使其只包含指定的指定范围的元素，起始和停止都是基于0的索引
        listOperations.trim("list", 0, 2);
        System.out.println(listOperations.range("list", 0, -1));

        // 返回存储在键中的列表的长度。如果键不存在，则将其解释为空列表，并返回0。当key存储的值不是列表时返回错误。
        System.out.println(listOperations.size("list"));

        // 根据下标获取列表中的值，下标是从 0 开始的
        System.out.println(listOperations.index("list", 0));

        // 弹出最左边的元素，弹出之后该值在列表中将不复存在
        System.out.println(listOperations.leftPop("list"));

        // 移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
        System.out.println(listOperations.leftPop("list", 1000, TimeUnit.MICROSECONDS));

        // 用于移除列表的最后一个元素，并将该元素添加到另一个列表并返回。
        listOperations.rightPopAndLeftPush("list", "newList");
        System.out.println(listOperations.range("list", 0, -1));
        System.out.println(listOperations.range("newList", 0, -1));
        delete("list");
        delete("newList");

RedisTemplate 的 Hash 数据结构

        Map<String, Object> testMap = new HashMap(4);
        testMap.put("name", "jack");
        testMap.put("age", "27");
        testMap.put("class", "1");
        hashOperations.putAll("hash", testMap);
        System.out.println(hashOperations.entries("hash"));

        // 删除给定的哈希hashKeys
        hashOperations.delete("hash", "class");
        System.out.println(hashOperations.entries("hash"));

        // 确定哈希 hashKey 是否存在
        System.out.println(hashOperations.hasKey("hash", "name"));

        // 从键中的哈希获取给定 hashKey 的值
        System.out.println(hashOperations.get("hash", "name"));

        // 从哈希中获取给定 hashKey 的值
        List<String> kes = new ArrayList<>();
        kes.add("name");
        kes.add("age");
        System.out.println(hashOperations.multiGet("hash", kes));

        // 通过给定的delta增加散列hashKey的值 支持整形、浮点型
        hashOperations.increment("hash", "age", 1);
        System.out.println(hashOperations.get("hash", "age"));

        // 获取key所对应的散列表的key
        System.out.println(hashOperations.keys("hash"));

        // size
        System.out.println(hashOperations.size("hash"));

        // 仅当 hashKey 不存在时才设置散列 hashKey 的值。
        Boolean hashIfAbsent = hashOperations.putIfAbsent("hash", "age", "25");

        // 获取整个哈希存储的值
        System.out.println(hashOperations.values("hash"));

        // 获取整个哈希存储
        System.out.println(hashOperations.entries("hash"));

        // 使用Cursor在key的hash中迭代，相当于迭代器。
        Cursor<Map.Entry<String, Object>> hash = hashOperations.scan("hash", ScanOptions.NONE);

        delete("hash");

RedisTemplate 的 Set 数据结构

        // 添加
        String[] strarrays = new String[]{"strarr1", "strarr2"};
        setOperations.add("set", strarrays);
        setOperations.add("set", "strarr3");
        setOperations.add("set", "strarr3", "strarr4");

        // 移除集合中一个或多个成员
        setOperations.remove("set", "strarr4");

        // 移除并返回集合中的一个随机元素
        setOperations.pop("set");
        setOperations.pop("set", 1);

        // 将 member 元素从 source 集合移动到 new 集合
        setOperations.move("set", "strarr2", "newSet");

        // size
        System.out.println(setOperations.size("set"));

        // 判断 member 元素是否是集合 key 的成员
        Boolean ismember = setOperations.isMember("set", "strarr1");

        // key 对应的无序集合与 otherKey 对应的无序集合求交集（可以与多个 otherKey 求交集）
        Set<Object> intersect = setOperations.intersect("set", "newSet");

        // key 无序集合与 otherkey 无序集合的交集存储到 destKey 无序集合中（可以与多个 otherKey 求交集）
        setOperations.intersectAndStore("set", "newSet", "newSet2");

        // key 无序集合与 otherKey 无序集合的并集（可以与多个 otherKey 求交集）
        Set<Object> union = setOperations.union("set", "newSet");

        // key 无序集合与 otherkey 无序集合的并集存储到 destKey 无序集合中（可以与多个 otherKey 求并集）
        setOperations.unionAndStore("set", "newSet", "newSet3");

        // key 无序集合与 otherKey 无序集合的差集（可以与多个 otherKey 求差集）
        Set<Object> difference = setOperations.difference("set", "newSet");

        // key无序集合与 otherkey 无序集合的差集存储到 destKey 无序集合中（可以与多个 otherKey 求差集）
        setOperations.differenceAndStore("set", "newSet", "newSet4");

        // 返回集合中的所有成员
        Set<Object> set = setOperations.members("set");

        // 随机获取 key 无序集合中的一个元素
        Object randomMember = setOperations.randomMember("set");

        // 获取多个 key 无序集合中的元素（去重），count 表示个数
        Set<Object> distinctRandomMembers = setOperations.distinctRandomMembers("set", 1);

        // 获取多个 key 无序集合中的元素，count 表示个数
        List<Object> randomMembers = setOperations.randomMembers("set", 2);

        delete("set");
        delete("newSet");
        delete("newSet2");
        delete("newSet3");
        delete("newSet4");

RedisTemplate 的 Zset 数据结构

        // 新增一个有序集合，存在的话为false，不存在的话为true
        zSetOperations.add("zset", "strarr1", 1.0);

        // 新增一个有序集合
        ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<>("strarr2", 9.6);
        ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<>("strarr3", 9.9);
        Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<>();
        tuples.add(objectTypedTuple1);
        tuples.add(objectTypedTuple2);
        zSetOperations.add("zset", tuples);
        System.out.println(zSetOperations.range("zset", 0, -1));

        // 从有序集合中移除一个或者多个元素
        zSetOperations.remove("zset", "strarr3");

        // 增加元素的 score 值，并返回增加后的值
        zSetOperations.incrementScore("zset", "strarr1", 1.0);

        // 返回有序集中指定成员的排名，其中有序集成员按分数值递减(从大到小)顺序排列
        System.out.println(zSetOperations.removeRange("zset", 0, -1));

        // 通过索引区间返回有序集合成指定区间内的成员对象，其中有序集成员按分数值递增(从小到大)顺序排列
        Set<ZSetOperations.TypedTuple<Object>> zset = zSetOperations.rangeWithScores("zset", 0, -1);

        // 通过分数返回有序集合指定区间内的成员对象，其中有序集成员按分数值递增(从小到大)顺序排列
        Set<ZSetOperations.TypedTuple<Object>> zset1 = zSetOperations.rangeByScoreWithScores("zset", 0, -1);

        // 通过分数返回有序集合指定区间内的成员个数
        System.out.println(zSetOperations.count("zset", 0, -1));

        // size
        System.out.println(zSetOperations.size("zset"));

        // 获取指定成员的 score 值
        System.out.println(zSetOperations.score("zset", "strarr1"));

        // 计算给定的一个有序集的并集，并存储在新的 destKey 中，key 相同的话会把 score 值相加 （可以与多个 otherKey 求并集）
        //zSetOperations.unionAndStore("zset", "zset2", "zsetNew");
        //zSetOperations.unionAndStore("zset", "zsetList", "zsetNew");

        // 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中 （可以与多个 otherKey 求交集）
        //zSetOperations.intersectAndStore("zset", "zset2", "zsetNew");

        // 遍历 zset
        Cursor<ZSetOperations.TypedTuple<Object>> zset2 = zSetOperations.scan("zset", ScanOptions.NONE);

        delete("zset");

本文由个人 hexo 博客 co2fe.com 迁移

date: 2018-10-29 14:00:41