前言
在 JedisCommands 接口中，其提供了操作 Redis 的全部方法，分別對應着 Redis 的各種操作命令，但遺憾的是，該接口中並沒有給出詳細的註釋。
在這種情況下，如果我們想知道某個方法的作用，就需要我們找到其對應的 Redis 命令來進行理解了，很不方便。
因此，在本文中，給出 JedisCommands 接口中各方法的詳細註釋，希望對大家有所幫助！
順便，給出 JedisCommands 接口所在包的 Maven 座標：
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
方法說明
package redis.clients.jedis;
import java.util.List;
import java.util.Map;
import java.util.Set;
import redis.clients.jedis.params.geo.GeoRadiusParam;
import redis.clients.jedis.params.sortedset.ZAddParams;
import redis.clients.jedis.params.sortedset.ZIncrByParams;
/**
* Common interface for sharded and non-sharded Jedis
*/
public interface JedisCommands {
/**
* 存儲數據到緩存中，若 key 已存在則覆蓋
* value 的長度不能超過 1073741824 bytes (1 GB)
*
* @param key 緩存鍵
* @param value 緩存值
* @return
*/
String set(String key, String value);
/**
* 存儲數據到緩存中，並制定過期時間以及當 Key 存在時是否覆蓋
*
* @param key 緩存鍵
* @param value 緩存值
* @param nxxx 該的值只能取 NX 或者 XX，
* 如果取 NX，則只有當 key 不存在時才進行 set
* 如果取 XX，則只有當 key 已經存在時才進行 set
* @param expx 該的值只能取 EX 或者 PX，代表數據過期時間的單位，EX 代表秒，PX 代表毫秒
* @param time 過期時間，單位是 expx 所代表的單位
* @return
*/
String set(String key, String value, String nxxx, String expx, long time);
/**
* 從緩存中根據 key 取得其 String 類型的值
* 如果 key 不存在則返回 null
* 如果 key 存在但 value 不是 string 類型的，則返回一個錯誤
* 這個方法只能從緩存中取得 value 爲 string 類型的值。
*
* @param key 緩存鍵
* @return
*/
String get(String key);
/**
* 檢查某個 key 是否在緩存中存在，如果存在返回true，否則返回false
* 需要注意的是，即使該 key 所對應的 value 是一個空字符串，也依然會返回 true
*
* @param key 緩存鍵
* @return
*/
Boolean exists(String key);
/**
* 如果一個 key 設置了過期時間，則取消其過期時間，使其永久存在
*
* @param key 緩存鍵
* @return 返回 1 或者 0, 1 代表取消過期時間成功，0 代表不成功(只有當 key 不存在時這種情況纔會發生)
*/
Long persist(String key);
/**
* 返回某個 key 所存儲的數據類型，返回的數據類型有可能是：
* "none", "string", "list", "set", "zset", "hash"
* 其中，"none" 代表 key 不存在
*
* @param key 緩存鍵
* @return
*/
String type(String key);
/**
* 爲 key 設置一個特定的過期時間，單位爲秒，過期時間一到，redis 將會從緩存中刪除掉該 key
* 即使是有過期時間的 key，redis 也會在持久化時將其寫到硬盤中，並把相對過期時間改爲絕對的 Unix 過期時間
* 在一個有設置過期時間的 key 上重複設置過期時間將會覆蓋原先設置的過期時間
*
* @param key 緩存鍵
* @param seconds 過期時間，單位爲秒
* @return 返回 1 表示成功設置過期時間，返回 0 表示 key 不存在
*/
Long expire(String key, int seconds);
/**
* 機制同{@link expire}一樣，只是時間單位改爲毫秒
*
* @param key 緩存鍵
* @param milliseconds 過期時間，單位爲毫秒
* @return 返回值同 {@link expire}一樣
*/
Long pexpire(String key, long milliseconds);
/**
* 與{@link expire}不一樣，
* expireAt 設置的時間不是能存活多久，而是固定的 UNIX 時間（從1970年開始算起），單位爲秒
*
* @param key 緩存鍵
* @param unixTime 過期時間
* @return
*/
Long expireAt(String key, long unixTime);
/**
* 同{@link expireAt}機制相同，但單位爲毫秒
*
* @param key 緩存鍵
* @param millisecondsTimestamp 過期時間
* @return
*/
Long pexpireAt(String key, long millisecondsTimestamp);
/**
* 返回一個 key 還能活多久，單位爲秒
*
* @param key 緩存鍵
* @return 如果該 key 本來並沒有設置過期時間，則返回 -1，如果該 key 不存在，則返回 -2
*/
Long ttl(String key);
/**
* 設置或者清除指定 key 的 value 上的某個位置的比特位
* 如果該 key 原先不存在，則新創建一個 key，其 value 將會自動分配內存，
* 直到可以放下指定位置的bit值
*
* @param key 緩存鍵
* @param offset 位置偏移量
* @param value true 代表 1，false 代表 0
* @return 返回原來位置的 bit 值是否是 1，如果是 1，則返回 true，否則返回 false
*/
Boolean setbit(String key, long offset, boolean value);
/**
* 設置或者清除指定 key 的 value 上的某個位置的比特位，
* 如果該 key 原先不存在，則新創建一個 key，其 value 將會自動分配內存，
* 直到可以放下指定位置的 bit 值
*
* @param key 緩存鍵
* @param offset 位置偏移量
* @param value 只能是 "1" 或者 "0"
* @return 返回原來位置的 bit 值是否是 1，如果是 1，則返回 true，否則返回 false
*/
Boolean setbit(String key, long offset, String value);
/**
* 取得偏移量爲 offset 的 bit 值
*
* @param key 緩存鍵
* @param offset 位置偏移量
* @return true 代表 1，false 代表 0
*/
Boolean getbit(String key, long offset);
/**
* 這個命令的作用是覆蓋 key 對應的 string 的一部分，從指定的 offset 處開始，覆蓋 value 的長度
* 如果 offset 比當前 key 對應 string 還要長，那這個 string 後面就補 0 以達到 offset
* 不存在的 key 被認爲是空字符串，所以這個命令可以確保 key 有一個足夠大的字符串，能在 offset 處設置 value
*
* @param key 緩存鍵
* @param offset 位置偏移量
* @param value
* @return 該命令修改後的字符串長度
*/
Long setrange(String key, long offset, String value);
/**
* 獲得 start - end 之間的子字符串，若偏移量爲負數，代表從末尾開始計算
* 例如 -1 代表倒數第一個，-2 代表倒數第二個
*
* @param key 緩存鍵
* @param startOffset 起始偏移量
* @param endOffset 末尾偏移量
* @return
*/
String getrange(String key, long startOffset, long endOffset);
/**
* 自動將 key 對應到 value 並且返回原來 key 對應的 value
* 如果 key 存在但是對應的 value不 是字符串，就返回錯誤
*
* @param key 緩存鍵
* @param value 緩存值
* @return
*/
String getSet(String key, String value);
/**
* 當 key 不存在時，進行 set
*
* @param key 緩存鍵
* @param value 緩存值
* @return
*/
Long setnx(String key, String value);
/**
* 當 key 存在時，進行 set
*
* @param key 緩存鍵
* @param seconds 過期時間，單位爲秒
* @param value 緩存鍵
* @return
*/
String setex(String key, int seconds, String value);
/**
* 將指定 key 的值減少某個值
*
* @param key 緩存鍵
* @param integer 待減值
* @return 返回減少後的新值
*/
Long decrBy(String key, long integer);
/**
* 將指定 Key 的值減少 1
*
* @param key 緩存鍵
* @return 返回減少後的新值
*/
Long decr(String key);
/**
* 將指定的 key 的值增加指定的值
*
* @param key 緩存鍵
* @param integer 待加值
* @return 返回增加後的新值
*/
Long incrBy(String key, long integer);
/**
* 將指定的 key 的值增加指定的值(浮點數)
*
* @param key 緩存鍵
* @param value 待加值
* @return 返回增加後的新值
*/
Double incrByFloat(String key, double value);
/**
* 將指定的 key 的值增加 1
*
* @param key 緩存鍵
* @return 返回增加後的新值
*/
Long incr(String key);
/**
* 若 key 存在，將 value 追加到原有字符串的末尾
* 若 key 不存在，則創建一個新的空字符串
*
* @param key 緩存鍵
* @param value 待處理值
* @return 返回字符串的總長度
*/
Long append(String key, String value);
/**
* 返回 start - end 之間的子字符串(start 和 end 處的字符也包括在內)
*
* @param key 緩存鍵
* @param start 起始索引
* @param end 結束索引
* @return 返回子字符串
*/
String substr(String key, int start, int end);
/**
* 設置 hash 表裏 field 字段的值爲 value
* 如果 key 不存在，則創建一個新的 hash 表
*
* @param key 緩存鍵
* @param field 哈希表字段
* @param value 字段對應的值
* @return 如果該字段已經存在，那麼將會更新該字段的值，返回 0，如果字段不存在，則新創建一個並且返回 1
*/
Long hset(String key, String field, String value);
/**
* 如果該 key 對應的值是一個哈希表，則返回對應字段的值
* 如果不存在該字段，或者 key 不存在，則返回一個 "nil" 值
*
* @param key 緩存鍵
* @param field 哈希表字段
* @return
*/
String hget(String key, String field);
/**
* 當字段不存在時，才進行 set
*
* @param key 緩存鍵
* @param field 哈希表字段
* @param value 字段對應的值
* @return 如果該字段已經存在，則返回 0，若字段不存在，則創建後 set，返回 1
*/
Long hsetnx(String key, String field, String value);
/**
* 設置多個字段和值，如果字段存在，則覆蓋
*
* @param key 緩存鍵
* @param hash 哈希表
* @return 設置成功返回 OK，設置不成功則返回 EXCEPTION
*/
String hmset(String key, Map<String, String> hash);
/**
* 在 hash 中獲取多個字段的值，若字段不存在，則其值爲 nil
*
* @param key 緩存鍵
* @param fields 哈希表字段
* @return 按順序返回多個字段的值。
*/
List<String> hmget(String key, String... fields);
/**
* 對 hash 中指定字段的值增加指定的值
*
* @param key 緩存鍵
* @param field 哈希表字段
* @param value 字段對應的值
* @return 返回增加後的新值
*/
Long hincrBy(String key, String field, long value);
/**
* 判斷 hash 中指定字段是否存在
*
* @param key 緩存鍵
* @param field 哈希表字段
* @return 若存在返回 1，若不存在返回 0
*/
Boolean hexists(String key, String field);
/**
* 刪除 hash 中指定字段
*
* @param key 緩存鍵
* @param field 哈希表字段
* @return 刪除成功返回 1， 刪除不成功返回 0
*/
Long hdel(String key, String... field);
/**
* 返回 key 指定的哈希集包含的字段的數量
*
* @param key 緩存鍵
* @return 哈希集中字段的數量，當 key 指定的哈希集不存在時返回 0
*/
Long hlen(String key);
/**
* 返回 key 指定的哈希集中所有字段的名字
*
* @param key 緩存鍵
* @return 哈希集中的字段列表，當 key 指定的哈希集不存在時返回空列表
*/
Set<String> hkeys(String key);
/**
* 返回 key 指定的哈希集中所有字段的值。
*
* @param key 緩存鍵
* @return 哈希集中的值的列表，當 key 指定的哈希集不存在時返回空列表
*/
List<String> hvals(String key);
/**
* 返回 key 指定的哈希集中所有的字段和值
*
* @param key 緩存鍵
* @return 返回 key 指定的哈希集中所有的字段和值,若 key 不存在返回空 map
*/
Map<String, String> hgetAll(String key);
/**
* 向存於 key 的列表的尾部插入所有指定的值
* 如果 key 不存在，那麼會創建一個空的列表然後再進行 push 操作
* 當 key 對應的值不是一個列表，那麼會返回一個錯誤
* <p>
* 可以使用一個命令把多個元素打入隊列，只需要在命令後面指定多個參數，元素是從左到右一個接一個從列表尾部插入
* 比如命令 RPUSH mylist a b c 會返回一個列表，其第一個元素是 a ，第二個元素是 b ，第三個元素是 c
*
* @param key 緩存鍵
* @param string 待處理字符串
* @return 返回 push 操作後的列表長度
*/
Long rpush(String key, String... string);
/**
* 將所有指定的值插入到存於 key 的列表的頭部
* 如果 key 不存在，那麼在進行 push 操作前會創建一個空列表
* 如果 key 對應的值不是一個 list 的話，那麼會返回一個錯誤
* <p>
* 可以使用一個命令把多個元素 push 進入列表，只需在命令末尾加上多個指定的參數，元素是從最左端的到最右端的、一個接一個被插入到列表的頭部
* 比如命令 LPUSH mylist a b c，返回的列表是 c 爲第一個元素， b 爲第二個元素， a 爲第三個元素
*
* @param key 緩存鍵
* @param string 待處理字符串
* @return 在 push 操作後的列表長度。
*/
Long lpush(String key, String... string);
/**
* 返回存儲在 key 裏的 list 的長度
* 如果 key 不存在，那麼就被看作是空 list，並且返回長度爲 0
* 當存儲在 key 裏的值不是一個 list 的話，會返回錯誤
*
* @param key 緩存鍵
* @return key 對應的 list 的長度。
*/
Long llen(String key);
/**
* 返回存儲在 key 的列表裏指定範圍內的元素
* start 和 end 偏移量都是基於 0 的下標
* 即 list 的第一個元素下標是 0（list 的表頭），第二個元素下標是 1，以此類推
* <p>
* 偏移量也可以是負數，表示偏移量是從 list 尾部開始計數
* 例如，-1 表示列表的最後一個元素，-2 是倒數第二個，以此類推
*
* @param key 緩存鍵
* @param start 起始偏移量
* @param end 結束偏移量
* @return 指定範圍裏的列表元素
*/
List<String> lrange(String key, long start, long end);
/**
* 修剪(trim)一個已存在的 list，處理後的 list 只包含指定範圍的指定元素
* start 和 stop 都是由 0 開始計數的，
* 這裏的 0 是列表裏的第一個元素（表頭），1 是第二個元素，以此類推
*
* @param key 緩存鍵
* @param start 起始偏移量
* @param end 結束偏移量
* @return
*/
String ltrim(String key, long start, long end);
/**
* 返回列表裏的元素的索引 index 存儲在 key 裏面
* 下標是從 0 開始索引的，所以 0 是表示第一個元素，1 表示第二個元素，並以此類推
* 負數索引用於指定從列表尾部開始索引的元素。在這種方法下，-1 表示最後一個元素，-2 表示倒數第二個元素，並以此往前推
* <p>
* 當 key 位置的值不是一個列表的時候，會返回一個錯誤
*
* @param key 緩存鍵
* @param index 索引
* @return 請求的對應元素，或者當 index 超過範圍的時候返回 nil
*/
String lindex(String key, long index);
/**
* 設置 index 位置的 list 元素的值爲 value，當 index 超出範圍時會返回一個錯誤
*
* @param key 緩存鍵
* @param index 索引
* @param value 待處理值
* @return 狀態恢復
*/
String lset(String key, long index, String value);
/**
* 從存於 key 的列表裏移除前 count 次出現的值爲 value 的元素，這個 count 參數通過下面幾種方式影響這個操作：
* <p>
* count > 0: 從頭往尾移除值爲 value 的元素
* count < 0: 從尾往頭移除值爲 value 的元素
* count = 0: 移除所有值爲 value 的元素
* <p>
* 比如， LREM list -2 "hello" 會從存於 list 的列表裏移除最後兩個出現的 "hello"
* <p>
* 需要注意的是，如果 list 裏沒有存在 key 就會被當作空 list 處理，所以當 key 不存在的時候，這個命令會返回 0
*
* @param key 緩存鍵
* @param count 出現次數
* @param value 待處理值
* @return 返回刪除的個數
*/
Long lrem(String key, long count, String value);
/**
* 移除並且返回 key 對應的 list 的第一個元素
*
* @param key 緩存鍵
* @return 返回第一個元素的值，或者當 key 不存在時返回 nil
*/
String lpop(String key);
/**
* 移除並返回存於 key 的 list 的最後一個元素
*
* @param key 緩存鍵
* @return 最後一個元素的值，或者當 key 不存在的時候返回 nil
*/
String rpop(String key);
/**
* 添加一個或多個指定的 member 元素到 key 對應的集合中
* 指定的一個或者多個元素 member 如果已經在集合 key 中存在則忽略
* 如果集合 key 不存在，則新建集合 key,並添加 member 元素到集合 key 中
* <p>
* 如果key 的類型不是集合則返回錯誤.
*
* @param key 緩存鍵
* @param member 待處理成員
* @return 返回新成功添加到集合裏元素的數量，不包括已經存在於集合中的元素
*/
Long sadd(String key, String... member);
/**
* 返回 key 集合所有的元素
* <p>
* 該命令的作用與使用一個參數的 SINTER 命令作用相同
*
* @param key 緩存鍵
* @return 集合中的所有元素
*/
Set<String> smembers(String key);
/**
* 在 key 集合中移除指定的元素
* 如果指定的元素不是 key 集合中的元素則忽略
* 如果 key 集合不存在則被視爲一個空的集合，該命令返回 0
* <p>
* 如果 key 的類型不是一個集合,則返回錯誤
*
* @param key 緩存鍵
* @param member 待處理成員
* @return 從集合中移除元素的個數，不包括不存在的成員
*/
Long srem(String key, String... member);
/**
* 移除並返回一個集合中的隨機元素
* <p>
* 該命令與 SRANDMEMBER 相似,不同的是 srandmember 命令返回一個隨機元素但是不移除
*
* @param key 緩存鍵
* @return 被移除的元素, 當 key 不存在的時候返回 nil
*/
String spop(String key);
/**
* 移除並返回多個集合中的隨機元素
*
* @param key 緩存鍵
* @param count 數量
* @return 被移除的元素, 當 key 不存在的時候值爲 nil
*/
Set<String> spop(String key, long count);
/**
* 返回集合存儲的 key 的基數 (集合元素的數量)
*
* @param key 緩存鍵
* @return 集合的基數(元素的數量), 如果 key 不存在, 則返回 0
*/
Long scard(String key);
/**
* 返回成員 member 是否是存儲的集合 key 的成員
*
* @param key 緩存鍵
* @param member 待處理成員
* @return 如果 member 元素是集合 key 的成員，則返回 1，如果不是或者集合 key 不存在，則返回 0
*/
Boolean sismember(String key, String member);
/**
* 僅提供 key 參數,那麼隨機返回 key 集合中的一個元素
* 該命令作用類似於 SPOP 命令, 不同的是 SPOP 命令會將被選擇的隨機元素從集合中移除
* 而 SRANDMEMBER 僅僅是返回該隨記元素，而不做任何操作
*
* @param key 緩存鍵
* @return 返回隨機的元素, 如果 key 不存在則返回 nil
*/
String srandmember(String key);
/**
* 如果 count 是整數且小於元素的個數，則返回含有 count 個不同的元素的列表
* 如果 count 是整數且大於集合中元素的個數時，僅返回整個集合的所有元素
* 如果 count 是負數，則會返回一個包含 count 的絕對值的個數元素的列表
* 如果 count 的絕對值大於元素的個數，則返回的結果集裏會出現一個元素出現多次的情況
*
* @param key 緩存鍵
* @param count 數量
* @return 返回一個隨機的元素數組, 如果 key 不存在則返回一個空的列表
*/
List<String> srandmember(String key, int count);
/**
* 返回 key 的 string 類型 value 的長度
* 如果 key 對應的非 string 類型，就返回錯誤
*
* @param key 緩存鍵
* @return key 對應的字符串 value 的長度，或者 0（key不存在）
*/
Long strlen(String key);
/**
* 該命令添加指定的成員到 key 對應的有序集合中，每個成員都有一個分數，你可以指定多個分數/成員組合
* 如果一個指定的成員已經在對應的有序集合中了，那麼其分數就會被更新成最新的，並且該成員會重新調整到正確的位置，以確保集合有序
* 如果 key 不存在，就會創建一個含有這些成員的有序集合，就好像往一個空的集合中添加一樣
* 如果 key 存在，但是它並不是一個有序集合，那麼就返回一個錯誤
* <p>
* 分數的值必須是一個表示數字的字符串，並且可以是 double 類型的浮點數
*
* @param key 緩存鍵
* @param score 分數
* @param member 待處理成員
* @return 返回添加到有序集合中元素的個數，不包括那種已經存在只是更新分數的元素
*/
Long zadd(String key, double score, String member);
/**
* 該命令添加指定的成員到 key 對應的有序集合中，每個成員都有一個分數，你可以指定多個分數/成員組合
* 如果一個指定的成員已經在對應的有序集合中了，那麼其分數就會被更新成最新的，並且該成員會重新調整到正確的位置，以確保集合有序
* 如果 key 不存在，就會創建一個含有這些成員的有序集合，就好像往一個空的集合中添加一樣
* 如果 key 存在，但是它並不是一個有序集合，那麼就返回一個錯誤
* <p>
* 分數的值必須是一個表示數字的字符串，並且可以是 double 類型的浮點數
*
* @param key 緩存鍵
* @param scoreMembers 成員及分數 MAP
* @return 返回添加到有序集合中元素的個數，不包括那種已經存在只是更新分數的元素
*/
Long zadd(String key, Map<String, Double> scoreMembers);
/**
* 返回有序集 key 中，指定區間內的成員。
* 其中成員按 score 值遞增(從小到大)來排序，具有相同 score 值的成員按字典序來排列
* <p>
* 如果你需要成員按 score 值遞減(score 相等時按字典序遞減)來排列，請使用 ZREVRANGE 命令
* 下標參數 start 和 stop 都以 0 爲底，也就是說，以 0 表示有序集第一個成員，以 1 表示有序集第二個成員，以此類推
* 你也可以使用負數下標，以 -1 表示最後一個成員，-2 表示倒數第二個成員，以此類推
* <p>
* 超出範圍的下標並不會引起錯誤。如果 start 的值比有序集的最大下標還要大，
* 或是 start > stop 時，ZRANGE 命令只是簡單地返回一個空列表
* 另一方面，假如 stop 參數的值比有序集的最大下標還要大，那麼 Redis 將 stop 當作最大下標來處理
*
* @param key 緩存鍵
* @param start 起始索引
* @param end 結束索引
* @return 指定範圍的元素列表
*/
Set<String> zrange(String key, long start, long end);
/**
* 從集合中刪除指定 member 元素，當 key 存在，但是其不是有序集合類型，就返回一個錯誤
*
* @param key 緩存鍵
* @param member 待處理成員
* @return 返回的是從有序集合中刪除的成員個數，不包括不存在的成員
*/
Long zrem(String key, String... member);
/**
* 爲有序集 key 的成員 member 的 score 值加上增量 increment
* 如果 key 中不存在 member，就在 key 中添加一個 member，其 score 是 increment（就好像它之前的 score 是0.0）
* 如果 key 不存在，就創建一個只含有指定 member 成員的有序集合
* 如果 key 不是有序集類型時，返回一個錯誤
* <p>
* score 值必須整數值或雙精度浮點數，也有可能給一個負數來減少 score 的值
*
* @param key 緩存鍵
* @param score 分數
* @param member 待處理成員
* @return member 成員的新 score 值
*/
Double zincrby(String key, double score, String member);
/**
* 返回有序集 key 中成員 member 的排名
* 其中有序集成員按 score 值遞增(從小到大)順序排列
* 排名以 0 爲底，也就是說，score 值最小的成員排名爲 0
* <p>
* 使用 ZREVRANK 命令可以獲得成員按 score 值遞減(從大到小)排列的排名
*
* @param key 緩存鍵
* @param member 待處理成員
* @return 如果 member 是有序集 key 的成員，返回 member 的排名的整數，如果 member 不是有序集 key 的成員，返回 nil
*/
Long zrank(String key, String member);
/**
* 返回有序集 key 中成員 member 的排名
* 其中有序集成員按 score 值從大到小排列
* 排名以 0 爲底，也就是說，score 值最大的成員排名爲 0
* <p>
* 使用 ZRANK 命令可以獲得成員按 score 值遞增(從小到大)排列的排名
*
* @param key 緩存鍵
* @param member 待處理成員
* @return 如果 member 是有序集 key 的成員，返回 member 的排名，如果 member 不是有序集 key 的成員，返回 nil
*/
Long zrevrank(String key, String member);
/**
* 返回有序集 key 中，指定區間內的成員
* 其中成員的位置按 score 值遞減(從大到小)來排列，具有相同 score 值的成員按字典序的反序排列
* 除了成員按 score 值遞減的次序排列這一點外，ZREVRANGE 命令的其他方面和 ZRANGE 命令一樣
*
* @param key 緩存鍵
* @param start 起始索引
* @param end 結束索引
* @return 指定範圍的元素列表(可選是否含有分數)
*/
Set<String> zrevrange(String key, long start, long end);
/**
* 返回有序集 key 中，指定區間內的成員
* 其中成員按 score 值遞增(從小到大)來排序，具有相同 score 值的成員按字典序來排列
* <p>
* 如果你需要成員按 score 值遞減(score 相等時按字典序遞減)來排列，請使用 ZREVRANGE 命令
* 下標參數 start 和 stop 都以 0 爲底，也就是說，以 0 表示有序集第一個成員，以 1 表示有序集第二個成員，以此類推
* 你也可以使用負數下標，以 -1 表示最後一個成員，-2 表示倒數第二個成員，以此類推
* <p>
* 超出範圍的下標並不會引起錯誤。如果 start 的值比有序集的最大下標還要大
* 或是 start > stop 時，ZRANGE 命令只是簡單地返回一個空列表
* 另一方面，假如 stop 參數的值比有序集的最大下標還要大，那麼 Redis 將 stop 當作最大下標來處理
* <p>
* 使用 WITHSCORES 選項，來讓成員和它的 score 值一起返回
* 返回列表以v alue1,score1, ..., valueN,scoreN 的格式表示，而不是 value1,...,valueN
* 客戶端庫可能會返回一些更復雜的數據類型，比如數組、元組等
*
* @param key
* @param start
* @param end
* @return 指定範圍的元素列表(以元組集合的形式)。
*/
Set<Tuple> zrangeWithScores(String key, long start, long end);
/**
* 返回有序集key中，指定區間內的成員。其中成員的位置按score值遞減(從大到小)來排列。具有相同score值的成員按字典序的反序排列。
* 除了成員按score值遞減的次序排列這一點外，ZREVRANGE命令的其他方面和ZRANGE命令一樣。
*
* @param key 緩存鍵
* @param start 起始索引
* @param end 結束索引
* @return 指定範圍的元素列表(可選是否含有分數)
*/
Set<Tuple> zrevrangeWithScores(String key, long start, long end);
/**
* 返回 key 的有序集元素個數
*
* @param key 緩存鍵
* @return key存在的時候，返回有序集的元素個數，否則返回0
*/
Long zcard(String key);
/**
* 返回有序集 key 中，成員 member 的 score 值
* 如果 member 元素不是有序集 key 的成員，或 key 不存在，返回nil
*
* @param key 緩存鍵
* @param member 待處理成員
* @return member 成員的 score 值（double 型浮點數）
*/
Double zscore(String key, String member);
/**
* 對一個集合或者一個列表排序
* <p>
* 對集合，有序集合，或者列表的 value 進行排序，默認情況下排序只對數字排序，雙精度浮點數
*
* @param key 緩存鍵
* @return 假設集合或列表包含的是數字元素，那麼返回的將會是從小到大排列的一個列表
* @see #sort(String, String)
* @see #sort(String, SortingParams)
* @see #sort(String, SortingParams, String)
*/
List<String> sort(String key);
/**
* 根據指定參數來對列表或集合進行排序
* <p>
* <b>examples:</b>
* <p>
* 以下是一些例子列表或者key-value:
* <p>
* <pre>
* x = [1, 2, 3]
* y = [a, b, c]
*
* k1 = z
* k2 = y
* k3 = x
*
* w1 = 9
* w2 = 8
* w3 = 7
* </pre>
* <p>
* 排序:
* <p>
* <pre>
* sort(x) or sort(x, sp.asc())
* -> [1, 2, 3]
*
* sort(x, sp.desc())
* -> [3, 2, 1]
*
* sort(y)
* -> [c, a, b]
*
* sort(y, sp.alpha())
* -> [a, b, c]
*
* sort(y, sp.alpha().desc())
* -> [c, b, a]
* </pre>
* <p>
* Limit (e.g. for Pagination):
* <p>
* <pre>
* sort(x, sp.limit(0, 2))
* -> [1, 2]
*
* sort(y, sp.alpha().desc().limit(1, 2))
* -> [b, a]
* </pre>
* <p>
* 使用外部鍵來排序:
* <p>
* <pre>
* sort(x, sb.by(w*))
* -> [3, 2, 1]
*
* sort(x, sb.by(w*).desc())
* -> [1, 2, 3]
* </pre>
* <p>
* Getting external keys:
* <p>
* <pre>
* sort(x, sp.by(w*).get(k*))
* -> [x, y, z]
*
* sort(x, sp.by(w*).get(#).get(k*))
* -> [3, x, 2, y, 1, z]
* </pre>
*
* @param key 緩存鍵
* @param sortingParameters 排序參數
* @return 返回排序列表
* @see #sort(String)
* @see #sort(String, SortingParams, String)
*/
List<String> sort(String key, SortingParams sortingParameters);
/**
* 返回有序集 key 中，score 值在 min 和 max 之間(默認包括 score 值等於 min 或 max )的成員
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @return 指定分數範圍的元素個數
*/
Long zcount(String key, double min, double max);
/**
* 返回有序集 key 中，score 值在 min 和 max 之間(默認包括 score 值等於 min 或 max )的成員
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @return 指定分數範圍的元素個數
*/
Long zcount(String key, String min, String max);
/**
* 返回 key 的有序集合中的分數在 min 和 max 之間的所有元素（包括分數等於 max 或者 min 的元素）
* 元素被認爲是從低分到高分排序的，具有相同分數的元素按字典序排列
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @return 指定分數範圍的元素列表
*/
Set<String> zrangeByScore(String key, double min, double max);
/**
* 返回 key 的有序集合中的分數在 min 和 max 之間的所有元素（包括分數等於 max 或者 min 的元素）
* 元素被認爲是從低分到高分排序的，具有相同分數的元素按字典序排列
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @return 指定分數範圍的元素列表
*/
Set<String> zrangeByScore(String key, String min, String max);
/**
* 返回 key 的有序集合中的分數在 min 和 max 之間的所有元素（包括分數等於 max 或者 min 的元素）
* 元素被認爲是從低分到高分排序的，具有相同分數的元素按字典序排列, 指定返回結果的數量及區間
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @param offset 偏移量
* @param count 數量
* @return 指定分數範圍的元素列表
*/
Set<String> zrangeByScore(String key, double min, double max, int offset, int count);
/**
* 返回 key 的有序集合中的分數在 min 和 max 之間的所有元素（包括分數等於 max 或者 min 的元素）
* 元素被認爲是從低分到高分排序的，具有相同分數的元素按字典序排列, 指定返回結果的數量及區間
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @param offset 偏移量
* @param count 數量
* @return 指定分數範圍的元素列表
*/
Set<String> zrangeByScore(String key, String min, String max, int offset, int count);
/**
* 返回 key 的有序集合中的分數在 min 和 max 之間的所有元素（包括分數等於 max 或者 min 的元素）
* 元素被認爲是從低分到高分排序的，具有相同分數的元素按字典序排列。返回元素和其分數，而不只是元素
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @return 指定分數範圍的元素元組集合
*/
Set<Tuple> zrangeByScoreWithScores(String key, double min, double max);
/**
* 返回 key 的有序集合中的分數在 min 和 max 之間的所有元素（包括分數等於 max 或者 min 的元素）
* 元素被認爲是從低分到高分排序的，指定返回結果的數量及區間，返回元素和其分數，而不只是元素
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @param offset 偏移量
* @param count 數量
* @return 指定分數範圍的元素元組集合
*/
Set<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset, int count);
/**
* 返回 key 的有序集合中的分數在 min 和 max 之間的所有元素（包括分數等於 max 或者 min 的元素）
* 元素被認爲是從低分到高分排序的，指定返回結果的數量及區間，返回元素和其分數，而不只是元素
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @return 指定分數範圍的元素元組集合
*/
Set<Tuple> zrangeByScoreWithScores(String key, String min, String max);
/**
* 返回 key 的有序集合中的分數在 min 和 max 之間的所有元素（包括分數等於 max 或者 min 的元素）
* 元素被認爲是從低分到高分排序的，指定返回結果的數量及區間，返回元素和其分數，而不只是元素
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @param offset 偏移量
* @param count 數量
* @return 指定分數範圍的元素元組集合
*/
Set<Tuple> zrangeByScoreWithScores(String key, String min, String max, int offset, int count);
/**
* 機制與 zrangeByScore 一樣，只是返回結果爲降序排序
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @return 指定分數範圍的元素列表
*/
Set<String> zrevrangeByScore(String key, double max, double min);
/**
* 機制與 zrangeByScore 一樣，只是返回結果爲降序排序
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @return 指定分數範圍的元素列表
*/
Set<String> zrevrangeByScore(String key, String max, String min);
/**
* 機制與 zrangeByScore 一樣，只是返回結果爲降序排序
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @param offset 偏移量
* @param count 數量
* @return 指定分數範圍的元素列表
*/
Set<String> zrevrangeByScore(String key, double max, double min, int offset, int count);
/**
* 機制與 zrangeByScoreWithScores 一樣，只是返回結果爲降序排序
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @return 指定分數範圍的元素元組集合
*/
Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min);
/**
* 機制與 zrangeByScore 一樣，只是返回結果爲降序排序
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @param offset 偏移量
* @param count 數量
* @return 指定分數範圍的元素列表
*/
Set<String> zrevrangeByScore(String key, String max, String min, int offset, int count);
/**
* 機制與 zrangeByScoreWithScores 一樣，只是返回結果爲降序排序
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @return 指定分數範圍的元素元組集合
*/
Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min);
/**
* 機制與 zrangeByScoreWithScores 一樣，只是返回結果爲降序排序
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @param offset 偏移量
* @param count 數量
* @return 指定分數範圍的元素元組集合
*/
Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count);
/**
* 機制與 zrangeByScoreWithScores 一樣，只是返回結果爲降序排序
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @param offset 偏移量
* @param count 數量
* @return 指定分數範圍的元素元組集合
*/
Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count);
/**
* 移除有序集 key 中，指定排名(rank)區間內的所有成員
* 下標參數 start 和 stop 都以 0 爲底，0 處是分數最小的那個元素
* 這些索引也可是負數，表示位移從最高分處開始數
* 例如，-1 是分數最高的元素，-2 是分數第二高的，依次類推
*
* @param key 緩存鍵
* @param start 起始分數
* @param end 結束分數
* @return 被移除成員的數量
*/
Long zremrangeByRank(String key, long start, long end);
/**
* 移除有序集 key 中，所有 score 值介於 start 和 end 之間(包括等於 start 或 end)的成員
* <p>
* 自版本2.1.6開始，score 值等於 start 或 end 的成員也可以不包括在內，語法請參見 ZRANGEBYSCORE 命令
*
* @param key 緩存鍵
* @param start 起始分數
* @param end 結束分數
* @return 刪除的元素的個數
*/
Long zremrangeByScore(String key, double start, double end);
/**
* 移除有序集 key 中，所有 score 值介於 start 和 end 之間(包括等於 start 或 end)的成員
* <p>
* 自版本2.1.6開始，score 值等於 start 或 end 的成員也可以不包括在內，語法請參見 ZRANGEBYSCORE 命令
*
* @param key 緩存鍵
* @param start 起始分數
* @param end 結束分數
* @return 刪除的元素的個數
*/
Long zremrangeByScore(String key, String start, String end);
/**
* 當插入到有序集合中的元素都具有相同的分數時，這個命令可以返回 min 和 max 指定範圍內的元素的數量
*
* @param key 緩存鍵
* @param min 最小分數
* @param max 最大分數
* @return
*/
Long zlexcount(final String key, final String min, final String max);
/**
* 把 value 插入存於 key 的列表中在基準值 pivot 的前面或後面
* 當 key 不存在時，這個 list 會被看作是空 list，任何操作都不會發生
* 當 key 存在，但保存的不是一個 list 的時候，會返回錯誤
*
* @param key 緩存鍵
* @param where 位置
* @param pivot 前或後
* @param value 值
* @return 在 insert 操作後的 list 長度。
*/
Long linsert(String key, Client.LIST_POSITION where, String pivot, String value);
/**
* 只有當 key 已經存在並且存着一個 list 的時候，在這個 key 下面的 list 的頭部插入 value
* 與 LPUSH 相反，當 key 不存在的時候不會進行任何操作
*
* @param key 緩存鍵
* @param string 待處理字符串
* @return 在 push 操作後的 list 長度
*/
Long lpushx(String key, String... string);
/**
* 將值 value 插入到列表 key 的表尾，當且僅當 key 存在並且是一個列表
* 和 RPUSH 命令相反, 當 key 不存在時，RPUSHX 命令什麼也不做
*
* @param key 緩存鍵
* @param string 待處理字符串
* @return 在 push 操作後 list 的長度
*/
Long rpushx(String key, String... string);
/**
* @deprecated 不可用命令，將在 3.0.0 版本中移除
*/
@Deprecated
List<String> blpop(String arg);
/**
* BLPOP 是阻塞式列表的彈出原語
* 它是命令 LPOP 的阻塞版本，這是因爲當給定列表內沒有任何元素可供彈出的時候，
* 連接將被 BLPOP 命令阻塞。 當給定多個 key 參數時，按參數 key 的先後順序依次檢查各個列表，彈出第一個非空列表的頭元素
* {@link http://www.redis.cn/commands/blpop.html}
*
* @param timeout 超時時間
* @param key 緩存鍵
* @return
*/
List<String> blpop(int timeout, String key);
/**
* @deprecated 不可用命令，將在 3.0.0 版本中移除
*/
@Deprecated
List<String> brpop(String arg);
/**
* BRPOP 是一個阻塞的列表彈出原語
* 它是 RPOP 的阻塞版本，因爲這個命令會在給定 list 無法彈出任何元素的時候阻塞連接
* 該命令會按照給出的 key 順序查看 list，並在找到的第一個非空 list 的尾部彈出一個元素
* <p>
* 請在 BLPOP 文檔 中查看該命令的準確語義，因爲 BRPOP 和 BLPOP 基本是完全一樣的，
* 除了它們一個是從尾部彈出元素，而另一個是從頭部彈出元素。
* {@link http://www.redis.cn/commands/brpop.html}
*
* @param timeout 超時時間
* @param key 緩存鍵
* @return
*/
List<String> brpop(int timeout, String key);
/**
* 刪除一個 key,如果刪除的 key 不存在，則直接忽略
*
* @param key 緩存鍵
* @return 被刪除的 key 的數量
*/
Long del(String key);
/**
* 回顯
*
* @param string 輸入字符串
* @return 回顯輸入的字符串
*/
String echo(String string);
/**
* 將當前數據庫的 key 移動到給定的數據庫 db 當中
* <p>
* 如果當前數據庫(源數據庫)和給定數據庫(目標數據庫)有相同名字的給定 key
* 或者 key 不存在於當前數據庫，那麼 MOVE 沒有任何效果
* <p>
* 因此，也可以利用這一特性，將 MOVE 當作鎖原語
*
* @param key 緩存鍵
* @param dbIndex 數據庫索引
* @return 移動成功返回 1 失敗則返回 0
*/
Long move(String key, int dbIndex);
/**
* 統計字符串的字節數
*
* @param key 緩存鍵
* @return 字節數
*/
Long bitcount(final String key);
/**
* 統計字符串指定起始位置的字節數
*
* @param key 緩存鍵
* @param start 起始索引
* @param end 結束索引
* @return
*/
Long bitcount(final String key, long start, long end);
/**
* 迭代 hash 裏面的元素
*
* @param key 緩存鍵
* @param cursor 遊標
* @return
*/
ScanResult<Map.Entry<String, String>> hscan(final String key, final String cursor);
/**
* 迭代 set 裏面的元素
*
* @param key 緩存鍵
* @param cursor 遊標
* @return
*/
ScanResult<String> sscan(final String key, final String cursor);
/**
* 迭代 zset 裏面的元素
*
* @param key 緩存鍵
* @param cursor 遊標
* @return
*/
ScanResult<Tuple> zscan(final String key, final String cursor);
}