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