redis + 主從 + 持久化 + 分片 + 集群 + spring集成

Redis是一個基於內存的數據庫，其不僅讀寫速度快，每秒可以執行大約110000的寫操作，81000的讀取操作，而且其支持存儲字符串，哈希結構，鏈表，集合豐富的數據類型。所以得到很多開發者的青睞。加之其支持主從、持久化等功能，3.0版本開始正式提供分片技術、讓其在大型互聯網應用中大顯身手，本文通過實際操作和理論相配合，對redis進行詳細地闡述。

一、redis的安裝與使用

下載直接去redis的官網http://redis.io/進行不同操作系統對應的版本。本文中采用的redis的版本為3.2.5、linux平台，安裝過程如下

[root@hbase usr]# tar -zxf redis-3.2.5.tar.gz 
[root@hbase usr]# cd redis-3.2.5
[root@hbase redis-3.2.5]# ll
[root@hbase redis-3.2.5]# make
[root@hbase redis-3.2.5]# cd src
[root@hbase src]# ll

之后我們會發現其中redis-server和redis-cli,這兩個文件分別對應啟動redis的服務端和客戶端，啟動服務端

[root@hbase src]# ./redis-server 
11579:M 13 Nov 15:07:01.399 # Warning: 32 bit instance detected but no memory limit set. Setting 3 GB maxmemory limit with 'noeviction' policy now.
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 3.2.5 (00000000/0) 32 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in standalone mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379
 |    `-._   `._    /     _.-'    |     PID: 11579
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

11579:M 13 Nov 15:07:01.404 # Server started, Redis version 3.2.5
11579:M 13 Nov 15:07:01.409 * The server is now ready to accept connections on port 6379

可以看到，redis正常啟動，6379 是 redis 服務端口，這個端口在redis.conf中可以進行配置，稍后我們講解配置文件的時候會提到。不要關閉這個窗口，因為當前redis-server不是在后台運行，我們另起一個窗口，在當前目錄下進行客戶端連接服務端。

[hadoop@hbase src]$ ./redis-cli 
127.0.0.1:6379> 

說明一切正常，linux環境下的redis安裝成功，至於windows下的安裝過程相對更加簡單，只需打開.exe文件即可，不在詳細演示

二、redis數據類型

2.1 string

字符串類型是Redis中最為基礎的數據存儲類型，它在Redis中是二進制安全的,在Redis中字符串類型的Value最多可以容納的數據長度是512M。除了get、set、作外，Redis還提供了其他的一些諸如追加、遞增等功能。

set key value O(1) 設定該key對應的value，如果該Key已經存在，則覆蓋其原有值。get key O(1) 獲取指定Key的value,如果該Key不存在，返回nil。

setnx key value O(1) 如果指定的Key不存在，則設定該Key持有指定字符串value，此時其效果等價於set命令。如果該Key已經存在，該命令將不做任何操作。 

127.0.0.1:6379> set hello word
OK
127.0.0.1:6379> get hello
"word"
127.0.0.1:6379> set hello world
OK
127.0.0.1:6379> set hello world
OK
127.0.0.1:6379> get hello
"world"
127.0.0.1:6379> get world
(nil)
127.0.0.1:6379> set hello world_new
OK
127.0.0.1:6379> get hello
"world_new"
127.0.0.1:6379> setnx hello nihao
(integer) 0
127.0.0.1:6379> setnx new_hello nihao
(integer) 1

mset key value [key value ...] O(N) N表示指定Key的數量。該命令可以看成是多次迭代執行set命令。

mget key [key ...] O(N) N表示獲取Key的數量。返回所有指定key的value，如果其中某個key不存在，該key的value將返回nil。 

msetnx key value [key value ...] O(N) N表示指定key的數量。該命令原子性的完成參數中所有key/value的設置操作，其具體行為可以看成是多次迭代執行setnx命令。如果在這一批keys中有任意一個key已經存在，那么該操作將全部回滾，即所有的修改都不會生效。 1表示所有keys都設置成功，0則表示沒有任何key被修改。 

127.0.0.1:6379> mset key1 hello key2 world
OK
127.0.0.1:6379> mget key1 key2
1) "hello"
2) "world"
127.0.0.1:6379> mget key1 key3
1) "hello"
2) (nil)
127.0.0.1:6379> msetnx key1 nihao key3 hi
(integer) 0
127.0.0.1:6379> msetnx key3 nihao key4 hi
(integer) 1

append key value  O(1) 若key已經存在，將value的數據追加到對應key的value的末尾。如果該key不存在，append命令將會創建一個新的key/value。

strlen key O(1) 返回指定Key的字符值長度，如果該Key不存在，返回0。

decr key O(1) 將指定key的value原子性的遞減1。如果該key不存在，其初始值為0，在decr之后其值為-1。如果value的值不能轉換為整型值,該操作將執行失敗。

incr key O(1) 將指定key的value原子性的遞增1。如果該Key不存在，其初始值為0，在incr之后其值為1。如果value的值不能轉換為整型值,該操作將執行失敗。 

decrby key decrement O(1) 將指定key的value原子性的減少decrement，其他同decr。

incrby key increment O(1) 將指定key的value原子性的增加increment,其他同incr。 

127.0.0.1:6379> append k1 hello
(integer) 5
127.0.0.1:6379> append k1 world
(integer) 10
127.0.0.1:6379> get k1
"helloworld"
127.0.0.1:6379> strlen k1
(integer) 10
127.0.0.1:6379> set k2 1
OK
127.0.0.1:6379> incr k2
(integer) 2
127.0.0.1:6379> get k2
"2"
127.0.0.1:6379> decr k2
(integer) 1
127.0.0.1:6379> get k2
"1"
127.0.0.1:6379> incrby k2 5
(integer) 6
127.0.0.1:6379> decrby k2 5
(integer) 1
127.0.0.1:6379> get k2
"1"

2.2 redis之數據類型list

在Redis中，List類型是按照插入順序排序的字符串鏈表。和數據結構中的普通鏈表一樣，我們可以在其頭部(left)和尾部(right)添加新的元素，該操作也可以在常量時間內完成。在插入時，如果該鍵並不存在，Redis將為該鍵創建一個新的鏈表。與此相反，如果鏈表中所有的元素均被移除，那么該鍵也將會被從數據庫中刪除。List中可以包含的最大元素數量是4294967295。 

lpush key value [value ...] O(1) 在指定key所對應的List頭部插入所有values。如果該Key不存在，則插入之前創建一個與該key關聯的空鏈表。

lpop key O(1) 返回並彈出指定key對應鏈表的第一個元素。如果該Key不存在，返回nil。

lrange key start stop start和end都是0-len，即0表示鏈表頭部的第一個元素。其中start的值也可以為負值，-1將表示鏈表中的最后一個元素，即尾部元素，-2表示倒數第二個並以此類推。該命令在獲取元素時，start和end位置上的元素也會被取出。如果start的值大於鏈表中元素的數量，空鏈表將會被返回。如果end的值大於元素的數量，該命令則獲取從start(包括start)開始，鏈表中剩余的所有元素。 

lpushx key value O(1) 當指定的key存在時，在其所關聯的list的頭部插入參數中給出的value，否則將不會有任何操作發生。    

lrem key count value O(N) 在指定key關聯的鏈表中，刪除前count個值等於value的元素。如果count大於0，從頭向尾遍歷並刪除，如果count小於0，則從尾向頭遍歷並刪除。如果count等於0，則刪除鏈表中所有等於value的元素。如果指定的key不存在，則直接返回0。

llen key O(1) 返回指定key關聯的鏈表中元素的數量，如果該Key不存在，則返回0。。

lset  key index value O(N) 設定鏈表中指定位置的值為新值，其中0表示第一個元素，即頭部元素，-1表示尾部元素。 

127.0.0.1:6379> lpush k1 v1 v2 v3
(integer) 3
127.0.0.1:6379> lrange k1 0 2
1) "v3" 2) "v2" 3) "v1"
127.0.0.1:6379> lpop k1
"v3"
127.0.0.1:6379> lrange k1 0 2
1) "v2" 2) "v1"
127.0.0.1:6379> lpush k1 v4
(integer) 3
127.0.0.1:6379> lrange k1 0 2
1) "v4" 2) "v2" 3) "v1"
127.0.0.1:6379> lpush k1 v4
(integer) 4
127.0.0.1:6379> lpush k1 v4
(integer) 5
127.0.0.1:6379> lpush k1 v4
(integer) 6
127.0.0.1:6379> lrange k1 0 5
1) "v4" 2) "v4" 3) "v4" 4) "v4" 5) "v2" 6) "v1"
127.0.0.1:6379> lrem k1 2 v4  # 刪除前兩個值為v4的元素
(integer) 2
127.0.0.1:6379> lrange k1 0 3
1) "v4" 2) "v4" 3) "v2" 4) "v1"
127.0.0.1:6379> llen k1
(integer) 4
127.0.0.1:6379> lset k1 1 k5  #設置索引為1的值為k5
OK
127.0.0.1:6379> lrange k1 0 3
1) "v4" 2) "k5" 3) "v2" 4) "v1"

