RedisTemplate常用操作方法總結(set、hash、list、string等)

更新時間：2022年05月05日 11:07:04 作者：..Silence..

本文主要介紹了RedisTemplate常用操作方法總結，主要包括了6種常用方法，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧

String類型

保存和讀取String(最常用的)

System.out.println("緩存正在設置。。。。。。。。。");  
redisTemplate.opsForValue().set("key1","value1");  
redisTemplate.opsForValue().set("key2","value2");  
redisTemplate.opsForValue().set("key3","value3");  
redisTemplate.opsForValue().set("key4","value4");  
System.out.println("緩存已經(jīng)設置完畢。。。。。。。");  
String result1=redisTemplate.opsForValue().get("key1").toString();  
String result2=redisTemplate.opsForValue().get("key2").toString();  
String result3=redisTemplate.opsForValue().get("key3").toString();  
System.out.println("緩存結果為：result："+result1+"  "+result2+"   "+result3);

判斷是否有key所對應的值，有則返回true，沒有則返回false

redisTemplate.hasKey(key)

有則取出key值所對應的值

redisTemplate.opsForValue().get(key)

刪除單個key值

redisTemplate.delete(key)

批量刪除key

redisTemplate.delete(keys) //其中keys:Collection<K> keys

將當前傳入的key值序列化為byte[]類型

redisTemplate.dump(key)

設置過期時間

public Boolean expire(String key, long timeout, TimeUnit unit) {
    return redisTemplate.expire(key, timeout, unit);
 }
 public Boolean expireAt(String key, Date date) {
    return redisTemplate.expireAt(key, date);
  }

查找匹配的key值，返回一個Set集合類型

public Set<String> getPatternKey(String pattern) {
    return redisTemplate.keys(pattern);
}

修改redis中key的名稱

 public void renameKey(String oldKey, String newKey) {
    redisTemplate.rename(oldKey, newKey);
}

返回傳入key所存儲的值的類型

public DataType getKeyType(String key) {
    return redisTemplate.type(key);
}

如果舊值存在時，將舊值改為新值

public Boolean renameOldKeyIfAbsent(String oldKey, String newKey) {
    return redisTemplate.renameIfAbsent(oldKey, newKey);
}

從redis中隨機取出一個key

redisTemplate.randomKey()

返回當前key所對應的剩余過期時間

 public Long getExpire(String key) {
    return redisTemplate.getExpire(key);
}

返回剩余過期時間并且指定時間單位

public Long getExpire(String key, TimeUnit unit) {
    return redisTemplate.getExpire(key, unit);
}

將key持久化保存

public Boolean persistKey(String key) {
    return redisTemplate.persist(key);
}

將當前數(shù)據(jù)庫的key移動到指定redis中數(shù)據(jù)庫當中

public Boolean moveToDbIndex(String key, int dbIndex) {
    return redisTemplate.move(key, dbIndex);
}

設置當前的key以及value值

redisTemplate.opsForValue().set(key, value)

設置當前的key以及value值并且設置過期時間

redisTemplate.opsForValue().set(key, value, timeout, unit)

返回key中字符串的子字符

public String getCharacterRange(String key, long start, long end) {
    return redisTemplate.opsForValue().get(key, start, end);
}

將舊的key設置為value，并且返回舊的key

public String setKeyAsValue(String key, String value) {
    return redisTemplate.opsForValue().getAndSet(key, value);
}

批量獲取值

 public List<String> multiGet(Collection<String> keys) {
    return redisTemplate.opsForValue().multiGet(keys);
 }

在原有的值基礎上新增字符串到末尾

redisTemplate.opsForValue().append(key, value)

以增量的方式將double值存儲在變量中

 public Double incrByDouble(String key, double increment) {
    return redisTemplate.opsForValue().increment(key, increment);
 }

通過increment(K key, long delta)方法以增量方式存儲long值（正值則自增，負值則自減）

public Long incrBy(String key, long increment) {
    return redisTemplate.opsForValue().increment(key, increment);
}

