Redis 資料結構

結構型別	結構儲存的值	結構的讀寫能力
String	可以是字串、整數或者浮點數	對整個字串或者字串的其中一部分執行操作；物件和浮點數執行自增(increment)或者自減(decrement)
List	一個連結串列，連結串列上的每個節點都包含了一個字串	從連結串列的兩端推入或者彈出元素；根據偏移量對連結串列進行修剪(trim)；讀取單個或者多個元素；根據值來查詢或者移除元素
Set	包含字串的無序收集器(unorderedcollection)，並且被包含的每個字串都是獨一無二的、各不相同	新增、獲取、移除單個元素；檢查一個元素是否存在於某個集合中；計算交集、並集、差集；從集合裡賣弄隨機獲取元素
Hash	包含鍵值對的無序散列表	新增、獲取、移除單個鍵值對；獲取所有鍵值對
Zset	字串成員(member)與浮點數分值(score)之間的有序對映，元素的排列順序由分值的大小決定	新增、獲取、刪除單個元素；根據分值範圍(range)或者成員來獲取元素

RedisTemplate應用

Spring封裝了RedisTemplate物件來進行對Redis的各種操作

public class RedisTemplate<K,V>
extends RedisAccessor
implements RedisOperations<K,V>, BeanClassLoaderAware

RedisTemplate常用方法

    1）Boolean delete(

K key)     ----刪除對應key的資料

    2）Long delete(Collection<K> keys)    ----批量刪除資料

    3）Boolean hasKey(K key)    ----判斷redis庫是否存在該key

    4）Boolean expire(K key,long timeout,TimeUnit unit)    ----設定過期時間

timeout:過期時間

unit:時間單位

    5）Boolean expireAt(K key,Date date)    ----設定到date時間點過期

    6）Long getExpire(K key)    ----獲取過期時間

    7）Set<K> keys(K pattern)    ----獲取符合條件的所有key

pattern：通配條件 （* 號是萬用字元）

eg：keys("*") ——查詢所有的key值

      keys("a*") ——查詢以a開頭的所有key

    8）void rename(K oldKey, K newKey)    ----key值重新命名

    9）ValueOperations<K, V> opsForValue()    ----操作字串，如下

    10）ListOperations<K, V> opsForList()    ----操作list，如下

    11）SetOperations<K, V> opsForSet()    ----操作set，如下

    12）ZSetOperations<K, V> opsForZSet()    ----操作zset，如下

    *） boundValueOps(K key)，boundListOps(K key)……    ----bound與以下五種方法操作類似，bound是對相應key的資料操作，以下是對所有操作

RedisTemplate中定義了對5種資料結構操作

redisTemplate.opsForValue();//操作字串
redisTemplate.opsForHash();//操作hash
redisTemplate.opsForList();//操作list
redisTemplate.opsForSet();//操作set
redisTemplate.opsForZSet();//操作有序set

RedisTemplate對五種資料型別操控

一、Redis的String資料結構 （推薦使用StringRedisTemplate）

注意：如果使用RedisTemplate需要更改序列化方式

public interface ValueOperations<K,V>    -->ValueOperations可以對String資料結構進行操作

1、插入資料  

    1）void set( K  key, V  value) 

key:儲存鍵；  value:儲存值

使用：redisTemplate.opsForValue().set("name","tom"); 

結果：redisTemplate.opsForValue().get("name")  

輸出結果為tom

    2）void set(K key, V value, long timeout, TimeUnit unit)

timeout:過期時間；  unit:時間單位  

使用：redisTemplate.opsForValue().set("name","tom",10, TimeUnit.SECONDS); 

結果：redisTemplate.opsForValue().get("name")由於設定的是10秒失效，十秒之內查詢有結果，十秒之後返回為null

    3）void set(K key, V value, long offset)    ----該方法是用 value 引數覆寫(overwrite)給定 key 所儲存的字串值，從偏移量 offset 開始

offset：value值覆寫偏移量

