springboot redis封裝類

一、實現的功能有以下：

（1）Sting操做

某個鍵是否存在

設置 String 類型 key-value

獲取 String 類型 key-value

設置 String 類型 key-value 並添加過時時間 (毫秒單位)

設置 String 類型 key-value 並添加過時時間 (分鐘單位)

設置 String 類型 key-value 並添加過時時間 (分鐘單位)

若是 key 存在則覆蓋,並返回舊值.若是不存在,返回null 並添加

批量添加 key-value (重複的鍵會覆蓋)

批量添加 key-value 只有在鍵不存在時,才添加，map中只要有一個key存在,則所有不添加

對一個 key-value 的值進行加減操做,若是該 key 不存在 將建立一個key 並賦值該 number，若是 key 存在,但 value 不是長整型 ,將報錯

對一個 key-value 的值進行加減操做,若是該 key 不存在 將建立一個key 並賦值該 number，若是 key 存在,但 value 不是 純數字 ,將報錯

對一個 key-value 的值進行加減操做,若是該 key 不存在 將建立一個key 並賦值該 number，若是 key 存在,但 value 不是 純數字 ,將報錯

給一個指定的 key 值附加過時時間

移除指定key 的過時時間

獲取指定key 的過時時間

修改 key

刪除 key-value

(2) Hash操做

添加 Hash 鍵值對

批量添加 hash 的 鍵值對，有則覆蓋,沒有則添加

添加 hash 鍵值對. 不存在的時候才添加

刪除指定 hash 的 HashKey

給指定 hash 的 hashkey 作增減操做 long

給指定 hash 的 hashkey 作增減操做 number

獲取指定 key 下的 hashkey

獲取 key 下的 全部  hashkey 和 value

驗證指定 key 下 有沒有指定的 hashkey

獲取 key 下的 全部 hashkey 字段名

獲取指定 hash 下面的 鍵值對 數量

三、List操做

指定 list 從左入棧

指定 list 從左出棧，若是列表沒有元素,會堵塞到列表一直有元素或者超時爲止

 

 

 

 

 

 

二、代碼以下

import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.DefaultTypedTuple;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations.TypedTuple;

/**
 * 2019年5月6日
 * redis 操做工具類
 */
public class RedisUtil {

    @Autowired
    private RedisTemplate<Object,Object> redisTemplate;

    public RedisTemplate<Object,Object> getInstance(){
        return redisTemplate;
    }


    /**
     * 某個鍵是否存在
     * @param key
     */
    public Boolean exist(String key){
        return redisTemplate.hasKey(key);
    }


    /**
     * 設置 String 類型 key-value
     * @param key
     * @param value
     */
    public void set(String key,String value){
        redisTemplate.opsForValue().set(key, value);
    }


    /**
     * 獲取 String 類型 key-value
     * @param key
     * @return
     */
    public String get(String key){
        return (String) redisTemplate.opsForValue().get(key);
    }

    /**
     * 設置 String 類型 key-value 並添加過時時間 (毫秒單位)
     * @param key
     * @param value
     * @param time 過時時間,毫秒單位
     */
    public void setForTimeMS(String key,String value,long time){
        redisTemplate.opsForValue().set(key, value, time, TimeUnit.MILLISECONDS);
    }

    /**
     * 設置 String 類型 key-value 並添加過時時間 (分鐘單位)
     * @param key
     * @param value
     * @param time 過時時間,分鐘單位
     */
    public void setForTimeMIN(String key,String value,long time){
        redisTemplate.opsForValue().set(key, value, time, TimeUnit.MINUTES);
    }


    /**
     * 設置 String 類型 key-value 並添加過時時間 (分鐘單位)
     * @param key
     * @param value
     * @param time 過時時間,分鐘單位
     */
    public void setForTimeCustom(String key,String value,long time,TimeUnit type){
        redisTemplate.opsForValue().set(key, value, time, type);
    }

    /**
     * 若是 key 存在則覆蓋,並返回舊值.
     * 若是不存在,返回null 並添加
     * @param key
     * @param value
     * @return
     */
    public String getAndSet(String key,String value){
        return (String) redisTemplate.opsForValue().getAndSet(key, value);
    }


