JedisCommand接口說明

Sharded 和 Non-Sharded共用的Jedis接口。查找redis官網一個個命令再翻譯，這實在讓人沒法忍受。因此把接口與對應的命令機制翻譯過來了，放在一個類裏。方便查找。

import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 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 
     *            nxxx的值只能取NX或者XX，若是取NX，則只有當key不存在是才進行set，若是取XX，則只有當key已經存在時才進行set
     * 
     * @param expx 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類型的，
     * 則返回一個error。這個方法只能從緩存中取得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。不存在的keys被認爲是空字符串，因此這個命令能夠確保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);

    /**
     * 參考 {@link set(String key, String value, String nxxx, String expx, long
     * time)}
     *
     * @param key
     * @param value
     * @return
     */
    Long setnx(String key, String value);

    /**
     * 參考 {@link set(String key, String value, String nxxx, String expx, long
     * time)}
     *
     * @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對應的值是一個Hash表，則返回對應字段的值。 若是不存在該字段，或者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
     * 保存的不是一個列表，那麼會返回一個錯誤。
     * 
     * 可使用一個命令把多個元素打入隊列，只須要在命令後面指定多個參數。元素是從左到右一個接一個從列表尾部插入。 好比命令 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 的話，那麼會返回一個錯誤。
     * 
     * 可使用一個命令把多個元素 push 進入列表，只需在命令末尾加上多個指定的參數。元素是從最左端的到最右端的、一個接一個被插入到 list
     * 的頭部。 因此對於這個命令例子 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的話，會返回error。
     *
     * @param key
     * @return key對應的list的長度。
     */
    Long llen(String key);

    /**
     * 返回存儲在 key 的列表裏指定範圍內的元素。 start 和 end
     * 偏移量都是基於0的下標，即list的第一個元素下標是0（list的表頭），第二個元素下標是1，以此類推。
     * 
     * 偏移量也能夠是負數，表示偏移量是從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 表示倒數第二個元素，並以此往前推。
     * 
     * 當 key 位置的值不是一個列表的時候，會返回一個error。
     *
     * @param key
     * @param index
     * @return 請求的對應元素，或者當 index 超過範圍的時候返回 nil。
     */
    String lindex(String key, long index);

    /**
     * 設置 index 位置的list元素的值爲 value。
     * 
     * 當index超出範圍時會返回一個error。
     *
     * @param key
     * @param index
     * @param value
     * @return 狀態恢復
     */
    String lset(String key, long index, String value);

    /**
     * 從存於 key 的列表裏移除前 count 次出現的值爲 value 的元素。 這個 count 參數經過下面幾種方式影響這個操做：
     * 
     * count > 0: 從頭往尾移除值爲 value 的元素。 count < 0: 從尾往頭移除值爲 value 的元素。 count = 0:
     * 移除全部值爲 value 的元素。
     * 
     * 好比， LREM list -2 "hello" 會從存於 list 的列表裏移除最後兩個出現的 "hello"。
     * 
     * 須要注意的是，若是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中.
     * 
     * 若是key 的類型不是集合則返回錯誤.
     *
     * @param key
     * @param member
     * @return 返回新成功添加到集合裏元素的數量，不包括已經存在於集合中的元素.
     */
    Long sadd(String key, String... member);

    /**
     * 返回key集合全部的元素.
     * 
     * 該命令的做用與使用一個參數的SINTER 命令做用相同.
     *
     * @param key
     * @return 集合中的全部元素.
     */
    Set<String> smembers(String key);

    /**
     * 在key集合中移除指定的元素. 若是指定的元素不是key集合中的元素則忽略 若是key集合不存在則被視爲一個空的集合，該命令返回0.
     * 
     * 若是key的類型不是一個集合,則返回錯誤.
     *
     * @param key
     * @param member
     * @return 從集合中移除元素的個數，不包括不存在的成員.
     */
    Long srem(String key, String... member);

    /**
     * 移除並返回一個集合中的隨機元素
     * 
     * 該命令與 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.若是member元素不是key的成員，或者集合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存在，可是它並非一個有序集合，那麼就返回一個錯誤。
     * 
     * 分數的值必須是一個表示數字的字符串，而且能夠是double類型的浮點數。
     *
     * @param key
     * @param score
     * @param member
     * @return 返回添加到有序集合中元素的個數，不包括那種已經存在只是更新分數的元素。
     */
    Long zadd(String key, double score, String member);

    /**
     * 該命令添加指定的成員到key對應的有序集合中，每一個成員都有一個分數。你能夠指定多個分數/成員組合。若是一個指定的成員已經在對應的有序集合中了，
     * 那麼其分數就會被更新成最新的
     * ，而且該成員會從新調整到正確的位置，以確保集合有序。若是key不存在，就會建立一個含有這些成員的有序集合，就好像往一個空的集合中添加同樣
     * 。若是key存在，可是它並非一個有序集合，那麼就返回一個錯誤。
     * 
     * 分數的值必須是一個表示數字的字符串，而且能夠是double類型的浮點數。
     *
     * @param key
     * @param scoreMembers
     * @return 返回添加到有序集合中元素的個數，不包括那種已經存在只是更新分數的元素。
     */
    Long zadd(String key, Map<String, Double> scoreMembers);

    /**
     * 返回有序集key中，指定區間內的成員。其中成員按score值遞增(從小到大)來排序。具備相同score值的成員按字典序來排列。
     * 
     * 若是你須要成員按score值遞減(score相等時按字典序遞減)來排列，請使用ZREVRANGE命令。
     * 下標參數start和stop都以0爲底，也就是說，以0表示有序集第一個成員，以1表示有序集第二個成員，以此類推。
     * 你也可使用負數下標，以-1表示最後一個成員，-2表示倒數第二個成員，以此類推。
     * 
     * 超出範圍的下標並不會引發錯誤。若是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不是有序集類型時，返回一個錯誤。
     * 
     * 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。
     * 
     * 使用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。
     * 
     * 使用ZRANK命令能夠得到成員按score值遞增(從小到大)排列的排名。
     *
     * @param key
     * @param member
     * @return 若是member是有序集key的成員，返回member的排名。整型數字。 若是member不是有序集key的成員，返回Bulk
     *         reply: 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值的成員按字典序來排列。
     * 
     * 若是你須要成員按score值遞減(score相等時按字典序遞減)來排列，請使用ZREVRANGE命令。
     * 下標參數start和stop都以0爲底，也就是說，以0表示有序集第一個成員，以1表示有序集第二個成員，以此類推。
     * 你也可使用負數下標，以-1表示最後一個成員，-2表示倒數第二個成員，以此類推。
     * 
     * 超出範圍的下標並不會引發錯誤。若是start的值比有序集的最大下標還要大，或是start >
     * stop時，ZRANGE命令只是簡單地返回一個空列表。
     * 另外一方面，假如stop參數的值比有序集的最大下標還要大，那麼Redis將stop看成最大下標來處理。
     * 
     * 使用WITHSCORES選項，來讓成員和它的score值一併返回，返回列表以value1,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);

    /**
     * 對一個集合或者一個列表排序
     * 
     * 對集合，有序集合，或者列表的value進行排序。默認狀況下排序只對數字排序，雙精度浮點數。
     * 
     * @see #sort(String, String)
     * @see #sort(String, SortingParams)
     * @see #sort(String, SortingParams, String)
     * @param key
     * @return 假設集合或列表包含的是數字元素，那麼返回的將會是從小到大排列的一個列表。
     */
    List<String> sort(String key);

    /**
     * 根據指定參數來對列表或集合進行排序.
     * <p>
     * <b>examples:</b>
     * <p>
     * 一下是一些例子列表或者key-value:
     * 
     * <pre>
     * x = [1, 2, 3]
     * y = [a, b, c]
     * 
     * k1 = z
     * k2 = y
     * k3 = x
     * 
     * w1 = 9
     * w2 = 8
     * w3 = 7
     * </pre>
     * 
     * 排序:
     * 
     * <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>
     * 
     * Limit (e.g. for Pagination):
     * 
     * <pre>
     * sort(x, sp.limit(0, 2))
     * -> [1, 2]
     * 
     * sort(y, sp.alpha().desc().limit(1, 2))
     * -> [b, a]
     * </pre>
     * 
     * 使用外部鍵來排序:
     * 
     * <pre>
     * sort(x, sb.by(w*))
     * -> [3, 2, 1]
     * 
     * sort(x, sb.by(w*).desc())
     * -> [1, 2, 3]
     * </pre>
     * 
     * Getting external keys:
     * 
     * <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>
     * 
     * @see #sort(String)
     * @see #sort(String, SortingParams, String)
     * @param key
     * @param sortingParameters
     * @return a list of sorted elements.
     */
    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 max
     * @param min
     * @return
     */
    Set<String> zrevrangeByScore(String key, double max, double min);

    /**
     * 機制與zrangeByScore同樣，只是返回結果爲降序排序。
     *
     * @param key
     * @param max
     * @param min
     * @return
     */
    Set<String> zrevrangeByScore(String key, String max, String min);

    /**
     * 機制與zrangeByScore同樣，只是返回結果爲降序排序。
     *
     * @param key
     * @param max
     * @param min
     * @param offset
     * @param count
     * @return
     */
    Set<String> zrevrangeByScore(String key, double max, double min, int offset, int count);

    /**
     * 機制與zrangeByScoreWithScores同樣，只是返回結果爲降序排序。
     *
     * @param key
     * @param max
     * @param min
     * @return
     */
    Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min);

    /**
     * 機制與zrangeByScore同樣，只是返回結果爲降序排序。
     *
     * @param key
     * @param max
     * @param min
     * @param offset
     * @param count
     * @return
     */
    Set<String> zrevrangeByScore(String key, String max, String min, int offset, int count);

    /**
     * 機制與zrangeByScoreWithScores同樣，只是返回結果爲降序排序。
     *
     * @param key
     * @param max
     * @param min
     * @return
     */
    Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min);

    /**
     * 機制與zrangeByScoreWithScores同樣，只是返回結果爲降序排序。
     *
     * @param key
     * @param max
     * @param min
     * @param offset
     * @param count
     * @return
     */
    Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, int offset,
            int count);

    /**
     * 機制與zrangeByScoreWithScores同樣，只是返回結果爲降序排序。
     *
     * @param key
     * @param max
     * @param min
     * @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值介於min和max之間(包括等於min或max)的成員。
     * 
     * 自版本2.1.6開始，score值等於min或max的成員也能夠不包括在內，語法請參見ZRANGEBYSCORE命令。
     *
     * @param key
     * @param start
     * @param end
     * @return 刪除的元素的個數
     */
    Long zremrangeByScore(String key, double start, double end);

    /**
     * 移除有序集key中，全部score值介於min和max之間(包括等於min或max)的成員。
     * 
     * 自版本2.1.6開始，score值等於min或max的成員也能夠不包括在內，語法請參見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的時候，會返回error。
     *
     * @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 unusable command, this will be removed in 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 unusable command, this will be removed in 3.0.0.
     */
    @Deprecated
    List<String> brpop(String arg);

    /**
     * BRPOP 是一個阻塞的列表彈出原語。 它是 RPOP 的阻塞版本，由於這個命令會在給定list沒法彈出任何元素的時候阻塞鏈接。
     * 該命令會按照給出的 key 順序查看 list，並在找到的第一個非空 list 的尾部彈出一個元素。
     * 
     * 請在 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 被刪除的keys的數量
     */
    Long del(String key);

    /**
     * 回顯
     *
     * @param string
     * @return 回顯輸入的字符串
     */
    String echo(String string);

    /**
     * 將當前數據庫的 key 移動到給定的數據庫 db 當中。
     * 
     * 若是當前數據庫(源數據庫)和給定數據庫(目標數據庫)有相同名字的給定 key ，或者 key 不存在於當前數據庫，那麼 MOVE 沒有任何效果。
     * 
     * 所以，也能夠利用這一特性，將 MOVE 看成鎖(locking)原語(primitive)。
     *
     * @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);

}