使用：template.opsForValue().set("key","hello world"); template.opsForValue().set("key","redis", 6); 

 System.out.println("***************"+template.opsForValue().get("key")); 

結果：***************hello redis

    4）Boolean setIfAbsent(K key, V value)   ----該方法不會覆蓋已存在資料

使用：System.out.println(template.opsForValue().setIfAbsent("multi1","multi1"));//false multi1之前已經存在
        System.out.println(template.opsForValue().setIfAbsent("multi111","multi111"));//true multi111之前不存在
結果: false

true

    5）void multiSet(Map<? extends K, ? extends V> m)    ----為多個鍵分別設定它們的值

使用：Map<String,String> maps = new HashMap<String, String>();
          maps.put("multi1","multi1");
          maps.put("multi2","multi2");
          maps.put("multi3","multi3");
          template.opsForValue().multiSet(maps);
          List<String> keys = new ArrayList<String>();
          keys.add("multi1");
          keys.add("multi2");
          keys.add("multi3");
          System.out.println(template.opsForValue().multiGet(keys));
結果：[multi1, multi2, multi3]

    6）Boolean multiSetIfAbsent(Map<? extends K, ? extends V> m)    ----為多個鍵分別設定它們的值，如果存在則返回false，不存在返回true

使用：Map<String,String> maps = new HashMap<String, String>();
          maps.put("multi11","multi11");
          maps.put("multi22","multi22");
          maps.put("multi33","multi33");
          Map<String,String> maps2 = new HashMap<String, String>();
          maps2.put("multi1","multi1");
          maps2.put("multi2","multi2");
          maps2.put("multi3","multi3");
          System.out.println(template.opsForValue().multiSetIfAbsent(maps));
          System.out.println(template.opsForValue().multiSetIfAbsent(maps2));
結果：true
          false

    7）Long increment(K key, long delta)    ----數值增加（支援整數）

使用：template.opsForValue().increment("increlong",1); 

 System.out.println("***************"+template.opsForValue().get("increlong")); 

結果：***************1

    8）Double increment(K key, double delta)     ----數值增加（支援浮點數）

使用：template.opsForValue().increment("increlong",1.2); 

 System.out.println("***************"+template.opsForValue().get("increlong")); 

結果：***************2.2

    9）Integer append(K key, String value)     ----如果key已經存在並且是一個字串，則該命令將該值追加到字串的末尾。如果鍵不存在，則它被建立並設定為空字串，因此APPEND在這種特殊情況下將類似於SET

使用：template.opsForValue().append("appendTest","Hello"); 

 System.out.println(template.opsForValue().get("appendTest")); 

 template.opsForValue().append("appendTest","world"); 

 System.out.println(template.opsForValue().get("appendTest")); 

結果：Hello Helloworld

2、查詢資料

    1）V get(Object key)

使用：template.opsForValue().set("key","hello world"); 

 System.out.println("***************"+template.opsForValue().get("key")); 

結果：***************hello world

    2）V getAndSet(K key, V value)    ----設定鍵的字串值並返回其舊值

value:新的值

使用：template.opsForValue().set("getSetTest","test"); 

 System.out.println(template.opsForValue().getAndSet("getSetTest","test2")); 

結果：test

    3）List<V> multiGet(Collection<K> keys)    ----為多個鍵分別取出它們的值

使用：Map<String,String> maps = new HashMap<String, String>();
          maps.put("multi1","multi1");
          maps.put("multi2","multi2");
          maps.put("multi3","multi3");
          template.opsForValue().multiSet(maps);
          List<String> keys = new ArrayList<String>();
          keys.add("multi1");
          keys.add("multi2");
          keys.add("multi3");
          System.out.println(template.opsForValue().multiGet(keys));
結果：[multi1, multi2, multi3]

    4）String get(K key, long start, long end)    ----擷取key所對應的value字串

使用：appendTest對應的value為Helloworld
        System.out.println("*********"+template.opsForValue().get("appendTest",0,5));