    /**
     * 批量添加 key-value (重複的鍵會覆蓋)
     * @param keyAndValue
     */
    public void batchSet(Map<String,String> keyAndValue){
        redisTemplate.opsForValue().multiSet(keyAndValue);
    }

    /**
     * 批量添加 key-value 只有在鍵不存在時,才添加
     * map 中只要有一個key存在,則所有不添加
     * @param keyAndValue
     */
    public void batchSetIfAbsent(Map<String,String> keyAndValue){
        redisTemplate.opsForValue().multiSetIfAbsent(keyAndValue);
    }

    /**
     * 對一個 key-value 的值進行加減操做,
     * 若是該 key 不存在 將建立一個key 並賦值該 number
     * 若是 key 存在,但 value 不是長整型 ,將報錯
     * @param key
     * @param number
     */
    public Long increment(String key,long number){
        return redisTemplate.opsForValue().increment(key, number);
    }

    /**
     * 對一個 key-value 的值進行加減操做,
     * 若是該 key 不存在 將建立一個key 並賦值該 number
     * 若是 key 存在,但 value 不是 純數字 ,將報錯
     * @param key
     * @param number
     */
    public Double increment(String key,double number){
        return redisTemplate.opsForValue().increment(key, number);
    }


    /**
     * 給一個指定的 key 值附加過時時間
     * @param key
     * @param time
     * @param type
     * @return
     */
    public boolean expire(String key,long time,TimeUnit type){
        return redisTemplate.boundValueOps(key).expire(time, type);
    }

    /**
     * 移除指定key 的過時時間
     * @param key
     * @return
     */
    public boolean persist(String key){
        return redisTemplate.boundValueOps(key).persist();
    }


    /**
     * 獲取指定key 的過時時間
     * @param key
     * @return
     */
    public Long getExpire(String key){
        return redisTemplate.boundValueOps(key).getExpire();
    }

    /**
     * 修改 key
     * @param key
     * @return
     */
    public void rename(String key,String newKey){
        redisTemplate.boundValueOps(key).rename(newKey);
    }

    /**
     * 刪除 key-value
     * @param key
     * @return
     */
    public boolean delete(String key){
        redisTemplate.delete(key);
        return true;
    }

    //hash操做

    /**
     * 添加 Hash 鍵值對
     * @param key
     * @param hashKey
     * @param value
     */
    public void put(String key, String hashKey, String value){
        redisTemplate.opsForHash().put(key, hashKey, value);
    }

    /**
     * 批量添加 hash 的 鍵值對
     * 有則覆蓋,沒有則添加
     * @param key
     * @param map
     */
    public void putAll(String key,Map<String,String> map){
        redisTemplate.opsForHash().putAll(key, map);
    }

    /**
     * 添加 hash 鍵值對. 不存在的時候才添加
     * @param key
     * @param hashKey
     * @param value
     * @return
     */
    public boolean putIfAbsent(String key, String hashKey, String value){
        return redisTemplate.opsForHash().putIfAbsent(key, hashKey, value);
    }


    /**
     * 刪除指定 hash 的 HashKey
     * @param key
     * @param hashKeys
     * @return 刪除成功的 數量
     */
    public Long delete(String key, String ...hashKeys){
        return redisTemplate.opsForHash().delete(key, hashKeys);
    }


    /**
     * 給指定 hash 的 hashkey 作增減操做
     * @param key
     * @param hashKey
     * @param number
     * @return
     */
    public Long increment(String key, String hashKey,long number){
        return redisTemplate.opsForHash().increment(key, hashKey, number);
    }

    /**
     * 給指定 hash 的 hashkey 作增減操做
     * @param key
     * @param hashKey
     * @param number
     * @return
     */
    public Double increment(String key, String hashKey,Double number){
        return redisTemplate.opsForHash().increment(key, hashKey, number);
    }

    /**
     * 獲取指定 key 下的 hashkey
     * @param key
     * @param hashKey
     * @return
     */
    public Object getHashKey(String key,String hashKey){
        return redisTemplate.opsForHash().get(key, hashKey);
    }