rpush key value [value ...] O(1) 在指定key所對應的List尾部插入所有values。如果該Key不存在，則插入之前創建一個與該key關聯的空鏈表。

rpop key O(1) 返回並彈出指定key對應鏈表的最后一個元素。如果該Key不存在，返回nil。

rpushx key value O(1) 當指定的key存在時，在其所關聯的list的尾部插入參數中給出的value，否則將不會有任何操作發生。  

127.0.0.1:6379> lrange k1 0 3
1) "v4" 2) "k5" 3) "v2" 4) "v1"
127.0.0.1:6379> rpushx k1 k6
(integer) 5
127.0.0.1:6379> lrange k1 0 4
1) "v4" 2) "k5" 3) "v2" 4) "v1" 5) "k6"
127.0.0.1:6379> rpush k1 k7 k8  #在尾部添加元素
(integer) 7
127.0.0.1:6379> lrange k1 0 6
1) "v4" 2) "k5" 3) "v2" 4) "v1" 5) "k6" 6) "k7" 7) "k8"  
127.0.0.1:6379> rpop k1  #彈出尾部的元素
"k8"
127.0.0.1:6379> lrange k1 0 5
1) "v4" 2) "k5" 3) "v2" 4) "v1" 5) "k6" 6) "k7"
127.0.0.1:6379> 

2.3 hash

Redis hash 是一個string類型的field和value的映射表，hash特別適合用於存儲對象。每一個Hash可以存儲4294967295個鍵值對。

hset key field value O(1) 為指定的key設置field/value對，若key不存在，則創建新key，並創建field/value對，若該key中已經存在，則用新值覆蓋其原有值。

hget key field O(1) 返回指定key中指定field所對應的值，若key或field不存在，返回nil。

hmget key field [field ...] O(N) 獲取指定fields關聯的一組values。如果請求的field不存在，其值返回nil。

hmset key field value [field value ...] O(N) 逐個依次設置參數中給出的field/value對。如果其中某個field已經存在，則用新值覆蓋原有值。如果key不存在，則創建新key，同時設定參數中的field/value。

hsetnx key field value O(1) 只有當key或field不存在時，為指定的key設定field/value對，否則該命令不會進行任何操作。

127.0.0.1:6379> hset k1 f1 v1
(integer) 1
127.0.0.1:6379> hset k1 f2 v2
(integer) 1
127.0.0.1:6379> hget k1 f1
"v1"
127.0.0.1:6379> hmget k1 f1 f2
1) "v1" 2) "v2"
127.0.0.1:6379> hmset k1 f3 v3 f4 v4
OK
127.0.0.1:6379> hmget k1 f1 f2 f3 f4
1) "v1" 2) "v2" 3) "v3" 4) "v4"
127.0.0.1:6379> hsetnx k1 f1 v5
(integer) 0
127.0.0.1:6379> hsetnx k1 f5 v5
(integer) 1
127.0.0.1:6379> hmget k1 f1 f2 f3 f4 f5
1) "v1" 2) "v2" 3) "v3" 4) "v4" 5) "v5"

hkeys key O(N) 返回指定key的所有fields名。

hvals key O(N) 返回指定Key的所有values名。

hexists key field O(1) 判斷指定key中的指定field是否存在。1表示存在，0表示field或key不存在。

hlen key O(1) 獲取該key所包含的field的數量。返回key包含的field數量，如果key不存在，返回0。

hdel key field [field ...] O(N) 從指定key的hash中刪除指定的多個字段，如果不存在的字段將被忽略。

hincrby key field increment O(1) 增加指定key中指定field對應的value的值。如果key或field不存在，該命令將會創建一個新key或新field。 

127.0.0.1:6379> hkeys k1
1) "f1" 2) "f2" 3) "f3" 4) "f4" 5) "f5"
127.0.0.1:6379> hvals k1
1) "v1" 2) "v2" 3) "v3" 4) "v4" 5) "v5"
127.0.0.1:6379> hexists k1 f1
(integer) 1
127.0.0.1:6379> hlen k1 
(integer) 5
127.0.0.1:6379> hdel k1 f5
(integer) 1
127.0.0.1:6379> hset k1 f5 1
(integer) 1
127.0.0.1:6379> hvals k1
1) "v1" 2) "v2" 3) "v3" 4) "v4" 5) "1"
127.0.0.1:6379> hincrby k1 f5 2
(integer) 3
127.0.0.1:6379> hvals k1
1) "v1" 2) "v2" 3) "v3" 4) "v4" 5) "3"

2.4 set

在Redis中， Set類型看作為沒有排序的字符集合，和List類型一樣，我們也可以在該類型的數據值上執行添加、刪除或判斷某一元素是否存在等操作。set可包含的最大元素數量是4294967295。set集合中不允許出現重復的元素。 

sadd key member [member ...] O(N) 若該Key不存在，該命令將會創建一個新的set。若有的成員在set中已經存在，該成員將被忽略，而其它成員仍將會被正常插入。

spop key O(1) 隨機的移除並返回set中的某一成員。

scard key O(1) 獲取set中成員的數量。

sismember key member O(1) 判斷參數中指定成員是否已經存在於與key所在的set集合中。

smembers key O(N) 獲取與該key關聯的set中所有的成員。     

srem key member [member ...] O(N) 從與key關聯的set中刪除參數中指定的成員，不存在的參數成員將被忽略。

127.0.0.1:6379> sadd k1 m1
(integer) 1
127.0.0.1:6379> sadd k1 m2
(integer) 1
127.0.0.1:6379> scard k1
(integer) 2
127.0.0.1:6379> spop k1
"m2"
127.0.0.1:6379> sadd k1 m3
(integer) 1
127.0.0.1:6379> sismember k1 m3
(integer) 1
127.0.0.1:6379> smembers k1
1) "m3"
2) "m1"
127.0.0.1:6379> srem k1 m1
(integer) 1
127.0.0.1:6379> smembers k1
1) "m3"

sdiff key [key ...] O(N) 返回第一個key所關聯的set和其后所有keys所關聯的sets中成員的差異。

sinter  key [key ...] O(N*M) 返回參數中所有keys關聯的sets中成員的交集。

sunion key [key ...] O(N) 返回參數中所有keys關聯的sets中成員的並集。  

127.0.0.1:6379> smembers k1
1) "m2"
2) "m1"
3) "m3"
127.0.0.1:6379> smembers k2
1) "m3"
2) "m1"
3) "m4"
127.0.0.1:6379> sdiff k1 k2
1) "m2"
127.0.0.1:6379> sinter k1 k2
1) "m1"
2) "m3"
127.0.0.1:6379> sunion k1 k2
1) "m3"
2) "m1"
3) "m2"
4) "m4"

 2.5 sorted set

sorted-set和set類型極為相似，都不允許重復的成員出現在一個Set中。它們之間的主要差別是sorted-set中的每一個成員都會有一個分數(score)與之關聯，Redis正是通過分數來為集合中的成員進行從小到大的排序。

zadd key score member [score] [member] O(log(N)) 添加參數中指定的所有成員及其分數到指定key的sorted-sett中。

zcard key O(1) 獲取與該key相關聯的sorted-set中包含的成員數量。

zscore key member O(1) 獲取指定Key的指定成員的分數。如果該成員存在，以字符串的形式返回其分數，否則返回nil。

zcount key min max O(log(N)+M) 用於獲取分數(score)在min和max之間的成員數量。min和max表示的范圍是閉區間范圍，即min <= score <= max內的成員將被返回。

zincrby key increment member O(log(N)) 將為指定Key中的指定成員增加指定的分數。

zrange key start stop [WITHSCORES] O(log(N)+M)  返回順序在start和stop指定范圍內的成員列表。

zrangebyscore key min max [WITHSCORES] [LIMIT offset count] O(log(N)+M) 將返回分數在min和max之間的所有成員列表。

zrem key member [member ...] O(M log(N)) 移除參數中指定的成員，其中不存在的成員將被忽略。

zremrangebyscore key min max O(log(N)+M) 刪除分數在min和max之間的所有成員，即滿足表達式min <= score <= max的所有成員。 

127.0.0.1:6379> zadd k1 1 m1
(integer) 1
127.0.0.1:6379> zadd k1 2 m2
(integer) 1
127.0.0.1:6379> zadd k1 3 m3
(integer) 1
127.0.0.1:6379> zcard k1
(integer) 3
127.0.0.1:6379> zscore k1 m1
"1"
127.0.0.1:6379> zscore k1 m2
"2"
127.0.0.1:6379> zcount k1 2 3
(integer) 2
127.0.0.1:6379> zincrby k1 3 m3
"6"
127.0.0.1:6379> zrange k1 1 10
1) "m2"
2) "m3"
127.0.0.1:6379> zrange k1 0 10
1) "m1"
2) "m2"
3) "m3"
127.0.0.1:6379> zcount k1 0 10
(integer) 3
127.0.0.1:6379> zrangebyscore k1 0 6
1) "m1"
2) "m2"
3) "m3"
127.0.0.1:6379> zrem k1 m1
(integer) 1
127.0.0.1:6379> zcard k1
(integer) 2
127.0.0.1:6379> zremrangebyscore k1 2 3
(integer) 1
127.0.0.1:6379> zremrangebyscore k1 2 10
(integer) 1
127.0.0.1:6379> zcard k1
(integer) 0