結果：*********Hellow
使用：System.out.println("*********"+template.opsForValue().get("appendTest",0,-1));
結果：*********Helloworld
使用：System.out.println("*********"+template.opsForValue().get("appendTest",-3,-1));
結果：*********rld

    5）Long size(K key)    ----返回key所對應的value值得長度

使用：template.opsForValue().set("key","hello world"); 

 System.out.println("***************"+template.opsForValue().size("key")); 

結果：***************11

    6） Boolean setBit(K key, long offset, boolean value)    ----對 key 所儲存的字串值，設定或清除指定偏移量上的位(bit)，key鍵對應的值value對應的ascii碼,在offset的位置(從左向右數)變為value

使用：template.opsForValue().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
          template.opsForValue().setBit("bitTest",6, true);
          template.opsForValue().setBit("bitTest",7, false);
          System.out.println(template.opsForValue().get("bitTest"));
結果：b

    7）Boolean getBit(K key, long offset)    ----獲取鍵對應值的ascii碼的在offset處位值

使用：System.out.println(template.opsForValue().getBit("bitTest",7)); 

結果：false

二、Redis的List資料結構 

更改RedisTemp序列化方式

Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
template.setKeySerializer(jackson2JsonRedisSerializer);
template.setValueSerializer(jackson2JsonRedisSerializer);
template.setHashKeySerializer(jackson2JsonRedisSerializer);
template.setHashValueSerializer(jackson2JsonRedisSerializer);

public interface ListOperations<K,V>
Redis列表是簡單的字串列表，按照插入順序排序。你可以新增一個元素導列表的頭部（左邊）或者尾部（右邊）
ListOperations專門操作list列表：

1、插入資料

    1） leftPush(K key, V value)    ----將所有指定的值插入儲存在鍵的列表的頭部。如果鍵不存在，則在執行推送操作之前將其建立為空列表。（從左邊插入）

使用：template.opsForList().leftPush("list","java");
        template.opsForList().leftPush("list","python");
        template.opsForList().leftPush("list","c++");
結果:返回的結果為推送操作後的列表的長度
2

    2）Long leftPushAll(K key, V... values)    ----批量把一個數組插入到列表中

使用：String[] stringarrays = new String[]{"1","2","3"}; 

 template.opsForList().leftPushAll("listarray",stringarrays); 

 System.out.println(template.opsForList().range("listarray",0,-1)); 

結果:[3, 2, 1]

    3）Long leftPushAll(K key, Collection<V> values)    ----批量把一個集合插入到列表中

使用：List<Object> strings = new ArrayList<Object>();
        strings.add("1");
        strings.add("2");
        strings.add("3");
       template.opsForList().leftPushAll("listcollection4", strings);
       System.out.println(template.opsForList().range("listcollection4",0,-1));
結果:[3, 2, 1]

    4）Long leftPushIfPresent(K key, V value)    ----只有存在key對應的列表才能將這個value值插入到key所對應的列表中

使用：System.out.println(template.opsForList().leftPushIfPresent("leftPushIfPresent","aa"));
        System.out.println(template.opsForList().leftPushIfPresent("leftPushIfPresent","bb"));
       ==========分割線===========
       System.out.println(template.opsForList().leftPush("leftPushIfPresent","aa"));
       System.out.println(template.opsForList().leftPushIfPresent("leftPushIfPresent","bb"));
結果:
0
==========分割線===========
2

    5）Long leftPush(K key, V pivot, V value)    ----把value值放到key對應列表中pivot值的左面，如果pivot值存在的話

使用：template.opsForList().leftPush("list","java","oc"); 

 System.out.print(template.opsForList().range("list",0,-1)); 

