RedisTemplate操做Redis

时间 2019-11-16

标签 redistemplate redis 栏目 Redis 繁體版

原文原文链接

RedisTemplate

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

String：能够是字符串、整数或者浮点数redis

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

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

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

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

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

redisTemplate.opsForValue();//操做字符串dom

redisTemplate.opsForHash();//操做hashcode

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