Redis使用手册

简介

Redis 是一个开源的使用 ANSI C 语言编写、支持网络、可基于内存亦可持久化的日志型、 Key-Value数据库。

Redis面向互联网的方案提供了三种形式：

1.主从

主机进行写操作，从机进行读操作，主节点如果挂了，集群就不可用了

2.哨兵

哨兵节点部署到新服务器上，实时监控主从节点状态，如果主节点挂了，集群在从节点中进行选举，选出性能最高的升级为主节点，当原来的主节点修复好后，会成为一个新的从节点加入进来

3.集群

多个主从组合，灵活性很强，原来的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 shutdown

数据类型

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操作

 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
 import org.junit.Test;

 import redis.clients.jedis.Jedis;
 import redis.clients.jedis.JedisShardInfo;
 import redis.clients.jedis.Pipeline;
 import redis.clients.jedis.ShardedJedis;
 import redis.clients.jedis.ShardedJedisPipeline;
 import redis.clients.jedis.ShardedJedisPool;
 import redis.clients.jedis.Transaction;

 public class TestSingleRedis {
     //单独连接一台Redis服务器
     private static Jedis jedis;
     //主从，哨兵使用Sharded
     private static ShardedJedis shard;
     //连接池
     private static ShardedJedisPool pool;

     @BeforeClass
     public static void setUpBeforeClass() throws Exception {
         //单个节点
         jedis = new Jedis("192.168.1.101", 6379);

         //分片
         List<JedisShardInfo> shards = Arrays.asList(
                 new JedisShardInfo("192.168.1.106",6379));
         shard = new ShardedJedis(shards);

         GenericObjectPoolConfig goConfig = new GenericObjectPoolConfig();
         goConfig.setMaxTotal(100);
         goConfig.setMaxIdle(20);
         goConfig.setMaxWaitMillis(-1);
         goConfig.setTestOnBorrow(true);
         pool = new ShardedJedisPool(goConfig, shards);
     }

     @AfterClass
     public static void tearDownAfterClass() throws Exception {
         jedis.disconnect();
         shard.disconnect();
         pool.destroy();
     }

     @Test
     public void testString() {
         //-----添加数据----------
         jedis.set("name","bhz");//向key-->name中放入了value-->xinxin
         System.out.println(jedis.get("name"));//执行结果：xinxin  

         jedis.append("name", " is my lover"); //拼接
         System.out.println(jedis.get("name")); 

         jedis.del("name");  //删除某个键
         System.out.println(jedis.get("name"));
         //设置多个键值对
         jedis.mset("name","bhz","age","27","qq","174754613");
         jedis.incr("age"); //进行加1操作
         System.out.println(jedis.get("name") + "-" + jedis.get("age") + "-" + jedis.get("qq"));
     }

     /**
      * redis操作Map
      */
     @Test
     public void testMap() {
         //-----添加数据----------
         Map<String, String> map = new HashMap<String, String>();
         map.put("name", "xinxin");
         map.put("age", "22");
         map.put("qq", "123456");
         jedis.hmset("user",map);
         //取出user中的name，执行结果:[minxr]-->注意结果是一个泛型的List
         //第一个参数是存入redis中map对象的key，后面跟的是放入map中的对象的key，后面的key可以跟多个，是可变参数
         List<String> rsmap = jedis.hmget("user", "name", "age", "qq");
         System.out.println(rsmap);
         //删除map中的某个键值
         jedis.hdel("user","age");
         System.out.println(jedis.hmget("user", "age")); //因为删除了，所以返回的是null
         System.out.println(jedis.hlen("user")); //返回key为user的键中存放的值的个数2
         System.out.println(jedis.exists("user"));//是否存在key为user的记录 返回true
         System.out.println(jedis.hkeys("user"));//返回map对象中的所有key
         System.out.println(jedis.hvals("user"));//返回map对象中的所有value 

         Iterator<String> iter=jedis.hkeys("user").iterator();
         while (iter.hasNext()){
             String key = iter.next();
             System.out.println(key+":"+jedis.hmget("user",key));
         }
     }

     /**
      * jedis操作List
      */
     @Test
     public void testList(){
         //开始前，先移除所有的内容
         jedis.del("java framework");
         System.out.println(jedis.lrange("java framework",0,-1));
         //先向key java framework中存放三条数据
         jedis.lpush("java framework","spring");
         jedis.lpush("java framework","struts");
         jedis.lpush("java framework","hibernate");
         //再取出所有数据jedis.lrange是按范围取出，
         // 第一个是key，第二个是起始位置，第三个是结束位置，jedis.llen获取长度 -1表示取得所有
         System.out.println(jedis.lrange("java framework",0,-1));  

         jedis.del("java framework");
         jedis.rpush("java framework","spring");
         jedis.rpush("java framework","struts");
         jedis.rpush("java framework","hibernate");
         System.out.println(jedis.lrange("java framework",0,-1));
     }  

     /**
      * jedis操作Set
      */
     @Test
     public void testSet(){
         //添加
         jedis.sadd("user","liuling");
         jedis.sadd("user","xinxin");
         jedis.sadd("user","ling");
         jedis.sadd("user","zhangxinxin");
         jedis.sadd("user","who");
         //移除noname
         jedis.srem("user","who");
         System.out.println(jedis.smembers("user"));//获取所有加入的value
         System.out.println(jedis.sismember("user", "who"));//判断 who 是否是user集合的元素
         System.out.println(jedis.srandmember("user"));
         System.out.println(jedis.scard("user"));//返回集合的元素个数
     } 

     @Test
     public void testRLpush() throws InterruptedException {
         //jedis 排序
         //注意，此处的rpush和lpush是List的操作。是一个双向链表（但从表现来看的）
         jedis.del("a");//先清除数据，再加入数据进行测试
         jedis.rpush("a", "1");
         jedis.lpush("a","6");
         jedis.lpush("a","3");
         jedis.lpush("a","9");
         System.out.println(jedis.lrange("a",0,-1));// [9, 3, 6, 1]
         System.out.println(jedis.sort("a")); //[1, 3, 6, 9]  //输入排序后结果
         System.out.println(jedis.lrange("a",0,-1));
     }  

     @Test
     public void testTrans() {
         long start = System.currentTimeMillis();
         Transaction tx = jedis.multi();
         for (int i = 0; i < 1000; i++) {
             tx.set("t" + i, "t" + i);
         }
         //System.out.println(tx.get("t1000").get());

         List<Object> results = tx.exec();
         long end = System.currentTimeMillis();
         System.out.println("Transaction SET: " + ((end - start)/1000.0) + " seconds");
     }

     @Test
     public void testPipelined() {
         Pipeline pipeline = jedis.pipelined();
         long start = System.currentTimeMillis();
         for (int i = 0; i < 1000; i++) {
             pipeline.set("p" + i, "p" + i);
         }
         //System.out.println(pipeline.get("p1000").get());
         List<Object> results = pipeline.syncAndReturnAll();
         long end = System.currentTimeMillis();
         System.out.println("Pipelined SET: " + ((end - start)/1000.0) + " seconds");
     }

     @Test
     public void testPipelineTrans() {
         long start = System.currentTimeMillis();
         Pipeline pipeline = jedis.pipelined();
         pipeline.multi();
         for (int i = 0; i < 100000; i++) {
             pipeline.set("" + i, "" + i);
         }
         pipeline.exec();
         List<Object> results = pipeline.syncAndReturnAll();
         long end = System.currentTimeMillis();
         System.out.println("Pipelined transaction SET: " + ((end - start)/1000.0) + " seconds");
     }

     @Test
     public void testShard() {
         long start = System.currentTimeMillis();
         for (int i = 0; i < 100000; i++) {
             String result = shard.set("shard" + i, "n" + i);
         }
         long end = System.currentTimeMillis();
         System.out.println("shard SET: " + ((end - start)/1000.0) + " seconds");
     }

     @Test
     public void testShardpipelined() {
         ShardedJedisPipeline pipeline = shard.pipelined();
         long start = System.currentTimeMillis();
         for (int i = 0; i < 100000; i++) {
             pipeline.set("sp" + i, "p" + i);
         }
         List<Object> results = pipeline.syncAndReturnAll();
         long end = System.currentTimeMillis();
         System.out.println("shardPipelined SET: " + ((end - start)/1000.0) + " seconds");
     }

     @Test
     public void testShardPool() {
         ShardedJedis sj = pool.getResource();

         long start = System.currentTimeMillis();
         for (int i = 0; i < 100000; i++) {
             String result = sj.set("spn" + i, "n" + i);
         }
         long end = System.currentTimeMillis();
         pool.returnResource(sj);
         System.out.println("shardPool SET: " + ((end - start)/1000.0) + " seconds");
     }

 }