如果對應的map集合名稱不存在，則添加否則不做修改

Map valueMap = new HashMap();  
valueMap.put("valueMap1","map1");  
valueMap.put("valueMap2","map2");  
valueMap.put("valueMap3","map3");  
redisTemplate.opsForValue().multiSetIfAbsent(valueMap);

設置map集合到redis

Map valueMap = new HashMap();  
valueMap.put("valueMap1","map1");  
valueMap.put("valueMap2","map2");  
valueMap.put("valueMap3","map3");  
redisTemplate.opsForValue().multiSet(valueMap);

獲取字符串的長度

redisTemplate.opsForValue().size(key)

用 value 參數(shù)覆寫給定 key 所儲存的字符串值，從偏移量 offset 開始

redisTemplate.opsForValue().set(key, value, offset)

重新設置key對應的值，如果存在返回false，否則返回true

redisTemplate.opsForValue().setIfAbsent(key, value)

將值 value 關聯(lián)到 key,并將 key 的過期時間設為 timeout

redisTemplate.opsForValue().set(key, value, timeout, unit)

將二進制第offset位值變?yōu)関alue

redisTemplate.opsForValue().setBit(key, offset, value)

對key所儲存的字符串值，獲取指定偏移量上的位(bit)

redisTemplate.opsForValue().getBit(key, offset)

Hash類型

Redis hash 是一個string類型的field和value的映射表，hash特別適合用于存儲對象。 Redis 中每個 hash 可以存儲 2^32 - 1 鍵值對（40多億）。

Hash結構，保存和讀取map：

示例代碼：

Map<String,String> map=new HashMap<String,String>();  
map.put("key1","value1");  
map.put("key2","value2");  
map.put("key3","value3");  
map.put("key4","value4");  
map.put("key5","value5");  
redisTemplate.opsForHash().putAll("map1",map);  
Map<String,String> resultMap= redisTemplate.opsForHash().entries("map1");  
List<String>reslutMapList=redisTemplate.opsForHash().values("map1");  
Set<String>resultMapSet=redisTemplate.opsForHash().keys("map1");  
String value=(String)redisTemplate.opsForHash().get("map1","key1");  
System.out.println("value:"+value);  
System.out.println("resultMapSet:"+resultMapSet);  
System.out.println("resultMap:"+resultMap);  
System.out.println("resulreslutMapListtMap:"+reslutMapList);

運行結果為：

value:value1

resultMapSet:[key1, key2, key5, key3, key4]

resultMap:{key3=value3, key2=value2, key1=value1, key5=value5, key4=value4}

resulreslutMapListtMap:[value1, value2, value5, value3, value4]

獲取變量中的指定map鍵是否有值,如果存在該map鍵則獲取值，沒有則返回null。

redisTemplate.opsForHash().get(key, field)

獲取變量中的鍵值對

public Map<Object, Object> hGetAll(String key) {
    return redisTemplate.opsForHash().entries(key);
}

新增hashMap值

redisTemplate.opsForHash().put(key, hashKey, value)

以map集合的形式添加鍵值對

public void hPutAll(String key, Map<String, String> maps) {
    redisTemplate.opsForHash().putAll(key, maps);
}

僅當hashKey不存在時才設置

public Boolean hashPutIfAbsent(String key, String hashKey, String value) {
    return redisTemplate.opsForHash().putIfAbsent(key, hashKey, value);
}

刪除一個或者多個hash表字段

public Long hashDelete(String key, Object... fields) {
    return redisTemplate.opsForHash().delete(key, fields);
}

查看hash表中指定字段是否存在

public boolean hashExists(String key, String field) {
    return redisTemplate.opsForHash().hasKey(key, field);
}

給哈希表key中的指定字段的整數(shù)值加上增量increment

public Long hashIncrBy(String key, Object field, long increment) {
    return redisTemplate.opsForHash().increment(key, field, increment);
}
 public Double hIncrByDouble(String key, Object field, double delta) {
    return redisTemplate.opsForHash().increment(key, field, delta);
}