結果：[c++, python, oc, java, c#, c#]

    6）Long rightPush(K key, V value) / rightPushAll(K key, V... values) …… ----右側插入，與left左側插入同理，方法類似

    7）void set(K key, long index, V value)    ----在列表中index的位置設定value值

使用：System.out.println(template.opsForList().range("listRight",0,-1)); 

 template.opsForList().set("listRight",1,"setValue"); 

 System.out.println(template.opsForList().range("listRight",0,-1)); 

結果:[java, python, oc, c++] [java, setValue, oc, c++]

 2、獲取資料

    1）List<V> range(K key, long start, long end)    ----返回儲存在鍵中的列表的指定元素。偏移開始和停止是基於零的索引，其中0是列表的第一個元素（列表的頭部），1是下一個元素

使用：System.out.println(template.opsForList().range("list",0,-1)); 

結果:[c#, c++, python, java, c#, c#]

    2）Long size(K key)    ----返回儲存在鍵中的列表的長度。如果鍵不存在，則將其解釋為空列表，並返回0。當key儲存的值不是列表時返回錯誤

使用：System.out.println(template.opsForList().size("list")); 

結果:6

    3）V index(K key, long index)    ----根據下表獲取列表中的值，下標是從0開始的

使用：System.out.println(template.opsForList().range("listRight",0,-1)); 

 System.out.println(template.opsForList().index("listRight",2)); 

結果:[java, oc, c++] c++

    4）V leftPop(K key)/rightPop(K key)    ----彈出最左邊/最右邊的元素，彈出之後該值在列表中將不復存在

使用：System.out.println(template.opsForList().range("list",0,-1));
          System.out.println(template.opsForList().leftPop("list"));
          System.out.println(template.opsForList().range("list",0,-1));
結果:
          [c++, python, oc, java, c#, c#]
          c++
          [python, oc, java, c#, c#]

    5）V leftPop(K key, long timeout, TimeUnit unit) /rightPop(K key, long timeout, TimeUnit unit)   ----移出並獲取列表的第一個/最後一個元素， 如果列表沒有元素會阻塞列表直到等待超時或發現可彈出元素為止

用法同上

    6）V rightPopAndLeftPush(K sourceKey, K destinationKey)    ----用於移除列表的最後一個元素，並將該元素新增到另一個列表並返回

使用：System.out.println(template.opsForList().range("list",0,-1));
          template.opsForList().rightPopAndLeftPush("list","rightPopAndLeftPush");
          System.out.println(template.opsForList().range("list",0,-1));
          System.out.println(template.opsForList().range("rightPopAndLeftPush",0,-1));
結果:[oc, java,c#]
          [oc, java]
          [c#]

3、其他操作

    1）void trim(K key, long start, long end)    ----修剪現有列表，使其只包含指定的指定範圍的元素，起始和停止都是基於0的索引

使用：System.out.println(template.opsForList().range("list",0,-1)); 

 template.opsForList().trim("list",1,-1);//裁剪第一個元素 System.out.println(template.opsForList().range("list",0,-1)); 

結果:[c#, c++, python, java, c#, c#] 

 [c++, python, java, c#, c#]

    2）Long remove(K key, long count, Object value)    ----從儲存在鍵中的列表中刪除等於值的元素的第一個計數事件

計數引數以下列方式影響操作：
count> 0：刪除等於從頭到尾移動的值的元素。
count <0：刪除等於從尾到頭移動的值的元素。
count = 0：刪除等於value的所有元素。

使用：System.out.println(template.opsForList().range("listRight",0,-1)); 

 template.opsForList().remove("listRight",1,"setValue");//將刪除列表中儲存的列表中第一次次出現的“setValue”。 System.out.println(template.opsForList().range("listRight",0,-1)); 

結果:[java, setValue, oc, c++] [java, oc, c++]

三、Redis的Hash資料機構

    Redis的雜湊可以讓使用者將多個鍵值對儲存到一個Redis鍵裡面。
    public interface HashOperations<H,HK,HV>
    HashOperations提供一系列方法操作hash：

常用方法如下

    1）Long delete(H key, Object... hashKeys)    ----刪除給定的雜湊hashKeys

    2）Boolean hasKey(H key, Object hashKey)    ----確定雜湊hashKey是否存在

    3）HV get(H key, Object hashKey)    ----從鍵中的雜湊獲取給定hashKey的值

    4）List<HV> multiGet(H key, Collection<HK> hashKeys)    ----從雜湊中獲取給定hashKey的值

    5）Long increment(H key, HK hashKey, long delta)    ----通過給定的delta增加雜湊hashKey的值（整型）

    6）Double increment(H key, HK hashKey, double delta)    ----通過給定的delta增加雜湊hashKey的值（浮點數）

    7）Set<HK> keys(H key)    ----獲取key所對應的散列表的key

    8）Long size(H key)    ----獲取key所對應的散列表的大小個數

    9）void putAll(H key, Map<? extends HK, ? extends HV> m)    ----使用m中提供的多個雜湊欄位設定到key對應的散列表中

    10）void put(H key, HK hashKey, HV value)    ----設定雜湊hashKey的值

    11）Boolean putIfAbsent(H key, HK hashKey, HV value)    ----僅當hashKey不存在時才設定雜湊hashKey的值

    12）List<HV> values(H key)    ----獲取整個雜湊儲存的值根據金鑰

    13）Map<HK, HV> entries(H key)    ----獲取整個雜湊儲存根據金鑰

    14）Cursor<Map.Entry<HK, HV>> scan(H key, ScanOptions options)    ----使用Cursor在key的hash中迭代，相當於迭代器

四、Redis的Set資料結構

    Redis的Set是string型別的無序集合。集合成員是唯一的，這就意味著集合中不能出現重複的資料。
    Redis 中 集合是通過雜湊表實現的，所以新增，刪除，查詢的複雜度都是O(1)。
    public interface SetOperations<K,V>
    SetOperations提供了對無序集合的一系列操作：

常用方法如下：

    1）Long add(K key, V... values)    ----無序集合中新增元素，返回添加個數，也可以直接在add裡面新增多個值 如：template.opsForSet().add("setTest","aaa","bbb")

    2）Long remove(K key, Object... values)    ----移除集合中一個或多個成員

    3）V pop(K key)    ----移除並返回集合中的一個隨機元素

    4）Boolean move(K key, V value, K destKey)    ----將 member 元素從 source 集合移動到 destination 集合

    5）Long size(K key)    ----無序集合的大小長度

    6）Boolean isMember(K key, Object o)     ----判斷 member 元素是否是集合 key 的成員

    7）Set<V> intersect(K key, K otherKey)    ----key對應的無序集合與otherKey對應的無序集合求交集

    8）Set<V> intersect(K key, Collection<K> otherKeys)    ----key對應的無序集合與多個otherKey對應的無序集合求交集

    9）Long intersectAndStore(K key, K otherKey, K destKey)    ----key無序集合與otherkey無序集合的交集儲存到destKey無序集合中

    10）Long intersectAndStore(K key, Collection<K> otherKeys, K destKey)    ----key對應的無序集合與多個otherKey對應的無序集合求交集儲存到destKey無序集合中

    11）Set<V> union(K key, K otherKey)     ----key無序集合與otherKey無序集合的並集

    12）Set<V> union(K key, Collection<K> otherKeys)    ----key無序集合與多個otherKey無序集合的並集

    13）Long unionAndStore(K key, K otherKey, K destKey)    ----key無序集合與otherkey無序集合的並集儲存到destKey無序集合中

    14）Long unionAndStore(K key, Collection<K> otherKeys, K destKey)    ----key無序集合與多個otherkey無序集合的並集儲存到destKey無序集合中

    15）Set<V> difference(K key, K otherKey)    ----key無序集合與otherKey無序集合的差集

    16）Set<V> difference(K key, Collection<K> otherKeys)    ----key無序集合與多個otherKey無序集合的差集

    17）Long differenceAndStore(K key, K otherKey, K destKey)    ----key無序集合與otherkey無序集合的差集儲存到destKey無序集合中

相關推薦