Redis使用手冊

時間 2019-11-14

標籤 redis 使用手冊欄目 Redis 简体版

原文原文鏈接

簡介

Redis 是一個開源的使用 ANSI C 語言編寫、支持網絡、可基於內存亦可持久化的日誌型、 Key-Value數據庫。 java

Redis面向互聯網的方案提供了三種形式：node

1.主從mysql

主機進行寫操做，從機進行讀操做，主節點若是掛了，集羣就不可用了linux

2.哨兵redis

哨兵節點部署到新服務器上，實時監控主從節點狀態，若是主節點掛了，集羣在從節點中進行選舉，選出性能最高的升級爲主節點，當原來的主節點修復好後，會成爲一個新的從節點加入進來spring

3.集羣sql

多個主從組合，靈活性很強，原來的1G數據能夠分紅N份存儲，其中一臺主機故障，也能夠將對應的從機升級爲主機，保證數據的安全性數據庫

Linux上的安裝過程

下載地址http://redis.io/download 安裝步驟：
1 首先須要安裝gcc，把下載好的redis-3.0.0-rc2.tar.gz 放到linux /usr/local文件夾下
2 進行解壓 tar -zxvf redis-3.0.0-rc2.tar.gz
3 進入到redis-3.0.0目錄下，進行編譯 make
4 進入到src下進行安裝 make install 驗證(ll查看src下的目錄，有redis-server 、redis-cil便可)
5 創建倆個文件夾存放redis命令和配置文件
mkdir -p /usr/local/redis/etc
mkdir -p /usr/local/redis/bin
6 把redis-3.0.0下的redis.conf 移動到/usr/local/redis/etc下，
cp redis.conf /usr/local/redis/etc/
7 把redis-3.0.0/src裏的mkreleasehdr.sh、redis-benchmark、redis-check-aof、redis-check-dump、redis-cli、redis-server
文件移動到bin下，命令：
mv mkreleasehdr.sh redis-benchmark redis-check-aof redis-check-dump redis-cli redis-server /usr/local/redis/bin
8 啓動時並指定配置文件：./redis-server /usr/local/redis/etc/redis.conf（注意要使用後臺啓動，因此修改redis.conf裏的 daemonize 改成yes)
9 驗證啓動是否成功： ps -ef | grep redis 查看是否有redis服務或者查看端口：netstat -tunpl | grep 6379
進入redis客戶端 ./redis-cli 退出客戶端quit 退出redis服務：
（1）pkill redis-server 、
（2）kill 進程號、
（3）/usr/local/redis/bin/redis-cli shutdownapache

數據類型

redis提供五種數據類型： string,hash,list,set 及Zset。
數組

string

string是最基本的類型，並且 string類型是二進制安全的。意思是 redis的 string能夠包含任何數據。好比 jpg圖片或者序列化的對象。
從內部實現來看其實 string能夠看做 byte 數組，最大上限是 1G字節。

string類型數據操做指令簡介

set key value 設置 key對應 string 類型的值，返回 1 表示成功， 0失敗。
setnx key value 若是 key 不存在，設置 key 對應 string 類型的值。若是 key 已經存在，返回 0。
setex key 10 value 設置key的有效期爲10秒，10秒後返回nil（表示空）
setrange key 10 ww 從key的value的第10位開始替換，後面跟上替換的字符串，這裏是ww。注意，索引從0開始
getkey 獲取 key對應的 string值,若是 key不存在返回 nil
getsetkey value 先獲取 key的值，再設置 key的值。若是 key不存在返回 nil。
mget key1 key2 ......keyN 一次獲取多個key 的值，若是對應 key不存在，則對應返回 nil。
mset key1 value1 ......keyN valueN 一次設置多個 key的值，成功返回 1表示全部的值都設置
了，失敗返回 0 表示沒有任何值被設置。
msetnx key1 value1 ......keyN valueN 一次設置多個 key的值，可是不會覆蓋已經存在的 key
incr key 對 key 的值作++操做，並返回新的值。注意 incr一個不是 int 的 value 會返回錯
誤， incr一個不存在的 key，則設置 key值爲 1。
decr key 對 key的值作 -- 操做， decr一個不存在 key，則設置 key值爲-1。
incrby key integer 對 key 加上指定值， key 不存在時候會設置 key，並認爲原來的 value
是 0。
decrby key integer 對key減去指定值。decrby徹底是爲了可讀性，咱們徹底能夠經過incrby
一個負值來實現一樣效果，反之同樣。
del key 刪除key對應的值
append key value 對key字符串追加上value
strlen key 獲取key的長度