三、redis的相關命令 

keys pattern O(N) 獲取所有匹配pattern參數的Keys。需要說明的是，在我們的正常操作中應該盡量避免對該命令的調用，因為對於大型數據庫而言，該命令是非常耗時的。pattern支持glob-style的通配符格式，如*表示任意一個或多個字符，?表示任意字符，[abc]表示方括號中任意一個字母。
del key [key ...] O(N) 從數據庫刪除中參數中指定的keys，如果指定鍵不存在，則直接忽略。
exists key O(1) 判斷指定鍵是否存在。 1表示存在，0表示不存在。
move key db O(1) 將當前數據庫中指定的鍵key移動到參數中指定的數據庫中。若該key在目標數據庫中已經存在，或者在當前數據庫中不存在，該命令將不做任何操作並返回0。 移動成功返回1，否則0。
rename key newkey O(1) 為指定指定的鍵重新命名，如果兩個keys的命令相同，或者是源key不存在，該命令都會返回相關的錯誤信息。如果newKey已經存在，則直接覆蓋。
renamenx key newkey O(1) 如果新值不存在，則將參數中的原值修改為新值。其它條件和rename一致。1表示修改成功，否則0。
expire key seconds O(1) 該命令為指定的key設定超時的秒數，在超過該時間后，key被自動的刪除。如果該Key在超時之前被修改，與該鍵關聯的超時將被移除。1表示超時被設置，0則表示Key不存在，或不能被設置。
expireat key timestamp O(1) 該命令的邏輯功能和expire完全相同，差別是該命令指定的超時時間是絕對時間，而不是相對時間。該時間參數是Unix timestamp格式的，即從1970年1月1日開始所流經的秒數。1表示超時被設置，0則表示Key不存在，或不能被設置。
ttl key O(1) 獲取該鍵所剩的超時描述。如果該鍵不存在或沒有超時設置，則返回-1。
type key O(1) 獲取與參數中指定鍵關聯值的類型，該命令將以字符串的格式返回。 返回的字符串為string、list、set、hash和zset，如果key不存在返回none。

127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> set str string
OK
127.0.0.1:6379> hset hash1 f1 v1
(integer) 1
127.0.0.1:6379> sadd set1 v1
(integer) 1
127.0.0.1:6379> zadd sortedset1 1 v1
(integer) 1
127.0.0.1:6379> lpush list1 v1 v2
(integer) 2
127.0.0.1:6379> keys *
1) "hash1"
2) "sortedset1"
3) "list1"
4) "str"
5) "set1"
127.0.0.1:6379> keys s*
1) "sortedset1"
2) "str"
3) "set1"
127.0.0.1:6379> exists list1
(integer) 1
127.0.0.1:6379> rename list1 list2
OK
127.0.0.1:6379> keys *
1) "hash1"
2) "sortedset1"
3) "str"
4) "list2"
5) "set1"
127.0.0.1:6379> type list2
list
127.0.0.1:6379> type str
string
127.0.0.1:6379> set str2 v2
OK
127.0.0.1:6379> expire str2 10
(integer) 1
127.0.0.1:6379> ttl str2
(integer) 6
127.0.0.1:6379> ttl str2
(integer) -2
127.0.0.1:6379> keys *
1) "hash1"
2) "sortedset1"
3) "str"
4) "list2"
5) "set1"
127.0.0.1:6379> move str 1
(integer) 1
127.0.0.1:6379> keys *
1) "hash1"
2) "sortedset1"
3) "list2"
4) "set1"
127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> keys *
1) "str"
127.0.0.1:6379[1]> select 0
OK
127.0.0.1:6379> del set1
(integer) 1
127.0.0.1:6379> keys *
1) "hash1"
2) "sortedset1"
3) "list2"

四、redis的事務

1). 所有命令順序執行，期間，Redis不會再為其它客戶端的請求提供任何服務，從而保證了事物中的所有命令被原子的執行。
2). 和關系型數據庫中的事務不同的是，在Redis事務中如果有某一條命令執行失敗，其后的命令仍然會被繼續執行。
3). 我們可以通過MULTI命令開啟一個事務，有關系型數據庫開發經驗的人可以將其理解為"BEGIN TRANSACTION"語句。在該語句之后執行的命令都將被視為事務之內的操作，最后我們可以通過執行EXEC/DISCARD命令來提交/回滾該事務內的所有操作。這兩個Redis命令可被視為等同於關系型數據庫中的COMMIT/ROLLBACK語句。

multi 用於標記事務的開始，其后執行的命令都將被存入命令隊列，直到執行exec時，這些命令才會被原子的執行。 始終返回OK
exec 執行在一個事務內命令隊列中的所有命令，同時將當前連接的狀態恢復為正常狀態，即非事務狀態。如果在事務中執行了watch命令，那么只有當watch所監控的keys沒有被修改的前提下，exec命令才能執行事務隊列中的所有命令，否則exec將放棄當前事務中的所有命令。 原子性的返回事務中各條命令的返回結果。如果在事務中使用了watch，一旦事務被放棄，exec將返回NULL-multi-bulk回復。

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k1 string
QUEUED
#由於k1為字符串類型，所以incr會報錯，但是以后其他命令正常執行
127.0.0.1:6379> incr k1
QUEUED
127.0.0.1:6379> set k1 newstring
QUEUED
127.0.0.1:6379> get k1
QUEUED
127.0.0.1:6379> exec
1) OK
2) (error) ERR value is not an integer or out of range
3) OK
4) "newstring"

discard 回滾事務隊列中的所有命令，同時再將當前連接的狀態恢復為正常狀態，即非事務狀態。如果watch命令被使用，該命令將unwatch所有的Keys。
watch key [key ...] O(1) 在multi命令執行之前，可以指定待監控的keys，然而在執行exec之前，如果被監控的keys發生修改，exec將放棄執行該事務隊列中的所有命令。
unwatch O(1) 取消當前事務中指定監控的keys，如果執行了exec或discard命令，則無需手工執行該命令，因為事務中所有被監控的keys都將自動取消。 

127.0.0.1:6379> set id 1
OK
127.0.0.1:6379> set name n1
OK
127.0.0.1:6379> set age 12
OK
127.0.0.1:6379> watch id
OK
127.0.0.1:6379> multi 
OK
127.0.0.1:6379> set name n2
QUEUED
127.0.0.1:6379> incr age
QUEUED
127.0.0.1:6379> exec
(nil)
127.0.0.1:6379> get age
"12"
127.0.0.1:6379> get name
"n1"

 注意，在提交事務之前，則執行exec命令之前，我們在另一個窗口對id進行修改（set id 2），可以看出，該事務沒有執行成功

五、redis的主從復制

1). 同一個Master可以同步多個Slaves節點。

2). Slave同樣可以接受其它Slaves的連接和同步請求。

3). Master Server是以非阻塞的方式為Slaves提供服務。所以在Master-Slave同步期間，客戶端仍然可以提交查詢或修改請求。

4). Slave Server同樣是以非阻塞的方式完成數據同步。在同步期間，如果有客戶端提交查詢請求，Redis則返回同步之前的數據。

5). 為了分載Master的讀操作壓力，Slave服務器可以為客戶端提供只讀操作的服務，寫服務仍然必須由Master來完成。從而實現讀寫分離

在Slave啟動並連接到Master之后，它將主動發送一個SYNC命令。此后Master將啟動后台存盤進程，同時收集所有接收到的用於修改數據集的命令，在后台進程執行完畢后，Master將傳送整個數據庫文件到Slave，以完成一次完全同步。而Slave服務器在接收到數據庫文件數據之后將其存盤並加載到內存中。此后，Master繼續將所有已經收集到的修改命令，和新的修改命令依次傳送給Slaves，Slave將在本次執行這些數據修改命令，從而達到最終的數據同步。若Master和Slave之間的鏈接出現斷連現象，Slave可以自動重連Master，但是在連接成功之后，一次完全同步將被自動執行。 

同時啟動兩個Redis服務器，可以考慮在同一台機器上啟動兩個Redis服務器，分別監聽不同的端口，如6379和6380。復制redis.conf並命名為slave.conf，編輯該配置文件，在84行位置將其中監聽的端口改為6380：配置如下port 6380，分配啟動兩個server，啟動時可以將配置文件作為啟動命令的參數。命令如下：redis-server redis.conf ,當我們把兩個server都啟動時，可以進行以下步驟：

redis-cli -p 6380