獲取所有hash表中字段

redisTemplate.opsForHash().keys(key)

獲取hash表中字段的數(shù)量

redisTemplate.opsForHash().size(key)

獲取hash表中存在的所有的值

public List<Object> hValues(String key) {
    return redisTemplate.opsForHash().values(key);
}

匹配獲取鍵值對，ScanOptions.NONE為獲取全部鍵對

public Cursor<Entry<Object, Object>> hashScan(String key, ScanOptions options) {
    return redisTemplate.opsForHash().scan(key, options);
}

List類型

保存和讀取list

示例代碼：

List<String> list1=new ArrayList<String>();  
 list1.add("a1");  
list1.add("a2");  
 list1.add("a3");  
 
 List<String> list2=new ArrayList<String>();  
  list2.add("b1");  
 list2.add("b2");  
 list2.add("b3");  
redisTemplate.opsForList().leftPush("listkey1",list1);  
redisTemplate.opsForList().rightPush("listkey2",list2);  
List<String> resultList1=(List<String>)redisTemplate.opsForList().leftPop("listkey1");  
 List<String> resultList2=(List<String>)redisTemplate.opsForList().rightPop("listkey2");  
System.out.println("resultList1:"+resultList1);  
System.out.println("resultList2:"+resultList2);

運行結果：

resultList1:[a1, a2, a3]

resultList2:[b1, b2, b3]

這里需要解釋一下：不管是leftPush還是rightPush都可以用leftPop或者rightPoP任意一種獲取到其中的值，不過就是獲取的遍歷方向不一樣。有學過數(shù)據(jù)結構的人都知道里面循環(huán)鏈表是可以前后遍歷的，就和這里的場景是一樣的。如果還有不懂的話可以去看看這部分的源代碼，其實就是遍歷方向不同，所以效率也不同。所以最好leftPush用leftPoP遍歷，rightPush用rightPoP遍歷

通過索引獲取列表中的元素

redisTemplate.opsForList().index(key, index)

獲取列表指定范圍內(nèi)的元素(start開始位置, 0是開始位置，end 結束位置, -1返回所有)

redisTemplate.opsForList().range(key, start, end)

存儲在list的頭部，即添加一個就把它放在最前面的索引處

redisTemplate.opsForList().leftPush(key, value)

把多個值存入List中(value可以是多個值，也可以是一個Collection value)

redisTemplate.opsForList().leftPushAll(key, value)

List存在的時候再加入

redisTemplate.opsForList().leftPushIfPresent(key, value)

如果pivot處值存在則在pivot前面添加

redisTemplate.opsForList().leftPush(key, pivot, value)

按照先進先出的順序來添加(value可以是多個值，或者是Collection var2)

redisTemplate.opsForList().rightPush(key, value)
redisTemplate.opsForList().rightPushAll(key, value)

在pivot元素的右邊添加值

redisTemplate.opsForList().rightPush(key, pivot, value)

設置指定索引處元素的值

redisTemplate.opsForList().set(key, index, value)

移除并獲取列表中第一個元素(如果列表沒有元素會阻塞列表直到等待超時或發(fā)現(xiàn)可彈出元素為止)

redisTemplate.opsForList().leftPop(key)
redisTemplate.opsForList().leftPop(key, timeout, unit)

移除并獲取列表最后一個元素

redisTemplate.opsForList().rightPop(key)
redisTemplate.opsForList().rightPop(key, timeout, unit)

從一個隊列的右邊彈出一個元素并將這個元素放入另一個指定隊列的最左邊

redisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey)
redisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey, timeout, unit)

刪除集合中值等于value的元素(index=0, 刪除所有值等于value的元素; index>0, 從頭部開始刪除第一個值等于value的元素; index<0, 從尾部開始刪除第一個值等于value的元素)

redisTemplate.opsForList().remove(key, index, value)