hash

hash 是一個 string類型的 field 和 value 的映射表。或者說是一個string的集合。
hash特別適合用於存儲對象。相對於將對象的每一個字段存成單個 string 類型。將一個對象
存儲在 hash 類型中會佔用更少的內存，而且能夠更方便的存取整個對象。

hash類型數據操做指令簡介

hset key field value 設置 hash field爲指定值，若是 key不存在，則建立
hget key field 獲取指定的 hash field。
hmget key filed1....fieldN 獲取所有指定的 hash filed。
hmset key filed1 value1 ......filedN valueN 同時設置hash的多個 field。
hincrby key field integer 將指定的 hash filed 加上指定值。成功返回 hash filed 變動後的
值。
一樣也有nx
hexists key field 檢測指定 field是否存在。
hdel key field 刪除指定的 hash field。
hlen key 返回指定 hash的 field 數量。
hkeys key 返回hash的全部field。
hvals key 返回hash的全部value。
hgetall 返回hash的全部filed和value 。

list

list是一個鏈表結構，能夠理解爲一個每一個子元素都是 string類型的雙向鏈表。主要功
能是push、 pop、獲取一個範圍的全部值等。操做中key理解爲鏈表的名字。

List類型數據操做指令簡介

lpush key string 在key對應list的頭部添加字符串元素，返回1表示成功， 0表示key存
在且不是list類型。
rpush key string在key對應list的尾部添加字符串元素。
linsert key before [集合的元素] [插入的元素] 在集合元素前插入元素
llen key 返回key對應list的長度，若是key不存在返回0，若是key對應類型不是list
返回錯誤。
lrange key start end 返回指定區間內的元素，下標從0開始，負值表示從後面計算， -1表示
倒數第一個元素， key不存在返回空列表。
ltrim key start end 截取list指定區間內元素，成功返回1， key不存在返回錯誤。
lset key index value 設置list中指定下標的元素值，成功返回1， key或者下標不存在返回
錯誤。
lrem key count value從 List 的頭部（ count正數）或尾部（ count負數）刪除必定數量（ count）
匹配value的元素，返回刪除的元素數量。 count爲0時候刪除所有。
lpop key 從list的頭部刪除並返回刪除元素。若是key對應list不存在或者是空返回nil，
若是key對應值不是list返回錯誤。
rpop key從list的尾部刪除並返回刪除元素。
blpop key1 ......keyN timeout 從左到右掃描，返回對第一個非空list進行lpop操做並返回，
好比blpop list1 list2 list3 0 ,若是list不存在list2,list3都是非空則對list2作
lpop並返回從list2中刪除的元素。若是全部的list都是空或不存在，則會阻塞timeout
秒， timeout爲0表示一直阻塞。當阻塞時，若是有 client對key1...keyN中的任意key
進行push操做，則第一在這個key上被阻塞的client會當即返回。若是超時發生，則返回
nil。有點像unix的select或者poll。
brpop 同blpop，一個是從頭部刪除一個是從尾部刪除。
lindex key [索引] 返回名稱爲key的list中指定索引處的元素

set

set是無序集合，最大能夠包含(2的 32次方-1)個元素。 set的是經過 hashtable實現的，
除了基本的添加刪除操做，其它有用的操做還包含集合的取並集(union)，交集(intersection)，
差集(difference)。