通過不同的端口來鏈接服務端，此時，當前客戶端鏈接的6380端口的服務端，我們讓這個服務端當做slave節點的角色。執行如下命令

slaveof 127.0.0.1 6379

當返回ok時，這里我Master-Slave建立成功。在監聽端口為6379的服務器上我們用客戶端進行操作

[root@hbase redis-3.2.5]# src/redis-cli -p 6379
127.0.0.1:6379> set k1 v1
OK
127.0.0.1:6379> hset k2 f2 v2
(integer) 1
127.0.0.1:6379> 

在slave節點，獲取該值：

[root@hbase redis-3.2.5]# src/redis-cli -p 6380
127.0.0.1:6380> slaveof 127.0.0.1 6379
OK
127.0.0.1:6380> keys *
1) "k1"
2) "k2"
127.0.0.1:6380> get k1
"v1"

說明兩個節點主從已經同步。實現了主從同步的效果。需要注意的是：上面的方式只是保證了在執行slaveof命令之后，redis_6380成為了redis_6379的slave，一旦服務(redis_6380)重新啟動之后，他們之間的復制關系將終止。如果希望長期保證這兩個服務器之間的Replication關系，可以在redis_6380的配置文件中做如下修改：

# slaveof <masterip> <masterport>改為slaveof 127.0.0.1 6379

保存退出。這樣就可以保證Redis_6380服務程序在每次啟動后都會主動建立與Redis_6379的Replication連接了。

六、redis的持久化 

6.1、Redis提供的持久化機制： 

1). RDB持久化：該機制是指在指定的時間間隔內將內存中的數據集快照寫入磁盤。 

2). AOF持久化：該機制將以日志的形式記錄服務器所處理的每一個寫操作，在Redis服務器啟動之初會讀取該文件來重新構建數據庫，以保證啟動后數據庫中的數據是完整的。

6.2、RDB機制的優勢和劣勢：

優勢：
1). 采用該方式，整個Redis數據庫將只包含一個文件，通過這樣的備份策略，一旦系統出現災難性故障，我們可以非常容易的進行恢復。
2). 性能最大化，對於Redis的服務進程而言，在開始持久化時，它唯一需要做的只是fork出子進程，再由子進程完成這些持久化的工作，這樣可以極避免服務進程執行IO操作。
劣勢：

1). 如果你想保證數據的高可用性，那么RDB將不是一個很好的選擇。因為系統一旦在定時持久化之前出現宕機現象，此前沒有來得及寫入磁盤的數據都將丟失。

2). 由於RDB是通過fork子進程來協助完成數據持久化工作的，因此，如果當數據集較大時，可能會導致整個服務器停止服務一定的時間。

6.3、AOF機制的優勢和劣勢： 

優勢
1). 帶來更高的數據安全性，即數據持久性。Redis中提供了3中同步策略，即每秒同步、每修改同步和不同步。事實上，每秒同步也是異步完成的，其效率也是非常高的，所差的是一旦系統出現宕機現象，那么這一秒鍾之內修改的數據將會丟失。而每修改同步，我們可以將其視為同步持久化，即每次發生的數據變化都會被立即記錄到磁盤中。可以預見，這種方式在效率上是最低的。

2). 由於該機制對日志文件的寫入操作采用的是append模式，因此在寫入過程中即使出現宕機現象，也不會破壞日志文件中已經存在的內容。然而如果我們本次操作只是寫入了一半數據就出現了系統崩潰問題，在Redis下一次啟動之前，可以通過redis-check-aof工具來解決數據一致性的問題。

3). 如果日志過大，Redis可以自動啟用rewrite機制。即Redis以append模式不斷的將修改數據寫入到老的磁盤文件中，同時Redis還會創建一個新的文件用於記錄此期間有哪些修改命令被執行。因此在進行rewrite切換時可以更好的保證數據安全性。

4). AOF包含一個格式清晰、易於理解的日志文件用於記錄所有的修改操作。事實上，我們也可以通過該文件完成數據的重建。
劣勢
1). 對於相同數量的數據集而言，AOF文件通常要大於RDB文件。
2). 根據同步策略的不同，AOF在運行效率上往往會慢於RDB。

介紹完理論之后，我們配置redis的持久化方案：

rdb方案，在redis.conf中如下配置(默認配置) 

save 900 1              #在900秒(15分鍾)之后，如果至少有1個key發生變化，則dump內存快照。
save 300 10            #在300秒(5分鍾)之后，如果至少有10個key發生變化，則dump內存快照。
save 60 10000        #在60秒(1分鍾)之后，如果至少有10000個key發生變化，則dump內存快照。

aof方案的配置：

在Redis的配置文件中存在三種同步方式，它們分別是：
appendfsync always     #每次有數據修改發生時都會寫入AOF文件。
appendfsync everysec  #每秒鍾同步一次，該策略為AOF的缺省策略。
appendfsync no          #從不同步。高效但是數據不會被持久化。

七、redis的分片

分片(partitioning)就是將你的數據拆分到多個 Redis 實例的過程,Redis 引入另一種哈希槽（hash slot）的概念。Redis 集群中內置了 16384 個哈希槽，當需要在 Redis 集群中放置一個 key-value 時，redis 先對 key 使用 crc16 算法得出結果，然后對 16384 求余數，這樣每個 key 對應一個編號在 0-16383 之間的哈希槽，redis 會根據節點數量大致均等的將哈希槽映射到不同節點。

原來的redis分片實現：

客戶端分片(Client side partitioning)，客戶端直接選擇正確的節點來寫入和讀取指定鍵。

代理協助分片(Proxy assisted partitioning)，客戶端發送請求到一個可以理解 Redis 協議的代理上，而不是直接發送請求到 Redis 實例上。代理會根據配置好的分片模式，來保證轉發請求到正確的 Redis 實例，並返回響應給客戶端。

查詢路由(Query routing)，發送查詢到一個隨機實例，這個實例會保證轉發查詢到正確的節點。 

新版本Redis的解決辦法:

Redis3.0版的一大特性就是支持集群（Cluster)功能。Redis集群是自動分片和高可用的首選方式。集群的特點在於擁有和單機實例同樣的功能，同時在網絡分區后能夠提供一定的可訪問性以及對主數據庫故障恢復的支持。

======================= 以下概念摘自網絡===================

集群節點屬性： 

每個節點在集群中都有一個獨一無二的 ID ， 該 ID 是一個十六進制表示的 160 位隨機數， 在節點第一次啟動時由 /dev/urandom 生成。節點會將它的 ID 保存到配置文件， 只要這個配置文件不被刪除， 節點就會一直沿用這個 ID 。節點 ID 用於標識集群中的每個節點。 一個節點可以改變它的 IP 和端口號， 而不改變節點 ID 。 集群可以自動識別出 IP/端口號的變化， 並將這一信息通過 Gossip 協議廣播給其他節點知道。

節點握手：

節點總是應答（accept）來自集群連接端口的連接請求， 並對接收到的 PING 數據包進行回復， 即使這個 PING 數據包來自不可信的節點。然而， 除了 PING 之外， 節點會拒絕其他所有並非來自集群節點的數據包。要讓一個節點承認另一個節點同屬於一個集群， 只有以下兩種方法：

1、一個節點可以通過向另一個節點發送 MEET 信息， 來強制讓接收信息的節點承認發送信息的節點為集群中的一份子。 一個節點僅在管理員顯式地向它發送CLUSTER MEET ip port 命令時， 才會向另一個節點發送 MEET 信息。

2、如果一個可信節點向另一個節點傳播第三者節點的信息， 那么接收信息的那個節點也會將第三者節點識別為集群中的一份子。 也即是說， 如果 A 認識 B ， B 認識 C ， 並且 B 向 A 傳播關於 C 的信息， 那么 A 也會將 C 識別為集群中的一份子， 並嘗試連接 C 。

這意味着如果我們將一個/一些新節點添加到一個集群中， 那么這個/這些新節點最終會和集群中已有的其他所有節點連接起來。這說明只要管理員使用 CLUSTER MEET 命令顯式地指定了可信關系， 集群就可以自動發現其他節點。這種節點識別機制通過防止不同的 Redis 集群因為 IP 地址變更或者其他網絡事件的發生而產生意料之外的聯合（mix）， 從而使得集群更具健壯性。當節點的網絡連接斷開時， 它會主動連接其他已知的節點。

MOVED 轉向：