將List列表進行剪裁

redisTemplate.opsForList().trim(key, start, end)

獲取當前key的List列表長度

redisTemplate.opsForList().size(key)

Set類型

保存和讀取Set：

代碼示例：

SetOperations<String, String> set = redisTemplate.opsForSet();
        set.add("set1","22");  
        set.add("set1","33");  
        set.add("set1","44");  
        Set<String> resultSet =redisTemplate.opsForSet().members("set1");  
        System.out.println("resultSet:"+resultSet);

運行結果為：

resultSet:[[set3, set2, set1]] jedis

添加元素

redisTemplate.opsForSet().add(key, values)

移除元素(單個值、多個值)

redisTemplate.opsForSet().remove(key, values)

刪除并且返回一個隨機的元素

redisTemplate.opsForSet().pop(key)

獲取集合的大小

redisTemplate.opsForSet().size(key)

判斷集合是否包含value

redisTemplate.opsForSet().isMember(key, value)

獲取兩個集合的交集(key對應的無序集合與otherKey對應的無序集合求交集)

redisTemplate.opsForSet().intersect(key, otherKey)

獲取多個集合的交集(Collection var2)

redisTemplate.opsForSet().intersect(key, otherKeys)

key集合與otherKey集合的交集存儲到destKey集合中(其中otherKey可以為單個值或者集合)

redisTemplate.opsForSet().intersectAndStore(key, otherKey, destKey)

key集合與多個集合的交集存儲到destKey無序集合中

redisTemplate.opsForSet().intersectAndStore(key, otherKeys, destKey)

獲取兩個或者多個集合的并集(otherKeys可以為單個值或者是集合)

redisTemplate.opsForSet().union(key, otherKeys)

key集合與otherKey集合的并集存儲到destKey中(otherKeys可以為單個值或者是集合)

redisTemplate.opsForSet().unionAndStore(key, otherKey, destKey)

獲取兩個或者多個集合的差集(otherKeys可以為單個值或者是集合)

redisTemplate.opsForSet().difference(key, otherKeys)

差集存儲到destKey中(otherKeys可以為單個值或者集合)

redisTemplate.opsForSet().differenceAndStore(key, otherKey, destKey)

隨機獲取集合中的一個元素

redisTemplate.opsForSet().randomMember(key)

獲取集合中的所有元素

redisTemplate.opsForSet().members(key)

隨機獲取集合中count個元素

redisTemplate.opsForSet().randomMembers(key, count)

獲取多個key無序集合中的元素（去重），count表示個數(shù)

redisTemplate.opsForSet().distinctRandomMembers(key, count)

遍歷set類似于Interator(ScanOptions.NONE為顯示所有的)

redisTemplate.opsForSet().scan(key, options)

zSet類型

ZSetOperations提供了一系列方法對有序集合進行操作添加元素(有序集合是按照元素的score值由小到大進行排列)

redisTemplate.opsForZSet().add(key, value, score)

刪除對應的value,value可以為多個值

redisTemplate.opsForZSet().remove(key, values)

增加元素的score值，并返回增加后的值

redisTemplate.opsForZSet().incrementScore(key, value, delta)

返回元素在集合的排名,有序集合是按照元素的score值由小到大排列

redisTemplate.opsForZSet().rank(key, value)

返回元素在集合的排名,按元素的score值由大到小排列

redisTemplate.opsForZSet().reverseRank(key, value)

獲取集合中給定區(qū)間的元素(start 開始位置，end 結束位置, -1查詢所有)

redisTemplate.opsForZSet().reverseRangeWithScores(key, start,end)

按照Score值查詢集合中的元素，結果從小到大排序

redisTemplate.opsForZSet().reverseRangeByScore(key, min, max)
redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, min, max)
//返回值為:Set<ZSetOperations.TypedTuple<V>>

從高到低的排序集中獲取分數(shù)在最小和最大值之間的元素

redisTemplate.opsForZSet().reverseRangeByScore(key, min, max, start, end)