set類型數據操做指令簡介

sadd key member 添加一個 string 元素到 key 對應 set 集合中，成功返回 1,若是元素以及
在集合中則返回0， key 對應的 set不存在則返回錯誤。
srem key member 從 key 對應 set 中移除指定元素，成功返回 1，若是 member 在集合中不
存在或者 key不存在返回 0，若是 key對應的不是 set類型的值返回錯誤。
spop key 刪除並返回 key 對應 set 中隨機的一個元素,若是 set 是空或者 key 不存在返回
nil。
srandmember key 同 spop，隨機取 set中的一個元素，可是不刪除元素。
smove srckey dstkey member 從srckey對應set中移除member並添加到dstkey對應set中，
整個操做是原子的。成功返回 1,若是 member在 srckey中不存在返回 0，若是 key 不是 set
類型返回錯誤。
scardkey 返回 set的元素個數，若是 set是空或者 key不存在返回 0。
sismember key member 判斷 member 是否在 set 中，存在返回 1， 0 表示不存在或者 key 不
存在。
sinterkey1 key2 …… keyN 返回全部給定key 的交集。
sinterstoredstkey key1 ....... keyN 返回全部給定 key的交集，並保存交集存到 dstkey下。
sunion key1 key2 ...... keyN 返回全部給定 key的並集。
sunionstoredstkey key1 ......keyN 返回全部給定 key的並集，並保存並集到 dstkey下。
sdiffkey1 key2 ......keyN 返回全部給定 key 的差集。
sdiffstoredstkey key1 ......keyN 返回全部給定 key的差集，並保存差集到 dstkey下。
smembers key 返回 key 對應set 的全部元素，結果是無序的。

zset

又叫sorted set 是有序集合，它在 set 的基礎上增長了一個順序屬性，這一屬性在添加修
改元素的時候能夠指定，每次指定後，會自動從新按新的值調整順序。能夠理解了有兩列的
mysql表，一列存 value，一列存順序。操做中key 理解爲 sorted set的名字。

ZSet 類型數據操做指令簡介

zadd key score member 添加元素到集合，元素在集合中存在則更新對應 score。
zrem key member 刪除指定元素， 1表示成功，若是元素不存在返回 0。
zincrby key incrmember 增長對應 member的 score值，而後移動元素並保持 skip list保持有
序。返回更新後的 score值。
zrank key member 返回指定元素在集合中的排名（下標），集合中元素是按 score從小到大
排序的。
zrevrankkey member 同上,可是集合中元素是按 score從大到小排序。
zrangekey start end 相似 lrange操做從集合中去指定區間的元素。返回的是有序結果
zrevrangekey start end 同上，返回結果是按 score逆序的。
zrangebyscorekey min max 返回集合中 score在給定區間的元素。
zcount key min max 返回集合中 score在給定區間的數量。
zcardkey 返回集合中元素個數。
zscorekey element 返回給定元素對應的 score。
zremrangebyrank key min max 刪除集合中排名在給定區間的元素。
zremrangebyscorekey min max 刪除集合中 score在給定區間的元素

其餘經常使用命令

實例：自行與上圖匹配

keys *

keys list*

expire name 5

ttl name

persisit name

select 12

move name 2

rename name name1

Redis設置密碼

主從複製

哨兵

持久化