一個 Redis 客戶端可以向集群中的任意節點（包括從節點）發送命令請求。 節點會對命令請求進行分析， 如果該命令是集群可以執行的命令， 那么節點會查找這個命令所要處理的鍵所在的槽。如果要查找的哈希槽正好就由接收到命令的節點負責處理， 那么節點就直接執行這個命令。如果所查找的槽不是由該節點處理的話， 節點將查看自身內部所保存的哈希槽到節點 ID 的映射記錄， 並向客戶端回復一個 MOVED 錯誤。為了讓客戶端的轉向操作盡可能地簡單， 節點在 MOVED 錯誤中直接返回目標節點的 IP 和端口號， 而不是目標節點的 ID 。客戶端應該記錄（memorize）下“槽 3999 由節點 127.0.0.1:6381 負責處理“這一信息， 這樣當再次有命令需要對槽 3999 執行時， 客戶端就可以加快尋找正確節點的速度。當集群處於穩定狀態時， 所有客戶端最終都會保存有一個哈希槽至節點的映射記錄（map of hash slots to nodes）， 使得集群非常高效： 客戶端可以直接向正確的節點發送命令請求， 無須轉向、代理或者其他任何可能發生單點故障（single point failure）的實體（entiy）。除了 MOVED 轉向錯誤之外， 一個客戶端還應該可以處理稍后介紹的 ASK 轉向錯誤。

集群在線重配置：

Redis 集群支持在集群運行的過程中添加或者移除節點。實際上， 節點的添加操作和節點的刪除操作可以抽象成同一個操作， 那就是， 將哈希槽從一個節點移動到另一個節點。因此， 實現 Redis 集群在線重配置的核心就是將槽從一個節點移動到另一個節點的能力。 因為一個哈希槽實際上就是一些鍵的集合， 所以 Redis 集群在重哈希（rehash）時真正要做的， 就是將一些鍵從一個節點移動到另一個節點。要理解 Redis 集群如何將槽從一個節點移動到另一個節點， 我們需要對 CLUSTER 命令的各個子命令進行介紹， 這些命理負責管理集群節點的槽轉換表（slots translation table）。以下是 CLUSTER 命令可用的子命令：

CLUSTER ADDSLOTS slot1 [slot2] ... [slotN]

CLUSTER DELSLOTS slot1 [slot2] ... [slotN]

CLUSTER SETSLOT slot NODE node

CLUSTER SETSLOT slot MIGRATING node

CLUSTER SETSLOT slot IMPORTING node

最開頭的兩條命令 ADDSLOTS 和 DELSLOTS 分別用於向節點指派（assign）或者移除節點， 當槽被指派或者移除之后， 節點會將這一信息通過 Gossip 協議傳播到整個集群。 ADDSLOTS 命令通常在新創建集群時， 作為一種快速地將各個槽指派給各個節點的手段來使用。CLUSTER SETSLOT slot NODE node 子命令可以將指定的槽 slot 指派給節點 node 。至於 CLUSTER SETSLOT slot MIGRATING node 命令和 CLUSTER SETSLOT slot IMPORTING node 命令， 前者用於將給定節點 node 中的槽 slot 遷移出節點， 而后者用於將給定槽 slot導入到節點 node ：當一個槽被設置為 MIGRATING 狀態時， 原來持有這個槽的節點仍然會繼續接受關於這個槽的命令請求， 但只有命令所處理的鍵仍然存在於節點時， 節點才會處理這個命令請求。如果命令所使用的鍵不存在與該節點， 那么節點將向客戶端返回一個 -ASK 轉向（redirection）錯誤， 告知客戶端， 要將命令請求發送到槽的遷移目標節點。當一個槽被設置為 IMPORTING 狀態時， 節點僅在接收到 ASKING 命令之后， 才會接受關於這個槽的命令請求。如果客戶端沒有向節點發送 ASKING 命令， 那么節點會使用 -MOVED 轉向錯誤將命令請求轉向至真正負責處理這個槽的節點。上面關於 MIGRATING 和 IMPORTING 的說明有些難懂， 讓我們用一個實際的實例來說明一下。假設現在， 我們有 A 和 B 兩個節點， 並且我們想將槽 8 從節點 A 移動到節點 B ， 於是我們：向節點 B 發送命令 CLUSTER SETSLOT 8 IMPORTING A，向節點 A 發送命令 CLUSTER SETSLOT 8 MIGRATING B，每當客戶端向其他節點發送關於哈希槽 8 的命令請求時， 這些節點都會向客戶端返回指向節點 A 的轉向信息：如果命令要處理的鍵已經存在於槽 8 里面， 那么這個命令將由節點 A 處理。如果命令要處理的鍵未存在於槽 8 里面（比如說，要向槽添加一個新的鍵）， 那么這個命令由節點 B 處理。這種機制將使得節點 A 不再創建關於槽 8 的任何新鍵。與此同時， 一個特殊的客戶端 redis-trib 以及 Redis 集群配置程序（configuration utility）會將節點 A 中槽 8 里面的鍵移動到節點 B 。

鍵的移動操作由以下兩個命令執行：

CLUSTER GETKEYSINSLOT slot count

上面的命令會讓節點返回 count 個 slot 槽中的鍵， 對於命令所返回的每個鍵， redis-trib 都會向節點 A 發送一條 MIGRATE 命令， 該命令會將所指定的鍵原子地（atomic）從節點 A 移動到節點 B （在移動鍵期間，兩個節點都會處於阻塞狀態，以免出現競爭條件）。

以下為 MIGRATE 命令的運作原理：

MIGRATE target_host target_port key target_database id timeout執行 MIGRATE 命令的節點會連接到 target 節點， 並將序列化后的 key 數據發送給 target ， 一旦 target 返回 OK ， 節點就將自己的 key 從數據庫中刪除。從一個外部客戶端的視角來看， 在某個時間點上， 鍵 key 要么存在於節點 A ， 要么存在於節點 B ， 但不會同時存在於節點 A 和節點 B 。因為 Redis 集群只使用 0 號數據庫， 所以當 MIGRATE 命令被用於執行集群操作時， target_database 的值總是 0 。target_database 參數的存在是為了讓 MIGRATE 命令成為一個通用命令， 從而可以作用於集群以外的其他功能。我們對 MIGRATE 命令做了優化， 使得它即使在傳輸包含多個元素的列表鍵這樣的復雜數據時， 也可以保持高效。不過， 盡管 MIGRATE 非常高效， 對一個鍵非常多、並且鍵的數據量非常大的集群來說， 集群重配置還是會占用大量的時間， 可能會導致集群沒辦法適應那些對於響應時間有嚴格要求的應用程序。

ASK 轉向：

在之前介紹 MOVED 轉向的時候， 我們說除了 MOVED 轉向之外， 還有另一種 ASK 轉向。當節點需要讓一個客戶端長期地（permanently）將針對某個槽的命令請求發送至另一個節點時， 節點向客戶端返回 MOVED 轉向。另一方面， 當節點需要讓客戶端僅僅在下一個命令請求中轉向至另一個節點時， 節點向客戶端返回 ASK 轉向。比如說， 在我們上一節列舉的槽 8 的例子中， 因為槽 8 所包含的各個鍵分散在節點 A 和節點 B 中， 所以當客戶端在節點 A 中沒找到某個鍵時， 它應該轉向到節點 B 中去尋找， 但是這種轉向應該僅僅影響一次命令查詢， 而不是讓客戶端每次都直接去查找節點 B ： 在節點 A 所持有的屬於槽 8 的鍵沒有全部被遷移到節點 B 之前， 客戶端應該先訪問節點 A ， 然后再訪問節點 B 。因為這種轉向只針對 16384 個槽中的其中一個槽， 所以轉向對集群造成的性能損耗屬於可接受的范圍。因為上述原因， 如果我們要在查找節點 A 之后， 繼續查找節點 B ， 那么客戶端在向節點 B 發送命令請求之前， 應該先發送一個 ASKING 命令， 否則這個針對帶有IMPORTING 狀態的槽的命令請求將被節點 B 拒絕執行。接收到客戶端 ASKING 命令的節點將為客戶端設置一個一次性的標志（flag）， 使得客戶端可以執行一次針對 IMPORTING 狀態的槽的命令請求。從客戶端的角度來看， ASK 轉向的完整語義（semantics）如下：

1、如果客戶端接收到 ASK 轉向， 那么將命令請求的發送對象調整為轉向所指定的節點。

2、先發送一個 ASKING 命令，然后再發送真正的命令請求。

3、不必更新客戶端所記錄的槽 8 至節點的映射： 槽 8 應該仍然映射到節點 A ， 而不是節點 B 。

一旦節點 A 針對槽 8 的遷移工作完成， 節點 A 在再次收到針對槽 8 的命令請求時， 就會向客戶端返回 MOVED 轉向， 將關於槽 8 的命令請求長期地轉向到節點 B 。注意， 即使客戶端出現 Bug ， 過早地將槽 8 映射到了節點 B 上面， 但只要這個客戶端不發送 ASKING 命令， 客戶端發送命令請求的時候就會遇上 MOVED 錯誤， 並將它轉向回節點 A 。

 
容錯：

節點失效檢測，以下是節點失效檢查的實現方法：

1、當一個節點向另一個節點發送 PING 命令， 但是目標節點未能在給定的時限內返回 PING 命令的回復時， 那么發送命令的節點會將目標節點標記為 PFAIL（possible failure，可能已失效）。等待 PING 命令回復的時限稱為“節點超時時限（node timeout）”， 是一個節點選項（node-wise setting）。

