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