一般 Redis 將數據存儲在內存中或虛擬內存中，它是經過如下兩種方式實現對數據的持
久化。
1. 快照方式：（默認持久化方式）
這種方式就是將內存中數據以快照的方式寫入到二進制文件中，默認的文件名爲
dump.rdb。
客戶端也可使用 save或者 bgsave 命令通知 redis作一次快照持久化。save 操做是在
主線程中保存快照的，因爲 redis 是用一個主線程來處理全部客戶端的請求，這種方式會阻
塞全部客戶端請求。因此不推薦使用。另外一點須要注意的是，每次快照持久化都是將內存數
據完整寫入到磁盤一次，並非增量的只同步增量數據。若是數據量大的話，寫操做會比較
多，必然會引發大量的磁盤 IO操做，可能會嚴重影響性能。
注意：因爲快照方式是在必定間隔時間作一次的，因此若是 redis意外當機的話，就會
丟失最後一次快照後的全部數據修改。
2. 日誌追加方式：
這種方式 redis 會將每個收到的寫命令都經過 write 函數追加到文件中(默認
appendonly.aof)。當 redis 重啓時會經過從新執行文件中保存的寫命令來在內存中重建整
個數據庫的內容。固然因爲操做系統會在內核中緩存 write作的修改，因此可能不是當即寫
到磁盤上。這樣的持久化仍是有可能會丟失部分修改。不過咱們能夠經過配置文件告訴
redis咱們想要經過 fsync 函數強制操做系統寫入到磁盤的時機。有三種方式以下（默認是：
每秒 fsync 一次）

appendonly yes	//啓用日誌追加持久化方式
#appendfsync always	//每次收到寫命令就當即強制寫入磁盤，最慢的，可是保證徹底的持久化
#appendfsync everysec	//每秒鐘強制寫入磁盤一次，在性能和持久化方面作了很好的折中
#appendfsync no	//徹底依賴操做系統，性能最好,持久化沒保證

日誌追加方式同時帶來了另外一個問題。持久化文件會變的愈來愈大。例如咱們調用 incr
test命令 100次，文件中必須保存所有 100條命令，其實有 99條都是多餘的。由於要恢復
數據庫狀態其實文件中保存一條 set test 100就夠了。爲了壓縮這種持久化方式的日誌文件。
redis提供了 bgrewriteaof命令。收到此命令 redis將使用與快照相似的方式將內存中的數據
以命令的方式保存到臨時文件中，最後替換原來的持久化日誌文件。