2、每次當節點對其他節點發送 PING 命令的時候， 它都會隨機地廣播三個它所知道的節點的信息， 這些信息里面的其中一項就是說明節點是否已經被標記為 PFAIL或者 FAIL 。當節點接收到其他節點發來的信息時， 它會記下那些被其他節點標記為失效的節點。 這稱為失效報告（failure report）。

3、如果節點已經將某個節點標記為 PFAIL ， 並且根據節點所收到的失效報告顯式， 集群中的大部分其他主節點也認為那個節點進入了失效狀態， 那么節點會將那個失效節點的狀態標記為 FAIL 。

4、一旦某個節點被標記為 FAIL ， 關於這個節點已失效的信息就會被廣播到整個集群， 所有接收到這條信息的節點都會將失效節點標記為 FAIL 。

簡單來說， 一個節點要將另一個節點標記為失效， 必須先詢問其他節點的意見， 並且得到大部分主節點的同意才行。因為過期的失效報告會被移除， 所以主節點要將某個節點標記為 FAIL 的話， 必須以最近接收到的失效報告作為根據。

從節點選舉：一旦某個主節點進入 FAIL 狀態， 如果這個主節點有一個或多個從節點存在， 那么其中一個從節點會被升級為新的主節點， 而其他從節點則會開始對這個新的主節點進行復制。新的主節點由已下線主節點屬下的所有從節點中自行選舉產生， 以下是選舉的條件：

1、這個節點是已下線主節點的從節點。

2、已下線主節點負責處理的槽數量非空。

3、從節點的數據被認為是可靠的， 也即是， 主從節點之間的復制連接（replication link）的斷線時長不能超過節點超時時限（node timeout）乘以REDIS_CLUSTER_SLAVE_VALIDITY_MULT 常量得出的積。

如果一個從節點滿足了以上的所有條件， 那么這個從節點將向集群中的其他主節點發送授權請求， 詢問它們， 是否允許自己（從節點）升級為新的主節點。如果發送授權請求的從節點滿足以下屬性， 那么主節點將向從節點返FAILOVER_AUTH_GRANTED 授權， 同意從節點的升級要求：

1、發送授權請求的是一個從節點， 並且它所屬的主節點處於 FAIL 狀態。

2、在已下線主節點的所有從節點中， 這個從節點的節點 ID 在排序中是最小的。

3、這個從節點處於正常的運行狀態： 它沒有被標記為 FAIL 狀態， 也沒有被標記為 PFAIL 狀態。

一旦某個從節點在給定的時限內得到大部分主節點的授權， 它就會開始執行以下故障轉移操作：

1、通過 PONG 數據包（packet）告知其他節點， 這個節點現在是主節點了。

2、通過 PONG 數據包告知其他節點， 這個節點是一個已升級的從節點（promoted slave）。

3、接管（claiming）所有由已下線主節點負責處理的哈希槽。

4、顯式地向所有節點廣播一個 PONG 數據包， 加速其他節點識別這個節點的進度， 而不是等待定時的 PING / PONG 數據包。

所有其他節點都會根據新的主節點對配置進行相應的更新：

1、所有被新的主節點接管的槽會被更新。

2、已下線主節點的所有從節點會察覺到 PROMOTED 標志， 並開始對新的主節點進行復制。

3、如果已下線的主節點重新回到上線狀態， 那么它會察覺到 PROMOTED 標志， 並將自身調整為現任主節點的從節點。

在集群的生命周期中， 如果一個帶有 PROMOTED 標識的主節點因為某些原因轉變成了從節點， 那么該節點將丟失它所帶有的 PROMOTED 標識 

======================= 以上概念摘自網絡===================

 搭建redis集群環境需要執行的ruby的腳本，所以需要安裝ruby的環境。建議用yum進行安裝，由於具體的操作環境不相同，所以具體操作過程還需視操作環境而定 

[root@root java]# yum install ruby
[root@root java]# yum install rubygems
[root@root java]# gem install redis

期間會出現選擇選項，鍵入yes即可。當出現Successfully installed redis-3.3.1  1 gem installed,說明redis集群需要的ruby環境安裝成功。開始搭建redis環境

創建redis-cluster文件夾，並在其中創建6379,6380,6381文件夾，修改redis.conf文件，並將其中的端口分別設置成6379,6380,6381，redis.conf中的其他配置為

daemonize yes

cluster-enabled yes

cluster-config-file nodes.conf

cluster-node-timeout 5000

appendonly yes

結構目錄如下：

[root@storm1 java]# cd redis-cluster/
[root@storm1 redis-cluster]# ll
total 12
drwxr-xr-x. 2 root root 4096 Nov 14 05:50 6379
drwxr-xr-x. 2 root root 4096 Nov 14 05:51 6380
drwxr-xr-x. 2 root root 4096 Nov 14 05:52 6381
[root@storm1 redis-cluster]# cd 6379
[root@storm1 6379]# cat redis.conf 
port 6379
daemonize yes
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes[root@storm1 6379]# more ../6380/redis.conf 
port 6380
daemonize yes
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
[root@storm1 6379]# 

分別啟動這3個redis實例，並創建集群，讓三個實例互相通訊：

[root@storm1 redis-3.2.5]# src/redis-trib.rb create --replicas 0 127.0.0.1:6379 127.0.0.1:6380 127.0.0.1:6381
>>> Creating cluster
>>> Performing hash slots allocation on 3 nodes...
Using 3 masters:
127.0.0.1:6379
127.0.0.1:6380
127.0.0.1:6381
M: 76d37cdb954e0c293cec5c6bc27015af40d4a59f 127.0.0.1:6379
   slots:0-5460 (5461 slots) master
M: f18ab812b7f9e933639b3afdab964039ddd3ceba 127.0.0.1:6380
   slots:5461-10922 (5462 slots) master
M: 644f9bca1af9cc9e3f1543ab5f0b434d11ff59b0 127.0.0.1:6381
   slots:10923-16383 (5461 slots) master
Can I set the above configuration? (type 'yes' to accept): yes
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join....
>>> Performing Cluster Check (using node 127.0.0.1:6379)
M: 76d37cdb954e0c293cec5c6bc27015af40d4a59f 127.0.0.1:6379
   slots:0-5460 (5461 slots) master
   0 additional replica(s)
M: 644f9bca1af9cc9e3f1543ab5f0b434d11ff59b0 127.0.0.1:6381
   slots:10923-16383 (5461 slots) master
   0 additional replica(s)
M: f18ab812b7f9e933639b3afdab964039ddd3ceba 127.0.0.1:6380
   slots:5461-10922 (5462 slots) master
   0 additional replica(s)
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.

至此redis集群即搭建成功,簡單進行測試一下

[root@storm1 redis-3.2.5]# src/redis-cli -c -p 6379
127.0.0.1:6379> set k1 v1
-> Redirected to slot [12706] located at 127.0.0.1:6381
OK
127.0.0.1:6381> exit
[root@storm1 redis-3.2.5]# src/redis-cli -c -p 6381
127.0.0.1:6381> keys *
1) "k1"
127.0.0.1:6381> 

可以看到，雖然我們第一次連接的是6379端口，redis cluster 自動幫我們重定向到 6381 。在6381端口的實例中出現了我們之前設置的k1,說明整個集群是工作的。

八、redis的管理命令

config get parameter 用於讀取服務器的運行時參數，但是並不是所有的配置參數都可以通過該命令進行讀取。該命令的參數接受glob風格的模式匹配規則，因此如果參數中包含模式元字符，那么所有匹配的參數都將以key/value方式被列出。如果參數是*，那么該命令支持的所有參數都將被列出。

config set parameter value 該命令用於配置Redis服務器的運行時參數，在設置成功之后無需重啟便可生效。然而並非所有的參數都可以通過該命令進行動態設置。
dbsize 返回當前打開的數據庫中keys的數量。
flushall  清空當前服務器管理的數據庫中的所有keys，不僅限於當前打開的數據庫。
flushdb  清空當前數據庫中的所有keys。
info  獲取和服務器運行狀況相關的一些列統計數字。
save 設置RDB持久化模式的保存策略。
shutdown  停止所有的客戶端，同時以阻塞的方式執行內存數據持久化。如果AOF模式被啟用，則將緩存中的數據flush到AOF文件。退出服務器。
slaveof host port 該命令用於修改slave服務器的主從復制設置。
slowlog subcommand [argument] 該命令主要用於讀取執行時間較長的命令。由於slowlog隊列不會被持久化到磁盤，因此Redis在收集命令時不會對性能產生很大的影響。通常我們可以將參數"slowlog-log-slower-than"設置為0，以便收集所有命令的執行時間。該命令還包含以下幾個子命令：
1). slowlog get N: 從slowlog隊列中讀取命令信息，N表示最近N條命令的信息。
2). slowlog len：獲取slowlog隊列的長度。
3). slowlog reset：清空slowlog中的內容。