根據(jù)score值獲取集合元素數(shù)量

redisTemplate.opsForZSet().count(key, min, max)

獲取集合的大小

redisTemplate.opsForZSet().size(key)
redisTemplate.opsForZSet().zCard(key)

獲取集合中key、value元素對應的score值

redisTemplate.opsForZSet().score(key, value)

移除指定索引位置處的成員

redisTemplate.opsForZSet().removeRange(key, start, end)

移除指定score范圍的集合成員

redisTemplate.opsForZSet().removeRangeByScore(key, min, max)

獲取key和otherKey的并集并存儲在destKey中（其中otherKeys可以為單個字符串或者字符串集合）

redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey)

獲取key和otherKey的交集并存儲在destKey中（其中otherKeys可以為單個字符串或者字符串集合）

redisTemplate.opsForZSet().intersectAndStore(key, otherKey, destKey)

遍歷集合（和iterator一模一樣）

Cursor<TypedTuple<Object>> scan = opsForZSet.scan("test3", ScanOptions.NONE);
        while (scan.hasNext()){
            ZSetOperations.TypedTuple<Object> item = scan.next();
            System.out.println(item.getValue() + ":" + item.getScore());
        }

到此這篇關于RedisTemplate常用操作方法總結(set、hash、list、string等)的文章就介紹到這了,更多相關RedisTemplate常用操作內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章:

詳解Redis實現(xiàn)限流的三種方式
這篇文章主要介紹了詳解Redis實現(xiàn)限流的三種方式，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
2021-04-04
Redis 命令整理并說明如何使用
這篇文章主要介紹了Redis 命令整理并說明如何使用的相關資料,需要的朋友可以參考下
2017-02-02
springboot中redis并發(fā)鎖的等待時間設置長短的方法
在SpringBoot應用中,Redis鎖的等待時間設置不當可能導致資源浪費、響應時間增加、死鎖風險升高、系統(tǒng)負載增加、業(yè)務邏輯延遲以及故障恢復慢等問題,建議合理設置等待時間,并考慮使用其他分布式鎖實現(xiàn)方式提高性能
2024-10-10
React中immutable的使用
這篇文章主要介紹了React中immutable的使用，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
2023-04-04
使用Redis實現(xiàn)向量相似度搜索
在自然語言處理領域，有一個常見且重要的任務就是文本相似度搜索，所以本文為大家介紹一下如何利用Redis實現(xiàn)向量相似度搜索，解決文本、圖像和音頻之間的相似度匹配問題，需要的可以了解下
2023-07-07
Redis在Ubuntu系統(tǒng)上無法啟動的問題排查
這篇文章主要介紹了Redis在Ubuntu系統(tǒng)上無法啟動的問題排查,文中通過代碼示例給大家介紹的非常詳細,對大家的學習或工作有一定的幫助,需要的朋友可以參考下
2024-08-08
Redis密碼設置與訪問限制實現(xiàn)方法
這篇文章主要介紹了Redis密碼設置與訪問限制實現(xiàn)方法,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
2020-11-11
Redis線程模型的原理分析
Redis是一個高性能的數(shù)據(jù)存儲框架，在高并發(fā)的系統(tǒng)設計中，Redis也是一個比較關鍵的組件，是我們提升系統(tǒng)性能的一大利器，本文詳細的介紹了Redis線程模型，感興趣的可以了解一
2021-11-11
Redis?存儲對象信息用?Hash?和String的區(qū)別
這篇文章主要介紹了Redis存儲對象信息用Hash和String的區(qū)別，文章圍繞主題展開詳細的內(nèi)容介紹，具有一定的參考價值，需要的小伙伴可以參考一下
2022-09-09
Redis延遲隊列的實現(xiàn)示例
Redis 延遲隊列是一種使用 Redis 實現(xiàn)的消息隊列,本文主要介紹了Redis延遲隊列的實現(xiàn)示例,文中通過示例代碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧
2025-01-01