JAVA操做

  1 import java.util.Arrays;
  2 import java.util.HashMap;
  3 import java.util.Iterator;
  4 import java.util.List;
  5 import java.util.Map;
  6 
  7 import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
  8 import org.junit.AfterClass;
  9 import org.junit.BeforeClass;
 10 import org.junit.Test;
 11 
 12 import redis.clients.jedis.Jedis;
 13 import redis.clients.jedis.JedisShardInfo;
 14 import redis.clients.jedis.Pipeline;
 15 import redis.clients.jedis.ShardedJedis;
 16 import redis.clients.jedis.ShardedJedisPipeline;
 17 import redis.clients.jedis.ShardedJedisPool;
 18 import redis.clients.jedis.Transaction;
 19  
 20 public class TestSingleRedis {
 21     //單獨鏈接一臺Redis服務器
 22     private static Jedis jedis;
 23     //主從，哨兵使用Sharded
 24     private static ShardedJedis shard;
 25     //鏈接池
 26     private static ShardedJedisPool pool;
 27  
 28     @BeforeClass
 29     public static void setUpBeforeClass() throws Exception {
 30         //單個節點
 31         jedis = new Jedis("192.168.1.101", 6379);
 32         
 33         //分片
 34         List<JedisShardInfo> shards = Arrays.asList(
 35                 new JedisShardInfo("192.168.1.106",6379)); 
 36         shard = new ShardedJedis(shards);
 37  
 38         GenericObjectPoolConfig goConfig = new GenericObjectPoolConfig();
 39         goConfig.setMaxTotal(100);
 40         goConfig.setMaxIdle(20);
 41         goConfig.setMaxWaitMillis(-1);
 42         goConfig.setTestOnBorrow(true);        
 43         pool = new ShardedJedisPool(goConfig, shards);
 44     }
 45  
 46     @AfterClass
 47     public static void tearDownAfterClass() throws Exception {
 48         jedis.disconnect();
 49         shard.disconnect();
 50         pool.destroy();
 51     }
 52  
 53     @Test
 54     public void testString() {
 55         //-----添加數據----------  
 56         jedis.set("name","bhz");//向key-->name中放入了value-->xinxin  
 57         System.out.println(jedis.get("name"));//執行結果：xinxin  
 58         
 59         jedis.append("name", " is my lover"); //拼接
 60         System.out.println(jedis.get("name")); 
 61         
 62         jedis.del("name");  //刪除某個鍵
 63         System.out.println(jedis.get("name"));
 64         //設置多個鍵值對
 65         jedis.mset("name","bhz","age","27","qq","174754613");
 66         jedis.incr("age"); //進行加1操做
 67         System.out.println(jedis.get("name") + "-" + jedis.get("age") + "-" + jedis.get("qq"));
 68     }
 69     
 70     /**
 71      * redis操做Map
 72      */
 73     @Test
 74     public void testMap() {
 75         //-----添加數據----------  
 76         Map<String, String> map = new HashMap<String, String>();
 77         map.put("name", "xinxin");
 78         map.put("age", "22");
 79         map.put("qq", "123456");
 80         jedis.hmset("user",map);
 81         //取出user中的name，執行結果:[minxr]-->注意結果是一個泛型的List  
 82         //第一個參數是存入redis中map對象的key，後面跟的是放入map中的對象的key，後面的key能夠跟多個，是可變參數  
 83         List<String> rsmap = jedis.hmget("user", "name", "age", "qq");
 84         System.out.println(rsmap);  
 85         //刪除map中的某個鍵值  
 86         jedis.hdel("user","age");
 87         System.out.println(jedis.hmget("user", "age")); //由於刪除了，因此返回的是null  
 88         System.out.println(jedis.hlen("user")); //返回key爲user的鍵中存放的值的個數2 
 89         System.out.println(jedis.exists("user"));//是否存在key爲user的記錄 返回true  
 90         System.out.println(jedis.hkeys("user"));//返回map對象中的全部key  
 91         System.out.println(jedis.hvals("user"));//返回map對象中的全部value 
 92   
 93         Iterator<String> iter=jedis.hkeys("user").iterator();  
 94         while (iter.hasNext()){  
 95             String key = iter.next();  
 96             System.out.println(key+":"+jedis.hmget("user",key));  
 97         }  
 98     }
 99     
100     /** 
101      * jedis操做List 
102      */  
103     @Test  
104     public void testList(){  
105         //開始前，先移除全部的內容  
106         jedis.del("java framework");  
107         System.out.println(jedis.lrange("java framework",0,-1));  
108         //先向key java framework中存放三條數據  
109         jedis.lpush("java framework","spring");  
110         jedis.lpush("java framework","struts");  
111         jedis.lpush("java framework","hibernate");  
112         //再取出全部數據jedis.lrange是按範圍取出，  
113         // 第一個是key，第二個是起始位置，第三個是結束位置，jedis.llen獲取長度 -1表示取得全部  
114         System.out.println(jedis.lrange("java framework",0,-1));  
115         
116         jedis.del("java framework");
117         jedis.rpush("java framework","spring");  
118         jedis.rpush("java framework","struts");  
119         jedis.rpush("java framework","hibernate"); 
120         System.out.println(jedis.lrange("java framework",0,-1));
121     }  
122     
123     /** 
124      * jedis操做Set 
125      */  
126     @Test  
127     public void testSet(){  
128         //添加  
129         jedis.sadd("user","liuling");  
130         jedis.sadd("user","xinxin");  
131         jedis.sadd("user","ling");  
132         jedis.sadd("user","zhangxinxin");
133         jedis.sadd("user","who");  
134         //移除noname  
135         jedis.srem("user","who");  
136         System.out.println(jedis.smembers("user"));//獲取全部加入的value  
137         System.out.println(jedis.sismember("user", "who"));//判斷 who 是不是user集合的元素  
138         System.out.println(jedis.srandmember("user"));  
139         System.out.println(jedis.scard("user"));//返回集合的元素個數  
140     } 
141     
142     @Test  
143     public void testRLpush() throws InterruptedException {  
144         //jedis 排序  
145         //注意，此處的rpush和lpush是List的操做。是一個雙向鏈表（但從表現來看的）  
146         jedis.del("a");//先清除數據，再加入數據進行測試  
147         jedis.rpush("a", "1");  
148         jedis.lpush("a","6");  
149         jedis.lpush("a","3");  
150         jedis.lpush("a","9");  
151         System.out.println(jedis.lrange("a",0,-1));// [9, 3, 6, 1]  
152         System.out.println(jedis.sort("a")); //[1, 3, 6, 9]  //輸入排序後結果  
153         System.out.println(jedis.lrange("a",0,-1));  
154     }  
155  
156     @Test
157     public void testTrans() {
158         long start = System.currentTimeMillis();
159         Transaction tx = jedis.multi();
160         for (int i = 0; i < 1000; i++) {
161             tx.set("t" + i, "t" + i);
162         }
163         //System.out.println(tx.get("t1000").get());
164  
165         List<Object> results = tx.exec();
166         long end = System.currentTimeMillis();
167         System.out.println("Transaction SET: " + ((end - start)/1000.0) + " seconds");
168     }
169  
170     @Test
171     public void testPipelined() {
172         Pipeline pipeline = jedis.pipelined();
173         long start = System.currentTimeMillis();
174         for (int i = 0; i < 1000; i++) {
175             pipeline.set("p" + i, "p" + i);
176         }
177         //System.out.println(pipeline.get("p1000").get());
178         List<Object> results = pipeline.syncAndReturnAll();
179         long end = System.currentTimeMillis();
180         System.out.println("Pipelined SET: " + ((end - start)/1000.0) + " seconds");
181     }
182  
183     @Test
184     public void testPipelineTrans() {
185         long start = System.currentTimeMillis();
186         Pipeline pipeline = jedis.pipelined();
187         pipeline.multi();
188         for (int i = 0; i < 100000; i++) {
189             pipeline.set("" + i, "" + i);
190         }
191         pipeline.exec();
192         List<Object> results = pipeline.syncAndReturnAll();
193         long end = System.currentTimeMillis();
194         System.out.println("Pipelined transaction SET: " + ((end - start)/1000.0) + " seconds");
195     }
196  
197     @Test
198     public void testShard() {
199         long start = System.currentTimeMillis();
200         for (int i = 0; i < 100000; i++) {
201             String result = shard.set("shard" + i, "n" + i);
202         }
203         long end = System.currentTimeMillis();
204         System.out.println("shard SET: " + ((end - start)/1000.0) + " seconds");
205     }
206  
207     @Test
208     public void testShardpipelined() {
209         ShardedJedisPipeline pipeline = shard.pipelined();
210         long start = System.currentTimeMillis();
211         for (int i = 0; i < 100000; i++) {
212             pipeline.set("sp" + i, "p" + i);
213         }
214         List<Object> results = pipeline.syncAndReturnAll();
215         long end = System.currentTimeMillis();
216         System.out.println("shardPipelined SET: " + ((end - start)/1000.0) + " seconds");
217     }
218  
219     @Test
220     public void testShardPool() {
221         ShardedJedis sj = pool.getResource();
222  
223         long start = System.currentTimeMillis();
224         for (int i = 0; i < 100000; i++) {
225             String result = sj.set("spn" + i, "n" + i);
226         }
227         long end = System.currentTimeMillis();
228         pool.returnResource(sj);
229         System.out.println("shardPool SET: " + ((end - start)/1000.0) + " seconds");
230     }
231  
232 }