redis 127.0.0.1:6379> config get port
1) "port"
2) "6379"
redis 127.0.0.1:6379> keys *
1) "k1"
redis 127.0.0.1:6379> flushdb
OK
redis 127.0.0.1:6379> keys *
(empty list or set)
redis 127.0.0.1:6379> dbsize
(integer) 0
redis 127.0.0.1:6379> set k1 v1
OK
redis 127.0.0.1:6379> dbsize
(integer) 1

九、redis的java操作

maven依賴 

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.6.2</version>
    <type>jar</type>
    <scope>compile</scope>
</dependency>

 java代碼：

import redis.clients.jedis.Jedis;

public class RedisDao {

    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.set("k2", "v2");
        System.out.println(jedis.get("k2"));
        jedis.hset("k3", "f1", "v1");
        System.out.println(jedis.hget("k3", "f1"));
        System.out.println(jedis.keys("*"));
        jedis.close();
    }
}

十、redis與spring整合 

10.1 引入jedis包和spring包

10.2 spring-mvc.xml 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd" default-autowire="byName">

    <bean id="redisClient" class="com.eztcn.commons.redis.RedisClientFactoryBean">
        <!-- 單個應用中的鏈接池最大鏈接數，默認8 -->
        <property name="maxTotal" value="150" />
        <!-- 單個應用中的鏈接池最大空閑數，默認8 -->
        <property name="maxIdle" value="50" />
        <!-- 單個應用中的鏈接池最大鏈接數，默認8 -->
        <property name="minIdle" value="30" />
        <!-- 設置在每一次取對象時測試ping -->
        <property name="testOnBorrow" value="false" />
        <!-- host:port -->
          <property name="ipConfString" value="192.168.1.60:7001" /> 
    </bean>
</beans>

 當然需要在spring配置文件中引入該配置文件：<import resource="spring/spring-config-redis.xml" />

10.3 RedisClientFactoryBean.java 

package com.commons.redis;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.FactoryBean;

public class RedisClientFactoryBean implements FactoryBean<RedisClient> {
    private RedisClientConfig redisClientConfig = new RedisClientConfig();

    public RedisClient getObject() throws Exception {
        if (StringUtils.isNotBlank(this.redisClientConfig.getIpConfString())) {
            return new RedisClient(this.redisClientConfig);
        }
        throw new RedisInitializerException("RedisClient init parameter masterConfString is empty,please check spring config file!");
    }

    public Class<?> getObjectType() {
        return RedisClient.class;
    }

    public boolean isSingleton() {
        return true;
    }

    public void setIpConfString(String string) {
        this.redisClientConfig.setIpConfString(string);
    }

    public void setMaxTotal(int maxTotal) {
        this.redisClientConfig.setMaxTotal(maxTotal);
    }

    public void setMaxIdle(int maxIdle) {
        this.redisClientConfig.setMaxIdle(maxIdle);
    }

    public void setMinIdle(int minIdle) {
        this.redisClientConfig.setMinIdle(minIdle);
    }

    public void setTestOnBorrow(boolean flag) {
        this.redisClientConfig.setTestOnBorrow(flag);
    }
}

10.4 RedisClientConfig.java

package com.commons.redis;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

/**
 * 
 * @描述 : 配置redis的相關屬性
 * @創建時間： 2015年7月20日上午11:05:53
 *
 */
public class RedisClientConfig {
    private GenericObjectPoolConfig jedisPoolConfig = new GenericObjectPoolConfig();
    
    private String ipConfString;

    /**
     * 
     * @描述 : 單個應用中的鏈接池最大鏈接數
     * @創建時間： 2015年7月20日上午11:11:10
     *
     * @param maxTotal
     */
    public void setMaxTotal(int maxTotal) {
        this.jedisPoolConfig.setMaxTotal(maxTotal);
    }

    /**
     * @描述 :單個應用中的鏈接池最大空閑數 
     * @創建時間： 2015年7月20日上午11:11:28
     *
     * @param maxIdle
     */
    
    
    public void setMaxIdle(int maxIdle) {
        this.jedisPoolConfig.setMaxIdle(maxIdle);
    }

    
    /**
     * @描述 : 單個應用中的鏈接池最大鏈接數
     * @創建時間： 2015年7月20日上午11:11:43
     *
     * @param maxIdle
     */
    public void setMinIdle(int minIdle) {
        this.jedisPoolConfig.setMinIdle(minIdle);
    }

    /**
     * @描述 : 設置在每一次取對象時測試ping 
     * @創建時間： 2015年7月20日上午11:11:58
     *
     * @param flag
     */
    public void setTestOnBorrow(boolean flag) {
        this.jedisPoolConfig.setTestOnBorrow(flag);
    }

    public GenericObjectPoolConfig getJedisPoolConfig() {
        return this.jedisPoolConfig;
    }

    public String getIpConfString() {
        return this.ipConfString;
    }

    public void setIpConfString(String ipConfString) {
        this.ipConfString = ipConfString;
    }
}

10.5 RedisClient.java

package com.commons.redis;

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

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import redis.clients.jedis.BinaryClient;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

public class RedisClient {
    private static final Log LOG = LogFactory.getLog(RedisClient.class);
    private RedisClientConfig redisClientConfig;
    private JedisPool jedisPool;

    public RedisClient(RedisClientConfig redisClientConfig) {
        this.redisClientConfig = redisClientConfig;
        init();
    }

    /**
     * 
     * @描述 : 初始化，配置ip和端口
     * @創建時間： 2015年7月20日下午1:43:29
     *
     */
    private void init() {
        LOG.info("redis client init start~");
        String ip = "";
        int port;
        if (StringUtils.isNotBlank(this.redisClientConfig.getIpConfString())) {
            String[] ipPortArray = this.redisClientConfig.getIpConfString().split(":");
            if (ipPortArray.length == 1) {
                throw new RedisInitializerException(ipPortArray + " is not include host:port or host:port after split \":\"");
            }
            ip = ipPortArray[0];
            port = Integer.valueOf(ipPortArray[1]).intValue();
        } else {
            throw new RuntimeException("init throw exception");
        }
        LOG.info("write redis client connect ip:" + ip + ",port:" + port);
        this.jedisPool = new JedisPool(this.redisClientConfig.getJedisPoolConfig(), ip, port);
    }