    /**
     * 獲取 key 下的 全部  hashkey 和 value
     * @param key
     * @return
     */
    public Map<Object,Object> getHashEntries(String key){
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 驗證指定 key 下 有沒有指定的 hashkey
     * @param key
     * @param hashKey
     * @return
     */
    public boolean hashKey(String key,String hashKey){
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    /**
     * 獲取 key 下的 全部 hashkey 字段名
     * @param key
     * @return
     */
    public Set<Object> hashKeys(String key){
        return redisTemplate.opsForHash().keys(key);
    }


    /**
     * 獲取指定 hash 下面的 鍵值對 數量
     * @param key
     * @return
     */
    public Long hashSize(String key){
        return redisTemplate.opsForHash().size(key);
    }

    //List 操做

    /**
     * 指定 list 從左入棧
     * @param key
     * @return 當前隊列的長度
     */
    public Long leftPush(String key,Object value){
        return redisTemplate.opsForList().leftPush(key, value);
    }

    /**
     * 指定 list 從左出棧
     * 若是列表沒有元素,會堵塞到列表一直有元素或者超時爲止
     * @param key
     * @return 出棧的值
     */
    public Object leftPop(String key){
        return redisTemplate.opsForList().leftPop(key);
    }

    /**
     * 從左邊依次入棧
     * 導入順序按照 Collection 順序
     * 如: a b c => c b a
     * @param key
     * @param values
     * @return
     */
    public Long leftPushAll(String key,Collection<Object> values){
        return redisTemplate.opsForList().leftPushAll(key, values);
    }

    /**
     * 指定 list 從右入棧
     * @param key
     * @return 當前隊列的長度
     */
    public Long rightPush(String key,Object value){
        return redisTemplate.opsForList().rightPush(key, value);
    }

    /**
     * 指定 list 從右出棧
     * 若是列表沒有元素,會堵塞到列表一直有元素或者超時爲止
     * @param key
     * @return 出棧的值
     */
    public Object rightPop(String key){
        return redisTemplate.opsForList().rightPop(key);
    }

    /**
     * 從右邊依次入棧
     * 導入順序按照 Collection 順序
     * 如: a b c => a b c
     * @param key
     * @param values
     * @return
     */
    public Long rightPushAll(String key,Collection<Object> values){
        return redisTemplate.opsForList().rightPushAll(key, values);
    }


    /**
     * 根據下標獲取值
     * @param key
     * @param index
     * @return
     */
    public Object popIndex(String key,long index){
        return redisTemplate.opsForList().index(key, index);
    }


    /**
     * 獲取列表指定長度
     * @param key
     * @param index
     * @return
     */
    public Long listSize(String key,long index){
        return redisTemplate.opsForList().size(key);
    }


    /**
     * 獲取列表 指定範圍內的全部值
     * @param key
     * @param start
     * @param end
     * @return
     */
    public List<Object> listRange(String key,long start,long end){
        return redisTemplate.opsForList().range(key, start, end);
    }


    /**
     * 刪除 key 中 值爲 value 的 count 個數.
     * @param key
     * @param count
     * @param value
     * @return 成功刪除的個數
     */
    public Long listRemove(String key,long count,Object value){
        return redisTemplate.opsForList().remove(key, count, value);
    }


    /**
     * 刪除 列表 [start,end] 之外的全部元素
     * @param key
     * @param start
     * @param end
     */
    public void listTrim(String key,long start,long end){
        redisTemplate.opsForList().trim(key, start, end);

    }

    /**
     * 將 key 右出棧,並左入棧到 key2
     *
     * @param key 右出棧的列表
     * @param key2 左入棧的列表
     * @return 操做的值
     */
    public Object rightPopAndLeftPush(String key,String key2){
        return redisTemplate.opsForList().rightPopAndLeftPush(key, key2);

    }

    //set 操做  無序不重複集合

    /**
     * 添加 set 元素
     * @param key
     * @param values
     * @return
     */
    public Long add(String key ,String ...values){
        return redisTemplate.opsForSet().add(key, values);
    }

    /**
     * 獲取兩個集合的差集
     * @param key
     * @param otherkey
     * @return
     */
    public Set<Object> difference(String key ,String otherkey){
        return redisTemplate.opsForSet().difference(key, otherkey);
    }


    /**
     * 獲取 key 和 集合  collections 中的 key 集合的差集
     * @param key
     * @param otherKeys
     * @return
     */
    public Set<Object> difference(String key ,Collection<Object> otherKeys){
        return redisTemplate.opsForSet().difference(key, otherKeys);
    }

    /**
     * 將  key 與 otherkey 的差集 ,添加到新的 newKey 集合中
     * @param key
     * @param otherkey
     * @param newKey
     * @return 返回差集的數量
     */
    public Long differenceAndStore(String key ,String otherkey,String newKey){
        return redisTemplate.opsForSet().differenceAndStore(key, otherkey, newKey);
    }

    /**
     * 將 key 和 集合  collections 中的 key 集合的差集 添加到  newkey 集合中
     * @param key
     * @param otherKeys
     * @param newKey
     * @return 返回差集的數量
     */
    public Long differenceAndStore(String key,Collection<Object> otherKeys,String newKey){
        return redisTemplate.opsForSet().differenceAndStore(newKey, otherKeys, newKey);
    }

    /**
     * 刪除一個或多個集合中的指定值
     * @param key
     * @param values
     * @return 成功刪除數量
     */
    public Long remove(String key,Object ...values){
        return redisTemplate.opsForSet().remove(key, values);
    }

    /**
     * 隨機移除一個元素,並返回出來
     * @param key
     * @return
     */
    public Object randomSetPop(String key){
        return redisTemplate.opsForSet().pop(key);
    }

    /**
     * 隨機獲取一個元素
     * @param key
     * @return
     */
    public Object randomSet(String key){
        return redisTemplate.opsForSet().randomMember(key);
    }

    /**
     * 隨機獲取指定數量的元素,同一個元素可能會選中兩次
     * @param key
     * @param count
     * @return
     */
    public List<Object> randomSet(String key,long count){
        return redisTemplate.opsForSet().randomMembers(key, count);
    }

    /**
     * 隨機獲取指定數量的元素,去重(同一個元素只能選擇兩一次)
     * @param key
     * @param count
     * @return
     */
    public Set<Object> randomSetDistinct(String key,long count){
        return redisTemplate.opsForSet().distinctRandomMembers(key, count);
    }

    /**
     * 將 key 中的 value 轉入到 destKey 中
     * @param key
     * @param value
     * @param destKey
     * @return 返回成功與否
     */
    public boolean moveSet(String key,Object value,String destKey){
        return redisTemplate.opsForSet().move(key, value, destKey);
    }

    /**
     * 無序集合的大小
     * @param key
     * @return
     */
    public Long setSize(String key){
        return redisTemplate.opsForSet().size(key);
    }

    /**
     * 判斷 set 集合中 是否有 value
     * @param key
     * @param value
     * @return
     */
    public boolean isMember(String key,Object value){
        return redisTemplate.opsForSet().isMember(key, value);
    }

    /**
     * 返回 key 和 othere 的並集
     * @param key
     * @param otherKey
     * @return
     */
    public Set<Object> unionSet(String key,String otherKey){
        return redisTemplate.opsForSet().union(key, otherKey);
    }

    /**
     * 返回 key 和 otherKeys 的並集
     * @param key
     * @param otherKeys 的集合
     * @return
     */
    public Set<Object> unionSet(String key,Collection<Object> otherKeys){
        return redisTemplate.opsForSet().union(key, otherKeys);
    }

    /**
     * 將 key 與 otherKey 的並集,保存到 destKey 中
     * @param key
     * @param otherKey
     * @param destKey
     * @return destKey 數量
     */
    public Long unionAndStoreSet(String key, String otherKey,String destKey){
        return redisTemplate.opsForSet().unionAndStore(key, otherKey, destKey);
    }

    /**
     * 將 key 與 otherKey 的並集,保存到 destKey 中
     * @param key
     * @param otherKeys
     * @param destKey
     * @return destKey 數量
     */
    public Long unionAndStoreSet(String key, Collection<Object> otherKeys,String destKey){
        return redisTemplate.opsForSet().unionAndStore(key, otherKeys, destKey);
    }

    /**
     * 返回集合中全部元素
     * @param key
     * @return
     */
    public Set<Object> members(String key){
        return redisTemplate.opsForSet().members(key);
    }

    //Zset 根據 socre 排序   不重複 每一個元素附加一個 socre  double類型的屬性(double 能夠重複)

    /**
     * 添加 ZSet 元素
     * @param key
     * @param value
     * @param score
     */
    public boolean add(String key,Object value,double score){
        return redisTemplate.opsForZSet().add(key, value, score);
    }

    /**
     * 批量添加 Zset <br>
     *         Set<TypedTuple<Object>> tuples = new HashSet<>();<br>
     *         TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<Object>("zset-5",9.6);<br>
     *         tuples.add(objectTypedTuple1);
     * @param key
     * @param tuples
     * @return
     */
    public Long batchAddZset(String key,Set<TypedTuple<Object>> tuples){
        return redisTemplate.opsForZSet().add(key, tuples);
    }

    /**
     * Zset 刪除一個或多個元素
     * @param key
     * @param values
     * @return
     */
    public Long removeZset(String key,String ...values){
        return redisTemplate.opsForZSet().remove(key, values);
    }

    /**
     * 對指定的 zset 的 value 值 , socre 屬性作增減操做
     * @param key
     * @param value
     * @param score
     * @return
     */
    public Double incrementScore(String key,Object value,double score){
        return redisTemplate.opsForZSet().incrementScore(key, value, score);
    }

    /**
     * 獲取 key 中指定 value 的排名(從0開始,從小到大排序)
     * @param key
     * @param value
     * @return
     */
    public Long rank(String key,Object value){
        return redisTemplate.opsForZSet().rank(key, value);
    }

    /**
     * 獲取 key 中指定 value 的排名(從0開始,從大到小排序)
     * @param key
     * @param value
     * @return
     */
    public Long reverseRank(String key,Object value){
        return redisTemplate.opsForZSet().reverseRank(key, value);
    }

    /**
     * 獲取索引區間內的排序結果集合(從0開始,從小到大,帶上分數)
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<TypedTuple<Object>> rangeWithScores(String key, long start, long end){
        return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
    }

    /**
     * 獲取索引區間內的排序結果集合(從0開始,從小到大,只有列名)
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<Object> range(String key, long start, long end){
        return redisTemplate.opsForZSet().range(key, start, end);
    }

    /**
     * 獲取分數範圍內的 [min,max] 的排序結果集合 (從小到大,只有列名)
     * @param key
     * @param min
     * @param max
     * @return
     */
    public Set<Object> rangeByScore(String key, double min, double max){
        return redisTemplate.opsForZSet().rangeByScore(key, min, max);
    }

    /**
     * 獲取分數範圍內的 [min,max] 的排序結果集合 (從小到大,集合帶分數)
     * @param key
     * @param min
     * @param max
     * @return
     */
    public Set<TypedTuple<Object>> rangeByScoreWithScores(String key, double min, double max){
        return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max);
    }

    /**
     * 返回 分數範圍內 指定 count 數量的元素集合, 而且從 offset 下標開始(從小到大,不帶分數的集合)
     * @param key
     * @param min
     * @param max
     * @param offset 從指定下標開始
     * @param count 輸出指定元素數量
     * @return
     */
    public Set<Object> rangeByScore(String key, double min, double max,long offset,long count){
        return redisTemplate.opsForZSet().rangeByScore(key, min, max, offset, count);
    }

    /**
     * 返回 分數範圍內 指定 count 數量的元素集合, 而且從 offset 下標開始(從小到大,帶分數的集合)
     * @param key
     * @param min
     * @param max
     * @param offset 從指定下標開始
     * @param count 輸出指定元素數量
     * @return
     */
    public Set<TypedTuple<Object>> rangeByScoreWithScores(String key, double min, double max,long offset,long count){
        return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max, offset, count);
    }