View Code

集羣化（重點）

這裏的7001是7004的主節點，7002是7005的主節點，以此類推，有這樣的順序要求

java操做集羣

 1 import java.util.HashSet;
 2 import java.util.Set;
 3 
 4 import redis.clients.jedis.HostAndPort;
 5 import redis.clients.jedis.JedisCluster;
 6 import redis.clients.jedis.JedisPoolConfig;
 7 
 8 public class TestClusterRedis {
 9 
10     public static void main(String[] args) {
11         
12         Set<HostAndPort> jedisClusterNode = new HashSet<HostAndPort>();
13         jedisClusterNode.add(new HostAndPort("192.168.1.171", 7001));
14         jedisClusterNode.add(new HostAndPort("192.168.1.171", 7002));
15         jedisClusterNode.add(new HostAndPort("192.168.1.171", 7003));
16         jedisClusterNode.add(new HostAndPort("192.168.1.171", 7004));
17         jedisClusterNode.add(new HostAndPort("192.168.1.171", 7005));
18         jedisClusterNode.add(new HostAndPort("192.168.1.171", 7006));
19         //GenericObjectPoolConfig goConfig = new GenericObjectPoolConfig();
20         //JedisCluster jc = new JedisCluster(jedisClusterNode,2000,100, goConfig);
21         JedisPoolConfig cfg = new JedisPoolConfig();
22         cfg.setMaxTotal(100);
23         cfg.setMaxIdle(20);
24         cfg.setMaxWaitMillis(-1);
25         cfg.setTestOnBorrow(true); 
26         JedisCluster jc = new JedisCluster(jedisClusterNode,6000,1000,cfg);        
27         
28         System.out.println(jc.set("age","20"));
29         System.out.println(jc.set("sex","男"));
30         System.out.println(jc.get("name"));
31         System.out.println(jc.get("age"));
32         System.out.println(jc.get("sex"));
33         jc.close();
34         
35         
36     }
37     
38 }

