1、 登錄
[root@bigdata1 bin]# ./redis-cli 本機登錄
[root@bigdata1 bin]# ./redis-cli -h 127.0.0.1 -p 6379 –a password 遠程登錄
127.0.0.1:6379> quit 退出
2、 數據類型
Redis支持五種數據類型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。
String（字符串）：string是redis最基本的類型，你可以理解成與Memcached一模一樣的類型，一個key對應一個value。
string類型是二進制安全的。意思是redis的string可以包含任何數據。比如jpg圖片或者序列化的對象 。
String類型是Redis最基本的數據類型，一個鍵最大能存儲512MB。
Hash（哈希）：
Redis hash 是一個鍵值(key=>value)對集合。
Redis hash是一個string類型的field和value的映射表，hash特別適合用於存儲對象。
每個 hash 可以存儲 232 -1 鍵值對（40多億）。
List（列表）：
Redis 列表是簡單的字符串列表，按照插入順序排序。你可以添加一個元素到列表的頭部（左邊）或者尾部（右邊）。
列表最多可存儲 232 - 1 元素 (4294967295, 每個列表可存儲40多億)。
Set（集合）：
Redis的Set是string類型的無序集合。
集合是通過哈希表實現的，所以添加，刪除，查找的復雜度都是O(1)。
Zset（有序集合）：
Redis zset 和 set 一樣也是string類型元素的集合,且不允許重復的成員。
不同的是每個元素都會關聯一個double類型的分數。redis正是通過分數來為集合中的成員進行從小到大的排序。
zset的成員是唯一的,但分數(score)卻可以重復。
3、 命令介紹
String（字符串）：
127.0.0.1:6379> SET key "value" 設置key
127.0.0.1:6379> GET key 讀取key
127.0.0.1:6379> GETRANGE key 0 3 讀取key對應的value前四個字符
127.0.0.1:6379>GETSET db mongodb 設定key的value，並返回舊value，沒有舊值，返回nil
127.0.0.1:6379> MGET key1 key2 返回一個或者多個給定的key值
Hash（哈希）：
127.0.0.1:6379> HMSET myhash field1 "Hello" field2 "World" 同時將多個 field-value (字段-值)對設置到哈希表中。
127.0.0.1:6379> HGET KEY_NAME FIELD_NAME 用於返回哈希表中指定字段的值
127.0.0.1:6379> HEXISTS myhash field1 哈希表含有給定字段，返回 1 。 如果哈希表不含有給定字段，或 key 不存在，返回 0
127.0.0.1:6379> HKEYS myhash 獲取哈希表中的所有域（field）
List（列表）：
127.0.0.1:6379> LPUSH KEY_NAME VALUE1.. VALUEN 將一個或多個值插入到列表頭部
127.0.0.1:6379> LRANGE list1 0 -1 返回列表中指定區間內的元素
Set（集合）：
127.0.0.1:6379> SADD myset "hello" 命令將一個或多個成員元素加入到集合中，已經存在於集合的成員元素將被忽略。
127.0.0.1:6379> SMEMBERS myset1 返回集合中的所有的成員。 不存在的集合 key 被視為空集合。
Zset（有序集合）：
127.0.0.1:6379>ZADD myzset 2 "two" 3 "three" 用於將一個或多個成員元素及其分數值加入到有序集當中。
127.0.0.1:6379>ZCARD myzset 獲取結合中元素的數量。
4、 封裝的redis基本命令
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import redis.clients.jedis.BinaryClient;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.JedisCluster;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class redisCluster {
private static final Log log = LogFactory.getLog(redisCluster.class);
JedisCluster jedisCluster=null;
ClassPathXmlApplicationContext context=null;
/**
* 構造函數，初始化jedis連接池
*/
public redisCluster(){
try{
context = new ClassPathXmlApplicationContext("classpath:spring/spring-context.xml");
context.start();
jedisCluster = (JedisCluster) context.getBean("jedisCluster");
}
catch(Exception e){
log.error("==>redisCluster context start error:", e);
context.stop();
System.exit(0);
}
}
/**
* 關閉連接
*/
public void closeRedisCluster(){
jedisCluster.close();
}
//Key(鍵)
/**
* 刪除指定的key
* @param key
* @return 刪除的數量
*/
public Long delete(String key){
return jedisCluster.del(key);
}
/**
* 檢查指定的key是否存在
* @param key
* @return 存在：返回1 不存在：返回0
*/
public Boolean exists(String key){
return jedisCluster.exists(key);
}
/**
* 為給定 key 設置生存時間，當 key 過期時(生存時間為 0 )，它會被自動刪除
* 可以對一個已經帶有生存時間的 key 執行 EXPIRE 命令，新指定的生存時間會取代舊的生存時間
* @param key
* @param seconds 秒
* @return 成功:返回1 失敗：返回0
*/
public Long expire(String key,int seconds){
return jedisCluster.expire(key, seconds);
}
/**
* EXPIREAT 的作用和 EXPIRE 類似，都用於為 key 設置生存時間
* 不同在於 EXPIREAT 命令接受的時間參數是 UNIX 時間戳(unix timestamp)
* @param key
* @param unixTime 秒
* @return 成功:返回1 失敗：返回0
*/
public long expireAt(String key,long unixTime){
return jedisCluster.expireAt(key, unixTime);
}
/**
* 將當前數據庫的 key 移動到給定的數據庫 db 當中
* 如果當前數據庫(源數據庫)和給定數據庫(目標數據庫)有相同名字的給定 key ，或者 key 不存在於當前數據庫，那么 MOVE 沒有任何效果
* @param key
* @param dbIndex
* @return 成功：返回1 失敗：返回0
*/
public Long move(String key,int dbIndex){
return jedisCluster.move(key, dbIndex);
}
/**
* 移除給定 key 的生存時間，將這個 key 從『易失的』(帶生存時間 key )轉換成『持久的』(一個不帶生存時間、永不過期的 key )
* @param key
* @return 成功：返回1 失敗：返回0
*/
public long persist(String key){
return jedisCluster.persist(key);
}
/**
* 為給定 key 設置生存時間，當 key 過期時(生存時間為 0 )，它會被自動刪除
* 可以對一個已經帶有生存時間的 key 執行 EXPIRE 命令，新指定的生存時間會取代舊的生存時間
* @param key
* @param seconds 毫秒
* @return 成功:返回1 失敗：返回0
*/
public long pexpire(String key,long milliseconds){
return jedisCluster.pexpire(key, milliseconds);
}
/**
* EXPIREAT 的作用和 EXPIRE 類似，都用於為 key 設置生存時間
* 不同在於 EXPIREAT 命令接受的時間參數是 UNIX 時間戳(unix timestamp)
* @param key
* @param unixTime 毫秒
* @return 成功:返回1 失敗：返回0
*/
public long pexpireAt(String key,long millisecondsTimestamp){
return jedisCluster.pexpireAt(key, millisecondsTimestamp);
}
/**
* 返回或保存給定列表、集合、有序集合 key 中經過排序的元素
* 排序默認以數字作為對象，值被解釋為雙精度浮點數，然后進行比較
* @param key
* @return
*/
public List<String> sort(String key){
return jedisCluster.sort(key);
}
/**
* 以秒為單位，返回給定 key 的剩余生存時間(TTL, time to live)
* @param key
* @return key不存在：返回-2 key存在但沒有設置生存時間：返回-1
*/
public long ttl(String key){
return jedisCluster.ttl(key);
}
/**
* 返回 key 所儲存的值的類型
* @param key
* @return none (key不存在) string (字符串) list (列表) set (集合) zset (有序集) hash (哈希表)
*/
public String type(String key){
return jedisCluster.type(key);
}
//String(字符串)
/**
* 如果 key 已經存在並且是一個字符串， APPEND 命令將 value 追加到 key 原來的值的末尾
* 如果 key 不存在， APPEND 就簡單地將給定 key 設為 value ，就像執行 SET key value 一樣
* @param key
* @param value
* @return 追加 value 之后， key 中字符串的長度
*/
public Long append(String key,String value){
return jedisCluster.append(key, value);
}
/**
* 計算給定字符串中，被設置為 1 的比特位的數量
* @param key
* @return 被設置為 1 的位的數量
*/
public Long bitCount(String key){
return jedisCluster.bitcount(key);
}
/**
* 通過指定額外的 start 或 end 參數，可以讓計數只在特定的位上進行
* @param key
* @param start
* @param end
* @return 被設置為 1 的位的數量
*/
public Long bitCount(String key,Long start,Long end){
return jedisCluster.bitcount(key, start, end);
}
/**
* 將 key 中儲存的數字值減一
* 如果 key 不存在，那么 key 的值會先被初始化為 0 ，然后再執行 DECR 操作
* 如果值包含錯誤的類型，或字符串類型的值不能表示為數字，那么返回一個錯誤
* @param key
* @return 執行 DECR 命令之后 key 的值
*/
public Long decr(String key){
return jedisCluster.decr(key);
}
/**
* 將 key 所儲存的值減去減量 decrement
* 如果 key 不存在，那么 key 的值會先被初始化為 0 ，然后再執行 DECRBY 操作
* 如果值包含錯誤的類型，或字符串類型的值不能表示為數字，那么返回一個錯誤
* @param key
* @param integer
* @return 減去 decrement 之后， key 的值
*/
public Long decrBy(String key,long integer){
return jedisCluster.decrBy(key, integer);
}
/**
* 返回 key 所關聯的字符串值
* 如果 key 不存在那么返回特殊值 nil
* 假如 key 儲存的值不是字符串類型，返回一個錯誤，因為 GET 只能用於處理字符串值
* @param key
* @return 當 key 不存在時，返回 nil ，否則，返回 key 的值,如果 key 不是字符串類型，那么返回一個錯誤
*/
public String get(String key){
return jedisCluster.get(key);
}
/**
* 對 key 所儲存的字符串值，獲取指定偏移量上的位(bit)
* 當 offset 比字符串值的長度大，或者 key 不存在時，返回 0
* @param key
* @param offset
* @return 字符串值指定偏移量上的位(bit)
*/
public Boolean getbit(String key,Long offset){
return jedisCluster.getbit(key, offset);
}
/**
* 返回 key 中字符串值的子字符串，字符串的截取范圍由 start 和 end 兩個偏移量決定(包括 start 和 end 在內)
* 負數偏移量表示從字符串最后開始計數， -1 表示最后一個字符， -2 表示倒數第二個，以此類推。
* @param key
* @param startOffset
* @param endOffset
* @return 截取得出的子字符串
*/
public String getrange(String key,long startOffset,long endOffset){
return jedisCluster.getrange(key, startOffset, endOffset);
}
/**
* 將給定 key 的值設為 value ，並返回 key 的舊值(old value)
* 當 key 存在但不是字符串類型時，返回一個錯誤
* @param key
* @param value
* @return 返回給定 key 的舊值,當 key 沒有舊值時，也即是， key 不存在時，返回 nil
*/
public String getSet(String key,String value){
return jedisCluster.getSet(key, value);
}
/**
* 將 key 中儲存的數字值增一
* 如果 key 不存在，那么 key 的值會先被初始化為 0 ，然后再執行 INCR 操作
* 如果值包含錯誤的類型，或字符串類型的值不能表示為數字，那么返回一個錯誤
* @param key
* @return 執行 INCR 命令之后 key 的值
*/
public Long incr(String key){
return jedisCluster.incr(key);
}
/**
* 將 key 所儲存的值加上增量 increment
* 如果 key 不存在，那么 key 的值會先被初始化為 0 ，然后再執行 INCRBY 命令
* 如果值包含錯誤的類型，或字符串類型的值不能表示為數字，那么返回一個錯誤
* @param key
* @param integer
* @return 加上 increment 之后， key 的值
*/
public Long incrBy(String key,long integer){
return jedisCluster.incrBy(key, integer);
}
/**
* 為 key 中所儲存的值加上浮點數增量 increment
* 如果 key 不存在，那么 INCRBYFLOAT 會先將 key 的值設為 0 ，再執行加法操作
* 如果命令執行成功，那么 key 的值會被更新為（執行加法之后的）新值，並且新值會以字符串的形式返回給調用者
* @param key
* @param value
* @return 執行命令之后 key 的值
*/
public double incrByFloat(String key,double value){
return jedisCluster.incrByFloat(key, value);
}
/**
* 將字符串值 value 關聯到 key
* 如果 key 已經持有其他值， SET 就覆寫舊值，無視類型
* @param key
* @param value
* @return 返回ok
*/
public String set(String key,String value){
return jedisCluster.set(key, value);
}
/**
* 對 key 所儲存的字符串值，設置或清除指定偏移量上的位(bit)
* 位的設置或清除取決於 value 參數，可以是 0 也可以是 1
* 當 key 不存在時，自動生成一個新的字符串值
* @param key
* @param offset
* @param value
* @return 指定偏移量原來儲存的位
*/
public Boolean setbit(String key,Long offset,String value){
return jedisCluster.setbit(key, offset, value);
}
/**
* 對 key 所儲存的字符串值，設置或清除指定偏移量上的位(bit)
* 位的設置或清除取決於 value 參數，可以是 0 也可以是 1
* 當 key 不存在時，自動生成一個新的字符串值
* @param key
* @param offset
* @param value
* @return 指定偏移量原來儲存的位
*/
public Boolean setbit(String key,long offset,Boolean value){
return jedisCluster.setbit(key, offset, value);
}
/**
* 將值 value 關聯到 key ，並將 key 的生存時間設為 seconds (以秒為單位)
* 如果 key 已經存在， SETEX 命令將覆寫舊值
* @param key
* @param seconds
* @param value
* @return 設置成功時返回 OK ,當 seconds 參數不合法時，返回一個錯誤
*/
public String setex(String key,int seconds,String value){
return jedisCluster.setex(key, seconds, value);
}
/**
* 將 key 的值設為 value ，當且僅當 key 不存在
* 若給定的 key 已經存在，則 SETNX 不做任何動作
* @param key
* @param value
* @return 設置成功，返回 1,設置失敗，返回 0
*/
public Long setnx(String key,String value){
return jedisCluster.setnx(key, value);
}
/**
* 用 value 參數覆寫(overwrite)給定 key 所儲存的字符串值，從偏移量 offset 開始
* 不存在的 key 當作空白字符串處理
* @param key
* @param offset
* @param value
* @return 被 SETRANGE 修改之后，字符串的長度
*/
public Long setrange(String key,Long offset,String value){
return jedisCluster.setrange(key, offset, value);
}
/**
* 返回 key 所儲存的字符串值的長度
* 當 key 儲存的不是字符串值時，返回一個錯誤
* @param key
* @return 字符串值的長度,當 key 不存在時，返回 0
*/
public Long strlen(String key){
return jedisCluster.strlen(key);
}
//Hash(哈希表)
/**
* 刪除哈希表 key 中的一個或多個指定域，不存在的域將被忽略
* @param key
* @param fields 格式為：field,field,field....
* @return 被成功移除的域的數量，不包括被忽略的域
*/
public Long hdel(String key,String fields){
return jedisCluster.hdel(key,fields);
}
/**
* 查看哈希表 key 中，給定域 field 是否存在
* @param key
* @param field
* @return 如果哈希表含有給定域，返回 1,如果哈希表不含有給定域，或 key 不存在，返回 0
*/
public Boolean hexists(String key,String field){
return jedisCluster.hexists(key, field);
}
/**
* 返回哈希表 key 中給定域 field 的值
* @param key
* @param field
* @return 給定域的值,當給定域不存在或是給定 key 不存在時，返回 nil
*/
public String hget(String key,String field){
return jedisCluster.hget(key, field);
}
/**
* 返回哈希表 key 中，所有的域和值
* 在返回值里，緊跟每個域名(field name)之后是域的值(value)，所以返回值的長度是哈希表大小的兩倍
* @param key
* @return 以列表形式返回哈希表的域和域的值,若 key 不存在，返回空列表
*/
public Map<String,String> hgetAll(String key){
return jedisCluster.hgetAll(key);
}
/**
* 為哈希表 key 中的域 field 的值加上增量 increment
* 增量也可以為負數，相當於對給定域進行減法操作
* 如果 key 不存在，一個新的哈希表被創建並執行 HINCRBY 命令
* 如果域 field 不存在，那么在執行命令前，域的值被初始化為 0
* 對一個儲存字符串值的域 field 執行 HINCRBY 命令將造成一個錯誤
* @param key
* @param field
* @param value
* @return 執行 HINCRBY 命令之后，哈希表 key 中域 field 的值
*/
public Long hincrBy(String key,String field,long value){
return jedisCluster.hincrBy(key, field, value);
}
/**
* 返回哈希表 key 中的所有域
* @param key
* @return 一個包含哈希表中所有域的表,當 key 不存在時，返回一個空表
*/
public Set<String> hkeys(String key){
return jedisCluster.hkeys(key);
}
/**
* 返回哈希表 key 中域的數量
* @param key
* @return 哈希表中域的數量,當 key 不存在時，返回 0
*/
public Long hlen(String key){
return jedisCluster.hlen(key);
}
/**
* 返回哈希表 key 中，一個或多個給定域的值
* 如果給定的域不存在於哈希表，那么返回一個 nil 值
* 因為不存在的 key 被當作一個空哈希表來處理，所以對一個不存在的 key 進行 HMGET 操作將返回一個只帶有 nil 值的表
* @param key
* @param fields 格式為：field,field,field........
* @return 一個包含多個給定域的關聯值的表，表值的排列順序和給定域參數的請求順序一樣
*/
public List<String> hmget(String key,String fields){
return jedisCluster.hmget(key, fields);
}
/**
* 同時將多個 field-value (域-值)對設置到哈希表 key 中
* 此命令會覆蓋哈希表中已存在的域
* 如果 key 不存在，一個空哈希表被創建並執行 HMSET 操作
* @param key
* @param fieldValues field,value,field,value....
* @return 如果命令執行成功，返回 OK ,當 key 不是哈希表(hash)類型時，返回一個錯誤
*/
public String hmset(String key,String fieldValues){
String[] fieldValue=fieldValues.split(",");
Map<String,String> map=new HashMap<String,String>();
for(int i=0;i<fieldValue.length;i++){
map.put(fieldValue[i],fieldValue[i+1]);
}
return jedisCluster.hmset(key,map);
}
/**
* 將哈希表 key 中的域 field 的值設為 value
* 如果 key 不存在，一個新的哈希表被創建並進行 HSET 操作
* 如果域 field 已經存在於哈希表中，舊值將被覆蓋
* @param key
* @param field
* @param value
* @return 如果 field 是哈希表中的一個新建域，並且值設置成功，返回 1,如果哈希表中域 field 已經存在且舊值已被新值覆蓋，返回 0
*/
public Long hset(String key,String field,String value){
return jedisCluster.hset(key, field, value);
}
/**
* 將哈希表 key 中的域 field 的值設置為 value ，當且僅當域 field 不存在
* 若域 field 已經存在，該操作無效
* 如果 key 不存在，一個新哈希表被創建並執行 HSETNX 命令
* @param key
* @param field
* @param value
* @return 設置成功，返回 1 ,如果給定域已經存在且沒有操作被執行，返回 0
*/
public Long hsetnx(String key,String field,String value){
return jedisCluster.hsetnx(key, field, value);
}
/**
* 返回哈希表 key 中所有域的值
* @param key
* @return 一個包含哈希表中所有值的表,當 key 不存在時，返回一個空表
*/
public List<String> hvals(String key){
return jedisCluster.hvals(key);
}
//List(列表)
/**
* LPOP 命令的阻塞版本，當給定列表內沒有任何元素可供彈出的時候，連接將被 BLPOP 命令阻塞，直到等待超時或發現可彈出元素為止
* @param timeout 超時時間，設置為0 表示無限制等待
* @param key
* @return
*/
public String blpop(int timeout,String key){
List<String> value=jedisCluster.blpop(timeout, key);
return value.get(0);
}
/**
* RPOP 命令的阻塞版本，當給定列表內沒有任何元素可供彈出的時候，連接將被 BLPOP 命令阻塞，直到等待超時或發現可彈出元素為止
* @param timeout 超時時間，設置為0 表示無限制等待
* @param key
* @return
*/
public String brpop(int timeout,String key){
List<String> value=jedisCluster.brpop(timeout, key);
return value.get(0);
}
/**
* 返回列表 key 中，下標為 index 的元素。
*下標(index)參數 start 和 stop 都以 0 為底，也就是說，以 0 表示列表的第一個元素，以 1 表示列表的第二個元素，以此類推
*你也可以使用負數下標，以 -1 表示列表的最后一個元素， -2 表示列表的倒數第二個元素，以此類推
*如果 key 不是列表類型，返回一個錯誤
* @param key
* @param index
* @return
*/
public String lindex(String key,long index){
return jedisCluster.lindex(key, index);
}
/**
* 將值 value 插入到列表 key 當中，位於值 pivot 之前或之后
* 當 pivot 不存在於列表 key 時，不執行任何操作
* 當 key 不存在時， key 被視為空列表，不執行任何操作
* 如果 key 不是列表類型，返回一個錯誤
* @param key
* @param where 值為BEFORE或者AFTER
* @param pivot
* @param value
* @return 成功：返回list長度 無pivot：返回-1 key不存在或者空列表：返回0 where輸入錯誤：返回-2
*/
public long linsert(String key,String where,String pivot,String value){
long result=-2;
if(where.toUpperCase()=="BEFORE"){
result=jedisCluster.linsert(key,LIST_POSITION.BEFORE, pivot, value);
}
else if(where.toUpperCase()=="AFTER"){
result=jedisCluster.linsert(key,LIST_POSITION.AFTER, pivot, value);
}
return result;
}
/**
* 返回列表 key 的長度
* 如果 key 不存在，則 key 被解釋為一個空列表，返回 0
* 如果 key 不是列表類型，返回一個錯誤
* @param key
* @return
*/
public long llen(String key){
return jedisCluster.llen(key);
}
/**
* 移除並返回列表 key 的頭元素
* @param key
* @return
*/
public String lpop(String key){
return jedisCluster.lpop(key);
}
/**
* 將一個或多個值 value 插入到列表 key 的表頭
* 如果 key 不存在，一個空列表會被創建並執行 LPUSH 操作
* 當 key 存在但不是列表類型時，返回一個錯誤
* @param key
* @param values 要插入的value的組合，格式為：value,value,......
* @return 列表長度
*/
public long lpush(String key,String values){
return jedisCluster.lpush(key,values);
}
/**
* 將值 value 插入到列表 key 的表頭
* @param key
* @param value
* @return 列表長度
*/
public long lpushx(String key,String value){
return jedisCluster.lpushx(key, value);
}
/**
* 返回列表 key 中指定區間內的元素，區間以偏移量 start 和 stop 指定
* 下標(index)參數 start 和 stop 都以 0 為底，也就是說，以 0 表示列表的第一個元素，以 1 表示列表的第二個元素，以此類推
* 你也可以使用負數下標，以 -1 表示列表的最后一個元素， -2 表示列表的倒數第二個元素，以此類推。
* @param key
* @param start
* @param stop
* @return
*/
public List<String> lrange(String key,long start,long stop){
return jedisCluster.lrange(key, start, stop);
}
/**
* count > 0 : 從表頭開始向表尾搜索，移除與 value 相等的元素，數量為 count
* count < 0 : 從表尾開始向表頭搜索，移除與 value 相等的元素，數量為 count 的絕對值
* count = 0 : 移除表中所有與 value 相等的值
* @param key
* @param count
* @param value
* @return 被移除元素的數量
*/
public long lrem(String key,long count,String value){
return jedisCluster.lrem(key, count, value);
}
/**
* 將列表 key 下標為 index 的元素的值設置為 value
* 當 index 參數超出范圍，或對一個空列表( key 不存在)進行 LSET 時，返回一個錯誤
* @param key
* @param index
* @param value
* @return
*/
public String lset(String key,long index,String value){
return jedisCluster.lset(key, index, value);
}
/**
* 對一個列表進行修剪(trim)，就是說，讓列表只保留指定區間內的元素，不在指定區間之內的元素都將被刪除
* @param key
* @param start
* @param end
* @return 成功返回OK
*/
public String ltrim(String key,long start,long end){
return jedisCluster.ltrim(key, start, end);
}
/**
* 移除並返回列表 key 的尾元素
* 當 key 不存在時，返回 nil
* @param key
* @return
*/
public String rpop(String key){
return jedisCluster.rpop(key);
}
/**
* 將一個或多個值 value 插入到列表 key 的表尾
* 如果 key 不存在，一個空列表會被創建並執行 RPUSH 操作
* 當 key 存在但不是列表類型時，返回一個錯誤
* @param key
* @param values 要插入的value的組合，格式為：value,value,......
* @return 列表長度
*/
public long rpush(String key,String values){
return jedisCluster.rpush(key,values);
}
/**
* 將值 value 插入到列表 key 的表尾
* @param key
* @param value
* @return 列表長度
*/
public long rpushx(String key,String value){
return jedisCluster.rpushx(key, value);
}
//Set(集合)
/**
* 將一個或多個 member 元素加入到集合 key 當中，已經存在於集合的 member 元素將被忽略
* 假如 key 不存在，則創建一個只包含 member 元素作成員的集合
* 當 key 不是集合類型時，返回一個錯誤
* @param key
* @param members 格式為：member,member,.......
* @return 被添加到集合中的新元素的數量，不包括被忽略的元素
*/
public long sadd(String key,String members){
return jedisCluster.sadd(key, members);
}
/**
* 返回集合 key 的基數(集合中元素的數量)
* @param key
* @return 集合的基數,當 key 不存在時，返回 0
*/
public long scard(String key){
return jedisCluster.scard(key);
}
/**
* 判斷 member 元素是否集合 key 的成員
* @param key
* @param member
* @return 如果 member 元素是集合的成員，返回 1,如果 member 元素不是集合的成員，或 key 不存在，返回 0
*/
public Boolean sismember(String key,String member){
return jedisCluster.sismember(key, member);
}
/**
* 返回集合 key 中的所有成員,不存在的 key 被視為空集合
* @param key
* @return 集合中的所有成員
*/
public Set<String> smembers(String key){
return jedisCluster.smembers(key);
}
/**
* 移除並返回集合中的一個隨機元素
* @param key
* @return 被移除的隨機元素,當 key 不存在或 key 是空集時，返回 nil
*/
public String spop(String key){
return jedisCluster.spop(key);
}
/**
* 移除並返回集合中的一個隨機元素
* @param key
* @return 被移除的隨機元素,當 key 不存在或 key 是空集時，返回 nil
*/
public Set<String> spop(String key,long count){
return jedisCluster.spop(key, count);
}
/**
* 只提供了 key 參數，那么返回集合中的一個隨機元素, 不做刪除
* @param key
* @return 返回一個元素；如果集合為空，返回 nil
*/
public String srandMember(String key){
return jedisCluster.srandmember(key);
}
/**
* 如果 count 為正數，且小於集合基數，那么命令返回一個包含 count 個元素的數組，數組中的元素各不相同。如果 count 大於等於集合基數，那么返回整個集合
* 如果 count 為負數，那么命令返回一個數組，數組中的元素可能會重復出現多次，而數組的長度為 count 的絕對值
* @param key
* @param count
* @return 返回一個數組；如果集合為空，返回空數組
*/
public List<String> srandMember(String key,int count){
return jedisCluster.srandmember(key, count);
}
/**
* 返回一個數組；如果集合為空，返回空數組
* @param key
* @param members 格式為：member,member,......
* @return 被成功移除的元素的數量，不包括被忽略的元素
*/
public long srem(String key,String members){
return jedisCluster.srem(key, members);
}
//SortedSet(有序集合)
/**
* 將一個member 元素及其 score 值加入到有序集 key 當中
* 如果某個 member 已經是有序集的成員，那么更新這個 member 的 score 值，並通過重新插入這個 member 元素，來保證該 member 在正確的位置上
* @param key
* @param score
* @param member
* @return 被成功添加的新成員的數量，不包括那些被更新的、已經存在的成員
*/
public long zadd(String key,double score,String member){
return jedisCluster.zadd(key, score, member);
}
/**
* 將一個或多個 member 元素及其 score 值加入到有序集 key 當中
* 如果某個 member 已經是有序集的成員，那么更新這個 member 的 score 值，並通過重新插入這個 member 元素，來保證該 member 在正確的位置上
* @param key
* @param scoreMembers 格式為：member,score,member,score,......
* @return 被成功添加的新成員的數量，不包括那些被更新的、已經存在的成員
*/
public long zadd(String key,String scoreMembers){
String[] scoreMember=scoreMembers.split(",");
Map<String,Double> map=new HashMap<String,Double>();
for(int i=0;i<scoreMember.length;i++){
map.put(scoreMember[i],Double.valueOf(scoreMember[i+1]));
}
return jedisCluster.zadd(key, map);
}
/**
* 返回有序集 key 的基數
* @param key
* @return 當 key 存在且是有序集類型時，返回有序集的基數,當 key 不存在時，返回 0
*/
public long zcard(String key){
return jedisCluster.zcard(key);
}
/**
* 返回有序集 key 中， score 值在 min 和 max 之間(默認包括 score 值等於 min 或 max )的成員的數量
* @param key
* @param min
* @param max
* @return score 值在 min 和 max 之間的成員的數量
*/
public long zcount(String key,double min,double max){
return jedisCluster.zcount(key, min, max);
}
/**
* 為有序集 key 的成員 member 的 score 值加上增量 increment
* 可以通過傳遞一個負數值 increment ，讓 score 減去相應的值，比如 ZINCRBY key -5 member ，就是讓 member 的 score 值減去 5
* 當 key 不存在，或 member 不是 key 的成員時， ZINCRBY key increment member 等同於 ZADD key increment member
* 當 key 不是有序集類型時，返回一個錯誤
* @param key
* @param score
* @param member
* @return member 成員的新 score 值
*/
public double zincrby(String key,double increment,String member){
return jedisCluster.zincrby(key, increment, member);
}
/**
* 返回有序集 key 中，指定區間內的成員,其中成員的位置按 score 值遞增(從小到大)來排序
* 具有相同 score 值的成員按字典序(lexicographical order )來排列
* 下標參數 start 和 stop 都以 0 為底，也就是說，以 0 表示有序集第一個成員，以 1 表示有序集第二個成員，以此類推。
* 你也可以使用負數下標，以 -1 表示最后一個成員， -2 表示倒數第二個成員，以此類推
* @param key
* @param start
* @param end
* @return 指定區間內，帶有 score 值(可選)的有序集成員的列表
*/
public Set<String> zrange(String key,long start,long end){
return jedisCluster.zrange(key, start, end);
}
/**
* 返回有序集 key 中，所有 score 值介於 min 和 max 之間(包括等於 min 或 max )的成員。有序集成員按 score 值遞增(從小到大)次序排列
* @param key
* @param min
* @param max
* @return 指定區間內，帶有 score 值(可選)的有序集成員的列表
*/
public Set<String> zrangeByScore(String key,String min,String max){
return jedisCluster.zrangeByScore(key, min, max);
}
/**
* 返回有序集 key 中，所有 score 值介於 min 和 max 之間(包括等於 min 或 max )的成員。有序集成員按 score 值遞增(從小到大)次序排列
* @param key
* @param min
* @param max
* @return 指定區間內，帶有 score 值(可選)的有序集成員的列表
*/
public Set<String> zrangeByScore(String key,double min,double max){
return jedisCluster.zrangeByScore(key, min, max);
}
/**
* 返回有序集 key 中，所有 score 值介於 min 和 max 之間(包括等於 min 或 max )的成員。有序集成員按 score 值遞增(從小到大)次序排列
* 可選的 LIMIT 參數指定返回結果的數量及區間(就像SQL中的 SELECT LIMIT offset, count )，注意當 offset 很大時，定位 offset 的操作可能需要遍歷整個有序集，此過程最壞復雜度為 O(N) 時間
* @param key
* @param min
* @param max
* @return 指定區間內，帶有 score 值(可選)的有序集成員的列表
*/
public Set<String> zrangeByScore(String key,String min,String max,int offset,int count){
return jedisCluster.zrangeByScore(key, min, max, offset, count);
}
/**
* 返回有序集 key 中，所有 score 值介於 min 和 max 之間(包括等於 min 或 max )的成員。有序集成員按 score 值遞增(從小到大)次序排列
* 可選的 LIMIT 參數指定返回結果的數量及區間(就像SQL中的 SELECT LIMIT offset, count )，注意當 offset 很大時，定位 offset 的操作可能需要遍歷整個有序集，此過程最壞復雜度為 O(N) 時間
* @param key
* @param min
* @param max
* @return 指定區間內，帶有 score 值(可選)的有序集成員的列表
*/
public Set<String> zrangeByScore(String key,double min,double max,int offset,int count){
return jedisCluster.zrangeByScore(key, min, max, offset, count);
}
/**
* 返回有序集 key 中成員 member 的排名。其中有序集成員按 score 值遞增(從小到大)順序排列
* 排名以 0 為底，也就是說， score 值最小的成員排名為 0
* @param key
* @param member
* @return
*/
public long zrank(String key,String member){
return jedisCluster.zrank(key, member);
}
/**
* 移除有序集 key 中的一個或多個成員，不存在的成員將被忽略
* 當 key 存在但不是有序集類型時，返回一個錯誤
* @param key
* @param members 格式為：member,member,......
* @return 被成功移除的成員的數量，不包括被忽略的成員
*/
public long zrem(String key,String members){
return jedisCluster.zrem(key, members);
}
/**
* 移除有序集 key 中，指定排名(rank)區間內的所有成員
* 區間分別以下標參數 start 和 stop 指出，包含 start 和 stop 在內
* @param key
* @param start
* @param end
* @return 被移除成員的數量
*/
public long zremRangeByRank(String key,long start,long end){
return jedisCluster.zremrangeByRank(key, start, end);
}
/**
* 移除有序集 key 中，所有 score 值介於 min 和 max 之間(包括等於 min 或 max )的成員。
* @param key
* @param start
* @param end
* @return 被移除成員的數量
*/
public long zremRangeByScore(String key,String start,String end){
return jedisCluster.zremrangeByScore(key, start, end);
}
/**
* 移除有序集 key 中，所有 score 值介於 min 和 max 之間(包括等於 min 或 max )的成員。
* @param key
* @param start
* @param end
* @return 被移除成員的數量
*/
public long zremRangeByScore(String key,double start,double end){
return jedisCluster.zremrangeByScore(key, start, end);
}
/**
* 返回有序集 key 中，指定區間內的成員
* 其中成員的位置按 score 值遞減(從大到小)來排列
* @param key
* @param start
* @param end
* @return 指定區間內，帶有 score 值(可選)的有序集成員的列表
*/
public Set<String> zrevRange(String key,long start,long end){
return jedisCluster.zrevrange(key, start, end);
}
/**
* 返回有序集 key 中，所有 score 值介於 max 和 min 之間(包括等於 max 或 min )的成員。有序集成員按 score 值遞減(從大到小)次序排列
* @param key
* @param min
* @param max
* @return 指定區間內，帶有 score 值(可選)的有序集成員的列表
*/
public Set<String> zrevrangeByScore(String key,String max,String min){
return jedisCluster.zrevrangeByScore(key, max, min);
}
/**
* 返回有序集 key 中，所有 score 值介於 max 和 min 之間(包括等於 max 或 min )的成員。有序集成員按 score 值遞減(從大到小)次序排列
* @param key
* @param min
* @param max
* @return 指定區間內，帶有 score 值(可選)的有序集成員的列表
*/
public Set<String> zrevrangeByScore(String key,double max,double min){
return jedisCluster.zrevrangeByScore(key, max, min);
}
/**
* 返回有序集 key 中，所有 score 值介於 max 和 min 之間(包括等於 max 或 min )的成員。有序集成員按 score 值遞減(從大到小)次序排列
* 可選的 LIMIT 參數指定返回結果的數量及區間(就像SQL中的 SELECT LIMIT offset, count )，注意當 offset 很大時，定位 offset 的操作可能需要遍歷整個有序集，此過程最壞復雜度為 O(N) 時間
* @param key
* @param min
* @param max
* @return 指定區間內，帶有 score 值(可選)的有序集成員的列表
*/
public Set<String> zrevrangeByScore(String key,String max,String min,int offset,int count){
return jedisCluster.zrevrangeByScore(key, max,min , offset, count);
}
/**
* 返回有序集 key 中，所有 score 值介於 max 和 min 之間(包括等於 max 或 min )的成員。有序集成員按 score 值遞減(從大到小)次序排列
* 可選的 LIMIT 參數指定返回結果的數量及區間(就像SQL中的 SELECT LIMIT offset, count )，注意當 offset 很大時，定位 offset 的操作可能需要遍歷整個有序集，此過程最壞復雜度為 O(N) 時間
* @param key
* @param min
* @param max
* @return 指定區間內，帶有 score 值(可選)的有序集成員的列表
*/
public Set<String> zrevrangeByScore(String key,double max,double min,int offset,int count){
return jedisCluster.zrevrangeByScore(key, max, min, offset, count);
}
/**
* 返回有序集 key 中成員 member 的排名。其中有序集成員按 score 值遞減(從大到小)排序
* 排名以 0 為底，也就是說， score 值最大的成員排名為 0
* @param key
* @param member
* @return 如果 member 是有序集 key 的成員，返回 member 的排名,如果 member 不是有序集 key 的成員，返回 nil
*/
public long zrevRank(String key,String member){
return jedisCluster.zrevrank(key, member);
}
/**
* 返回有序集 key 中，成員 member 的 score 值
* 如果 member 元素不是有序集 key 的成員，或 key 不存在，返回 nil
* @param key
* @param member
* @return member 成員的 score 值
*/
public Double zscore(String key,String member){
return jedisCluster.zscore(key, member);
}
//Connection(連接)
/**
* 通過設置配置文件中 requirepass 項的值(使用命令 CONFIG SET requirepass password )，可以使用密碼來保護 Redis 服務器
* 如果開啟了密碼保護的話，在每次連接 Redis 服務器之后，就要使用 AUTH 命令解鎖，解鎖之后才能使用其他 Redis 命令
* 如果 AUTH 命令給定的密碼 password 和配置文件中的密碼相符的話，服務器會返回 OK 並開始接受命令輸入
* 另一方面，假如密碼不匹配的話，服務器將返回一個錯誤，並要求客戶端需重新輸入密碼。
* @param password
* @return 密碼匹配時返回 OK ，否則返回一個錯誤
*/
public String auth(String password){
return jedisCluster.auth(password);
}
/**
* 打印一個特定的信息 message ，測試時使用
* @param message
* @return message 自身
*/
public String echo(String message){
return jedisCluster.echo(message);
}
/**
* 使用客戶端向 Redis 服務器發送一個 PING ，如果服務器運作正常的話，會返回一個 PONG
* 通常用於測試與服務器的連接是否仍然生效，或者用於測量延遲值
* @return 如果連接正常就返回一個 PONG ，否則返回一個連接錯誤
*/
public String ping(){
return jedisCluster.ping();
}
/**
* 請求服務器關閉與當前客戶端的連接
* 一旦所有等待中的回復(如果有的話)順利寫入到客戶端，連接就會被關閉
* @return 總是返回 OK
*/
public String quit(){
return jedisCluster.quit();
}
/**
* 切換到指定的數據庫，數據庫索引號 index 用數字值指定，以 0 作為起始索引值,默認使用 0 號數據庫
* @param index
* @return ok
*/
public String select(int index){
return jedisCluster.select(index);
}
//Server(服務器)
/**
* 執行一個 AOF文件 重寫操作。重寫會創建一個當前 AOF 文件的體積優化版本
* @return 反饋信息
*/
public String bgreWriteAof(){
return jedisCluster.bgrewriteaof();
}
/**
* 在后台異步(Asynchronously)保存當前數據庫的數據到磁盤
* BGSAVE 命令執行之后立即返回 OK ，然后 Redis fork 出一個新子進程，原來的 Redis 進程(父進程)繼續處理客戶端請求，而子進程則負責將數據保存到磁盤，然后退出
* @return 反饋信息
*/
public String bgSave(){
return jedisCluster.bgsave();
}
/**
* 返回當前數據庫的 key 的數量
* @return 當前數據庫的 key 的數量
*/
public long dbSize(){
return jedisCluster.dbSize();
}
/**
* 清空整個 Redis 服務器的數據(刪除所有數據庫的所有 key )
* @return 總是返回 OK
*/
public String flushAll(){
return jedisCluster.flushAll();
}
/**
* 清空當前數據庫中的所有 key
* @return 總是返回 OK
*/
public String flushDB(){
return jedisCluster.flushDB();
}
/**
* 返回關於 Redis 服務器的各種信息和統計數值
* @return
*/
public String info(){
return jedisCluster.info();
}
/**
* 以一種易於解釋（parse）且易於閱讀的格式，返回關於 Redis 服務器的各種信息和統計數值
* @param section
* @return
*/
public String info(String section){
return jedisCluster.info(section);
}
/**
* 返回最近一次 Redis 成功將數據保存到磁盤上的時間，以 UNIX 時間戳格式表示
* @return
*/
public long lastsave(){
return jedisCluster.lastsave();
}
/**
* SAVE 命令執行一個同步保存操作，將當前 Redis 實例的所有數據快照(snapshot)以 RDB 文件的形式保存到硬盤
* @return 保存成功時返回 OK
*/
public String save(){
return jedisCluster.save();
}
/**
* SHUTDOWN 命令執行以下操作：停止所有客戶端
* 如果有至少一個保存點在等待，執行 SAVE 命令
* 如果 AOF 選項被打開，更新 AOF 文件
* 關閉 redis 服務器(server)
* 如果持久化被打開的話， SHUTDOWN 命令會保證服務器正常關閉而不丟失任何數據
* @return 執行失敗時返回錯誤,執行成功時不返回任何信息，服務器和客戶端的連接斷開，客戶端自動退出
*/
public String shutdown(){
return jedisCluster.shutdown();
}
/**
* SLAVEOF 命令用於在 Redis 運行時動態地修改復制(replication)功能的行為
* 通過執行 SLAVEOF host port 命令，可以將當前服務器轉變為指定服務器的從屬服務器(slave server)
* @param host
* @param port
* @return 總是返回 OK
*/
public String slaveof(String host,int port){
return jedisCluster.slaveof(host, port);
}
}