    /**
     * 獲取索引區間內的排序結果集合(從0開始,從大到小,只有列名)
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<Object> reverseRange(String key,long start,long end){
        return redisTemplate.opsForZSet().reverseRange(key, start, end);
    }

    /**
     * 獲取索引區間內的排序結果集合(從0開始,從大到小,帶上分數)
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set<TypedTuple<Object>> reverseRangeWithScores(String key,long start,long end){
        return redisTemplate.opsForZSet().reverseRangeWithScores(key, start, end);
    }

    /**
     * 獲取分數範圍內的 [min,max] 的排序結果集合 (從大到小,集合不帶分數)
     * @param key
     * @param min
     * @param max
     * @return
     */
    public Set<Object> reverseRangeByScore(String key,double min,double max){
        return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max);
    }

    /**
     * 獲取分數範圍內的 [min,max] 的排序結果集合 (從大到小,集合帶分數)
     * @param key
     * @param min
     * @param max
     * @return
     */
    public Set<TypedTuple<Object>> reverseRangeByScoreWithScores(String key,double min,double max){
        return redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, min, max);
    }

    /**
     * 返回 分數範圍內 指定 count 數量的元素集合, 而且從 offset 下標開始(從大到小,不帶分數的集合)
     * @param key
     * @param min
     * @param max
     * @param offset 從指定下標開始
     * @param count 輸出指定元素數量
     * @return
     */
    public Set<Object> reverseRangeByScore(String key,double min,double max,long offset,long count){
        return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max, offset, count);
    }

    /**
     * 返回 分數範圍內 指定 count 數量的元素集合, 而且從 offset 下標開始(從大到小,帶分數的集合)
     * @param key
     * @param min
     * @param max
     * @param offset 從指定下標開始
     * @param count 輸出指定元素數量
     * @return
     */
    public Set<TypedTuple<Object>> reverseRangeByScoreWithScores(String key,double min,double max,long offset,long count){
        return redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key, min, max, offset, count);
    }

    /**
     * 返回指定分數區間 [min,max] 的元素個數
     * @param key
     * @param min
     * @param max
     * @return
     */
    public long countZSet(String key,double min,double max){
        return redisTemplate.opsForZSet().count(key, min, max);
    }

    /**
     * 返回 zset 集合數量
     * @param key
     * @return
     */
    public long sizeZset(String key){
        return redisTemplate.opsForZSet().size(key);
    }

    /**
     * 獲取指定成員的 score 值
     * @param key
     * @param value
     * @return
     */
    public Double score(String key,Object value){
        return redisTemplate.opsForZSet().score(key, value);
    }

    /**
     * 刪除指定索引位置的成員,其中成員分數按( 從小到大 )
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Long removeRange(String key,long start ,long end){
        return redisTemplate.opsForZSet().removeRange(key, start, end);
    }

    /**
     * 刪除指定 分數範圍 內的成員 [main,max],其中成員分數按( 從小到大 )
     * @param key
     * @param min
     * @param max
     * @return
     */
    public Long removeRangeByScore(String key,double min ,double max){
        return redisTemplate.opsForZSet().removeRangeByScore(key, min, max);
    }

    /**
     *  key 和 other 兩個集合的並集,保存在 destKey 集合中, 列名相同的 score 相加
     * @param key
     * @param otherKey
     * @param destKey
     * @return
     */
    public Long unionAndStoreZset(String key,String otherKey,String destKey){
        return redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey);
    }

    /**
     *  key 和 otherKeys 多個集合的並集,保存在 destKey 集合中, 列名相同的 score 相加
     * @param key
     * @param otherKeys
     * @param destKey
     * @return
     */
    public Long unionAndStoreZset(String key,Collection<String> otherKeys,String destKey){
        return redisTemplate.opsForZSet().unionAndStore(key, otherKeys, destKey);
    }

    /**
     *  key 和 otherKey 兩個集合的交集,保存在 destKey 集合中
     * @param key
     * @param otherKey
     * @param destKey
     * @return
     */
    public Long intersectAndStore(String key,String otherKey,String destKey){
        return redisTemplate.opsForZSet().intersectAndStore(key, otherKey, destKey);
    }

    /**
     *  key 和 otherKeys 多個集合的交集,保存在 destKey 集合中
     * @param key
     * @param otherKeys
     * @param destKey
     * @return
     */
    public Long intersectAndStore(String key,Collection<String> otherKeys,String destKey){
        return redisTemplate.opsForZSet().intersectAndStore(key, otherKeys, destKey);
    }
}