View Code

Spring整合集羣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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop"
    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">

    <context:property-placeholder location="classpath:redis.properties" />
    <context:component-scan base-package="com.x.redis.dao">
    </context:component-scan>
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}" />
        <property name="maxTotal" value="${redis.maxActive}" />
        <property name="maxWaitMillis" value="${redis.maxWait}" />
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean>

    <bean id="hostport1" class="redis.clients.jedis.HostAndPort">
        <constructor-arg name="host" value="10.16.68.92" />
        <constructor-arg name="port" value="7770" />
    </bean>
    <bean id="hostport2" class="redis.clients.jedis.HostAndPort">
        <constructor-arg name="host" value="10.16.68.92" />
        <constructor-arg name="port" value="7771" />
    </bean>
    <bean id="hostport3" class="redis.clients.jedis.HostAndPort">
        <constructor-arg name="host" value="10.16.68.92" />
        <constructor-arg name="port" value="7772" />
    </bean>
    <bean id="hostport4" class="redis.clients.jedis.HostAndPort">
        <constructor-arg name="host" value="10.16.68.92" />
        <constructor-arg name="port" value="7773" />
    </bean>
    <bean id="hostport5" class="redis.clients.jedis.HostAndPort">
        <constructor-arg name="host" value="10.16.68.92" />
        <constructor-arg name="port" value="7774" />
    </bean>
    <bean id="hostport6" class="redis.clients.jedis.HostAndPort">
        <constructor-arg name="host" value="10.16.68.92" />
        <constructor-arg name="port" value="7775" />
    </bean>

    <bean id="redisCluster" class="redis.clients.jedis.JedisCluster">
        <constructor-arg name="nodes">
            <set>
                <ref bean="hostport1" />
                <ref bean="hostport2" />
                <ref bean="hostport3" />
                <ref bean="hostport4" />
                <ref bean="hostport5" />
                <ref bean="hostport6" />
            </set>
        </constructor-arg>
        <constructor-arg name="timeout" value="6000" />
        <constructor-arg name="poolConfig">
            <ref bean="jedisPoolConfig" />
        </constructor-arg>
    </bean>
</beans>

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。