集群化（重点）

这里的7001是7004的主节点，7002是7005的主节点，以此类推，有这样的顺序要求

java操作集群

 import java.util.HashSet;
 import java.util.Set;

 import redis.clients.jedis.HostAndPort;
 import redis.clients.jedis.JedisCluster;
 import redis.clients.jedis.JedisPoolConfig;

 public class TestClusterRedis {

     public static void main(String[] args) {

         Set<HostAndPort> jedisClusterNode = new HashSet<HostAndPort>();
         jedisClusterNode.add(new HostAndPort("192.168.1.171", 7001));
         jedisClusterNode.add(new HostAndPort("192.168.1.171", 7002));
         jedisClusterNode.add(new HostAndPort("192.168.1.171", 7003));
         jedisClusterNode.add(new HostAndPort("192.168.1.171", 7004));
         jedisClusterNode.add(new HostAndPort("192.168.1.171", 7005));
         jedisClusterNode.add(new HostAndPort("192.168.1.171", 7006));
         //GenericObjectPoolConfig goConfig = new GenericObjectPoolConfig();
         //JedisCluster jc = new JedisCluster(jedisClusterNode,2000,100, goConfig);
         JedisPoolConfig cfg = new JedisPoolConfig();
         cfg.setMaxTotal(100);
         cfg.setMaxIdle(20);
         cfg.setMaxWaitMillis(-1);
         cfg.setTestOnBorrow(true);
         JedisCluster jc = new JedisCluster(jedisClusterNode,6000,1000,cfg);        

         System.out.println(jc.set("age","20"));
         System.out.println(jc.set("sex","男"));
         System.out.println(jc.get("name"));
         System.out.println(jc.get("age"));
         System.out.println(jc.get("sex"));
         jc.close();

     }

 }

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>