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