    /**
     * 
     * @描述 : 設置鍵值對
     * @創建時間： 2015年7月20日下午1:44:10
     *
     * @param key
     * @param value
     * @return
     * @throws RedisAccessException
     */
    public String set(String key, String value) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.set(key, value);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 將值 value 關聯到 key ，並將 key 的生存時間設為 seconds (以秒為單位)。如果 key 已經存在， SETEX
     *     命令將覆寫舊值。
     * @創建時間： 2015年7月20日下午1:44:36
     *
     * @param key
     * @param seconds
     * @param value
     * @return
     * @throws RedisAccessException
     */
    public String set(String key, int seconds, String value) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.setex(key, seconds, value);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 如果 key 已經存在並且是一個字符串， APPEND 命令將 value 追加到 key 原來的值的末尾。 如果 key 不存在，
     *     APPEND 就簡單地將給定 key 設為 value ，就像執行 SET key value 一樣。
     * @創建時間： 2015年7月20日下午1:45:55
     *
     * @param key
     * @param value
     * @return
     * @throws RedisAccessException
     */
    public Long append(String key, String value) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.append(key, value);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 返回 key 所關聯的字符串值。如果 key 不存在那么返回特殊值 null 。 假如 key
     *     儲存的值不是字符串類型，返回一個錯誤，因為 GET 只能用於處理字符串值。
     * @創建時間： 2015年7月20日下午1:47:10
     *
     * @param key
     * @return
     * @throws RedisAccessException
     */
    public String get(String key) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.get(key);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 刪除給定的一個或多個 key 。 不存在的 key 會被忽略。
     * @創建時間： 2015年7月20日下午1:48:37
     *
     * @param key
     * @return
     * @throws RedisAccessException
     */
    public Long del(String key) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.del(key);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 檢查給定 key 是否存在。
     * @創建時間： 2015年7月20日下午1:48:48
     *
     * @param key
     * @return
     * @throws RedisAccessException
     */
    public Boolean exists(String key) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.exists(key);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * @描述 : 為給定 key 設置生存時間，當 key 過期時(生存時間為 0 )，它會被自動刪除。
     * @創建時間： 2015年7月20日下午1:49:29
     *
     * @param key
     * @param seconds
     * @return
     * @throws RedisAccessException
     */
    public Long expire(String key, int seconds) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.expire(key, seconds);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }
    
    
    
    /**
     * @描述 : 為給定 key 設置生存時間，當 key 過期時(生存時間為 0 )，它會被自動刪除。
     * @創建時間： 2015年7月20日下午1:49:29
     *
     * @param key
     * @param seconds
     * @return
     * @throws RedisAccessException
     */
    public Long expireAt(String key, long unixTime) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.expireAt(key,unixTime);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 將給定 key 的值設為 value ，並返回 key 的舊值(old value)。當 key
     *     存在但不是字符串類型時，返回一個錯誤。
     * @創建時間： 2015年7月20日下午1:50:28
     *
     * @param key
     * @param value
     * @return
     * @throws RedisAccessException
     */
    public String getSet(String key, String value) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.getSet(key, value);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 將 key 的值設為 value ，當且僅當 key 不存在。若給定的 key 已經存在，則 SETNX 不做任何動作。
     * @創建時間： 2015年7月20日下午1:52:07
     *
     * @param key
     * @param value
     * @return
     * @throws RedisAccessException
     */
    public Long setnx(String key, String value) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.setnx(key, value);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 將哈希表 key 中的域 field 的值設為 value 。 如果 key 不存在，一個新的哈希表被創建並進行 HSET操作。
     *     如果域 field 已經存在於哈希表中，舊值將被覆蓋。
     * @創建時間： 2015年7月20日下午1:53:23
     *
     * @param key
     * @param field
     * @param value
     * @return
     * @throws RedisAccessException
     */
    public Long hset(String key, String field, String value) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.hset(key, field, value);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 :返回哈希表 key 中給定域 field 的值。
     * @創建時間： 2015年7月20日下午1:54:24
     *
     * @param key
     * @param field
     * @return
     * @throws RedisAccessException
     */
    public String hget(String key, String field) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.hget(key, field);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 將哈希表 key 中的域 field 的值設置為 value ，當且僅當域 field 不存在。若域 field
     *     已經存在，該操作無效。 如果 key 不存在，一個新哈希表被創建並執行 HSETNX 命令。
     * @創建時間： 2015年7月20日下午1:54:44
     *
     * @param key
     * @param field
     * @param value
     * @return
     * @throws RedisAccessException
     */
    public Long hsetnx(String key, String field, String value) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.hsetnx(key, field, value);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 :同時將多個 field-value (域-值)對設置到哈希表 key 中。此命令會覆蓋哈希表中已存在的域。 如果 key
     *     不存在，一個空哈希表被創建並執行 HMSET 操作。
     * @創建時間： 2015年7月20日下午1:58:26
     *
     * @param key
     * @param hash
     * @return
     * @throws RedisAccessException
     */
    public String hmset(String key, Map<String, String> hash) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.hmset(key, hash);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 返回哈希表 key 中，一個或多個給定域的值。如果給定的域不存在於哈希表，那么返回一個 null 值。 因為不存在的 key
     *     被當作一個空哈希表來處理，所以對一個不存在的 key 進行 HMGET 操作將返回一個只帶有 null 值的表。
     * @創建時間： 2015年7月20日下午1:57:32
     *
     * @param key
     * @param fields
     * @return
     * @throws RedisAccessException
     */
    public List<String> hmget(String key, String[] fields) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.hmget(key, fields);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 :刪除哈希表 key 中的一個或多個指定域，不存在的域將被忽略。
     * @創建時間： 2015年7月20日下午1:59:32
     *
     * @param key
     * @param fields
     * @return
     * @throws RedisAccessException
     */
    public Long hdel(String key, String[] fields) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.hdel(key, fields);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 返回哈希表 key 中域的數量。
     * @創建時間： 2015年7月20日下午2:00:13
     *
     * @param key
     * @return
     * @throws RedisAccessException
     */
    public Long hlen(String key) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.hlen(key);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 :返回哈希表 key 中的所有域。
     * @創建時間： 2015年7月20日下午2:00:59
     *
     * @param key
     * @return
     * @throws RedisAccessException
     */
    public Set<String> hkeys(String key) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.hkeys(key);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 返回哈希表 key 中所有域的值。
     * @創建時間： 2015年7月20日下午2:01:06
     *
     * @param key
     * @return
     * @throws RedisAccessException
     */
    public List<String> hvals(String key) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.hvals(key);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 返回哈希表 key 中，所有的域和值。在返回值里，緊跟每個域名(field
     *     name)之后是域的值(value)，所以返回值的長度是哈希表大小的兩倍。
     * @創建時間： 2015年7月20日下午2:01:36
     *
     * @param key
     * @return
     * @throws RedisAccessException
     */
    public Map<String, String> hgetAll(String key) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.hgetAll(key);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 :查看哈希表 key 中，給定域 field 是否存在。
     * @創建時間： 2015年7月20日下午2:02:38
     *
     * @param key
     * @param field
     * @return
     * @throws RedisAccessException
     */
    public Boolean hexists(String key, String field) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.hexists(key, field);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 將一個或多個值 value 插入到列表 key 的表尾(最右邊)。
     * @創建時間： 2015年7月20日下午2:02:44
     *
     * @param key
     * @param values
     * @return
     * @throws RedisAccessException
     */
    public Long rpush(String key, String[] values) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.rpush(key, values);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 將值 value 插入到列表 key 的表尾，當且僅當 key 存在並且是一個列表。
     * @創建時間： 2015年7月20日下午2:03:20
     *
     * @param key
     * @param value
     * @return
     * @throws RedisAccessException
     */
    public Long rpushx(String key, String value) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.rpushx(key, new String[] { value });
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 將一個或多個值 value 插入到列表 key 的表頭
     * @創建時間： 2015年7月20日下午2:04:13
     *
     * @param key
     * @param values
     * @return
     * @throws RedisAccessException
     */
    public Long lpush(String key, String[] values) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.lpush(key, values);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 將值 value 插入到列表 key 的表頭，當且僅當 key 存在並且是一個列表。 和 LPUSH 命令相反，當 key 不存在時，
     *     LPUSHX 命令什么也不做。
     * @創建時間： 2015年7月20日下午2:05:09
     *
     * @param key
     * @param value
     * @return
     * @throws RedisAccessException
     */
    public Long lpushx(String key, String value) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.lpushx(key, new String[] { value });
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 返回列表 key 的長度。如果 key 不存在，則 key 被解釋為一個空列表，返回 0 . 如果 key
     *     不是列表類型，返回一個錯誤。
     * @創建時間： 2015年7月20日下午2:05:25
     *
     * @param key
     * @return
     * @throws RedisAccessException
     */
    public Long llen(String key) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.llen(key);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 返回列表 key 中，下標為 index 的元素。
     * @創建時間： 2015年7月20日下午2:05:37
     *
     * @param key
     * @param index
     * @return
     * @throws RedisAccessException
     */
    public String lindex(String key, long index) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.lindex(key, index);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 將列表 key 下標為 index 的元素的值設置為 value 。當 index 參數超出范圍，或對一個空列表( key
     *     不存在)進行 LSET 時，返回一個錯誤。
     * @創建時間： 2015年7月20日下午2:07:06
     *
     * @param key
     * @param index
     * @param value
     * @return
     * @throws RedisAccessException
     */
    public String lset(String key, long index, String value) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.lset(key, index, value);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 移除並返回列表 key 的頭元素。
     * @創建時間： 2015年7月20日下午2:07:10
     *
     * @param key
     * @return
     * @throws RedisAccessException
     */
    public String lpop(String key) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.lpop(key);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 移除並返回列表 key 的尾元素。
     * @創建時間： 2015年7月20日下午2:07:13
     *
     * @param key
     * @return
     * @throws RedisAccessException
     */
    public String rpop(String key) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.rpop(key);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

    /**
     * 
     * @描述 : 將值 value 插入到列表 key 當中，位於值 pivot 之前或之后。當 pivot 不存在於列表 key 時，不執行任何操作。
     *     key 不存在時， key 被視為空列表，不執行任何操作。 如果 key 不是列表類型，返回一個錯誤。
     * @創建時間： 2015年7月20日下午2:07:37
     *
     * @param key
     * @param where
     * @param pivot
     * @param value
     * @return
     * @throws RedisAccessException
     */
    public Long linsert(String key, BinaryClient.LIST_POSITION where, String pivot, String value) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.linsert(key, where, pivot, value);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }
    
    /**
     * @描述 : 將 key 中儲存的數字值增一。如果 key 不存在，那么 key 的值會先被初始化為 0 ，然后再執行 INCR 操作。
     * @創建時間： 2014-6-16下午2:31:58
     * 
     * @param key
     * @return
     * @throws RedisAccessException
     */
    public Long incr(String key) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.incr(key);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }
    
    
    /**
     * @描述 :  將 key 所儲存的值加上增量 increment 。如果 key 不存在，那么 key 的值會先被初始化為 0 ，然后再執行  INCRBY 命令。
     * @創建時間： 2014-6-16下午2:31:58
     * 
     * @param key
     * @return
     * @throws RedisAccessException
     */
    public double incrBy(String key,long value) throws RedisAccessException {
        Jedis client = null;
        try {
            client = jedisPool.getResource();
            return client.incrBy(key, value);
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new RedisAccessException(e);
        } finally {
            if (null != client) {
                jedisPool.returnResourceObject(client);
            }
        }
    }

}

OK，這個關於redis的相關內容更新完畢！ 

本文地址： http://www.cnblogs.com/gzy-blog/p/6058849.html