Redis客户端之Jedis（Key、String、Set、List、pub/sub、cluster、pool、pipleline）

环境：
OS：CentOS6.5   64位
server版本：Redis 3.2.0
client 版本：Jedis 2.9.0

在Maven中引用jedis的jar：

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit-dep</artifactId>
        <version>4.8.2</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
        <version>2.3</version>
    </dependency>
    <dependency>
        <groupId>org.hamcrest</groupId>
        <artifactId>hamcrest-all</artifactId>
        <version>1.3</version>
    </dependency>
 </dependencies>

   
1
2
3
4
5
6
7
8
9
10
11
12
13

   

    
   

   
1
2
3
4
5
6
7
8
9
10
11
12
13
14

15

16

17

18

19

20

21

22

23



1、非切片链接
package com.digi_zones;

import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.*;

import java.util.*;

/**
 * Jedis Api测试
 * 字符串、Set、List、Hash、publish/subscribe
 * Created by yangxin on 2016/7/14.
 */
public class JedisTest {

    private Jedis jedis;

    @Before
    public void before() {
        jedis = new Jedis("192.168.0.201",6384);
        jedis.auth("yangxin");
    }

    /**
     * 字符串
     * 文档：127.0.0.1:6384> help @string
     */
    @Test
    public void testString() {
        jedis.flushDB();    // 清空当前数据的所有数据
        // 保存一个字符串
        jedis.set("language","java");
        // 在原来key对应的值追加一个字符串，如果key不存在，则创建一个新的key
        jedis.append("language","c++");
        // 获取一个字符串
        String s = jedis.get("language");
        Assert.assertEquals("javac++",s);
        // 自增1，redis会转换成整型，再进行加操作。等价于count++。默认为0
        jedis.incr("count");
        // 在原有值的基础增加指定的值，等价于count+=10;
        jedis.incrBy("count",10);
        // 浮点数自增
        Double price = jedis.incrByFloat("price",1.2);
        Assert.assertTrue(price == 1.2);
        // 自减1，等价于count--
        jedis.decr("count");
        // 减指定数量的值,等价于count-=5
        jedis.decrBy("count",5);
        Assert.assertEquals(jedis.get("count"),"5");
        // 获取key旧的值，并设置一个新的值
        s = jedis.getSet("count","100");
        Assert.assertEquals(s,"5");
        // 获取指定范围的字符串，0：起始偏移  3：结束位置
        s = jedis.getrange("language",0,3);
        Assert.assertEquals(s, "java");
        // 替换，0：替换起始位置，php：从0开始替换的字符串
        jedis.setrange("language",0,"php");
        Assert.assertEquals(jedis.get("language"),"phpac++");
        // 只有key不存在才保存,key不存在返回1，存在返回0
        long r = jedis.setnx("count","200");
        Assert.assertTrue(r == 0);
        // 获取字符串的长度
        long len = jedis.strlen("language");
        Assert.assertTrue("phpac++".length() == len);

        // 同时设置多个key的值
        jedis.mset("language","java", "count","2000");

        // 获取多个key的值
        List<String> list = jedis.mget("language","count");
        System.out.println(list);
        Assert.assertTrue(list.size() == 2 && list.get(0).equals("java") && list.get(1).equals("2000"));

        // 同时设置多个key，且key不存在
        r = jedis.msetnx("auth","yangxin","age","18");
        Assert.assertTrue(r == 1);

        // 保存带有效期的key，单位为毫秒
        jedis.psetex("expir_key",2000,"abcde");
        try {
            Thread.sleep(2100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        boolean b = jedis.exists("expir_key");
        Assert.assertTrue(!b);

        // 保存带有效期的key，单位为秒
        jedis.setex("expir_key2",3,"test");

    }

    /**
     * 集合
     * 1> 元素没有顺序
     * 2> 元素不可重复
     * 文档：127.0.0.1:6384> help @set
     */
    @Test
    public void testSet() {
        jedis.flushDB();
        // 添加元素，返回添加的元素个数
        long r = jedis.sadd("hobbys","吃","喝","玩","乐","看书","旅游");
        Assert.assertTrue(r == 6);

        // 查询集合元数数量
        r = jedis.scard("hobbys");
        Assert.assertTrue(r == 6);

        // 取多个集合的差集
        r = jedis.sadd("hobbys2","吃","旅游");
        Assert.assertTrue(r == 2);
        Set<String> s = jedis.sdiff("hobbys","hobbys2");
        System.out.println(s);
        Assert.assertTrue(s.size() == 4);

        // 取hoobys和hobbys2的差集，将结果存在hobbys3集合中
        r = jedis.sdiffstore("hobbys3","hobbys","hobbys2");
        Assert.assertTrue(jedis.scard("hobbys3") == r);

        // 取多个集合的交集
        s = jedis.sinter("hobbys","hobbys2");
        System.out.println(s);
        Assert.assertTrue(s.size() == 2);

        // 取多个集合的交集，并将结果存储到一个新的key中
        r = jedis.sinterstore("hobbys4","hobbys","hobbys2");
        Assert.assertTrue(jedis.scard("hobbys4") == r);

        // 判断某个元素是否在集合当中
        boolean b = jedis.sismember("hobbys","吃");
        Assert.assertTrue(b);

        // 获取集合中的的元素
        s = jedis.smembers("hobbys");
        System.out.println(s);
        Assert.assertTrue(s.size() == 6);

        // 从一个集合中移动指定的元素到另外一个集合当中
        r = jedis.smove("hobbys","hobbys2","乐");
        Assert.assertTrue(r == 1);
        Assert.assertTrue(jedis.sismember("hobbys2","乐"));

        // 从集合中随机获取2个元素
        List<String> list = jedis.srandmember("hobbys",2);
        System.out.println("随机获取2个元素：" + list);
        Assert.assertTrue(list.size() == 2);

        // 从集合中随机移除一个或多个元素，返回移除的元素。因为集合中的元素是没有顺序的
        s = jedis.spop("hobbys",2);
        System.out.println(s);
        Assert.assertTrue(s.size() == 2);

        // 从集合中删除一个或多个元素，返回删除的个数
        r = jedis.srem("hobbys","吃","旅游");
        System.out.println(r);
        Assert.assertTrue(!jedis.sismember("hobbys","吃") && !jedis.sismember("hobbys","旅游"));

        // 根据查询关键搜索集合中的元素，0：搜索开始位置，scanParams：搜索规则
        ScanParams scanParams = new ScanParams();
        jedis.sadd("hobbys","java","javascript","php","c++","c","objective-c","node.js","python");
        scanParams.match("java*");
        ScanResult<String> sr = jedis.sscan("hobbys",0,scanParams);
        list = sr.getResult();
        System.out.println(list);
        Assert.assertTrue(list.size() == 2);

        // 取多个集合的并集，如果元素相同，则会覆盖
        Set<String> us = jedis.sunion("hobbys2","hobbys3");
        System.out.println(us);

        // 将多个集合的并集存储到一个新的集合中
        r = jedis.sunionstore("hobbys5","hobbys2","hobbys3");
        Assert.assertTrue(r == jedis.scard("hobbys5"));
        System.out.println(jedis.smembers("hobbys5"));
    }

    /**
     * 自动排序的集合
     * 1> 元素不可重复
     * 2> 元素有序（根据score排序）
     * score值越大，排名越靠后
     */
    @Test
    public void testSortedSet() {
        jedis.flushDB();
        // 添加元素（不需要设置同样的类型）
        jedis.zadd("price",1,"1");
        jedis.zadd("price",5,"10");
        jedis.zadd("price",2,"5.2");
        jedis.zadd("price",6,"6");
        jedis.zadd("price",7,"3");
        jedis.zadd("price",10,"五百");

        // 获取元素列表
        Set<String> set = jedis.zrange("price",0,-1);
        System.out.println(set);

        // 获取指定分值范围的元素数量
        long r = jedis.zcount("price",1,8);
        System.out.println(r);
        Assert.assertTrue(r == 5);

        // 给指定元素的增加分值，返回新的分值
        double s = jedis.zincrby("price",5.5,"3");
        System.out.println(s);
        Assert.assertTrue(s == 12.5);

        // 指定键在集合的分值排名，从0开始算
        r = jedis.zrank("price","3");
        System.out.println(r);
        Assert.assertTrue(r == 5);  // 最高分，默认按升序排列，第最后一名

        // 删除元素，删除成功返回删除的元素数量，失败返回0
        r = jedis.zrem("price","五百","3");
        Assert.assertTrue(r == 2);

        // 获取元素的排名分值
        s = jedis.zscore("price","6");
        Assert.assertTrue(s == 6);

        // 获取元素在集合中的逆序名次（倒数第几名）,从0开始计算
        s = jedis.zrevrank("price","6");
        Assert.assertTrue(s == 0);

        // 获取指定范围的后几个元素(这里是后3个元素)
        set = jedis.zrevrange("price", 0, 2);
        System.out.println(set);    // [6, 10, 5.2]

        // 获取指定分值范围的后几个元素，依移1个元素，取后2个
        set = jedis.zrevrangeByScore("price",5,1,1,2);
        System.out.println(set);    // [5.2, 1]

        /**
         * 模拟搜索
         * 区间必须包含(、[符号：（代表不包含，[代表包含
         * -、+ ： 代表最少和最大范围
         * @see http://redisdoc.com/sorted_set/zrangebylex.html
         */
        jedis.zadd("alpha",0,"a");
        jedis.zadd("alpha",0,"b");
        jedis.zadd("alpha",0,"c");
        jedis.zadd("alpha",0,"d");
        jedis.zadd("alpha",0,"e");
        jedis.zadd("alpha",0,"f");
        jedis.zadd("alpha",0,"k");
        jedis.zadd("alpha",0,"z");

        // 取a~k范围的元素，包含a，不包含k。从第2个开始取3个
        set = jedis.zrangeByLex("alpha","[a","(k",1,3);
        System.out.println(set);    // [b, c, d]

        // 获取指定范围的元素个数
        r = jedis.zlexcount("alpha","[a","[f");
        System.out.println(r);
        Assert.assertTrue(r == 6);

        // 倒着取指定范围的元素
        set = jedis.zrevrangeByLex("alpha","[z","[d",0,3);
        System.out.println(set);    // [z, k, f]

    }

    /**
     * 队列
     * 文档：127.0.0.1:6384> help @list
     */
    @Test
    public void testList() {
        jedis.flushDB();
        // 向头添加元素，返回链表的长度
        long r = jedis.lpush("users","yangxin","yangli","yangfang","huge","guodegang");
        System.out.println(r);
        Assert.assertTrue(r == 5);

        // 向尾添加元素，返回链表的长度
        r = jedis.rpush("users","likaifu","mayun","mahuateng");
        System.out.println(r);
        Assert.assertTrue(r == 8);

        // 返回链表长度
        r = jedis.llen("users");
        System.out.println(r);
        Assert.assertTrue(r == 8);

        // 获取链表元素,0:开始索引，-1：结束索引，-1表示取链表长度
        List<String> list = jedis.lrange("users",0,-1);
        System.out.println(list);
        Assert.assertTrue(list.size() == 8);

        // 删除指定的相同元素数量，返回删除元素个数
        jedis.rpush("users","mahuateng","mahuateng");
        r = jedis.lrem("users",2,"mahuateng");
        System.out.println(r);
        Assert.assertTrue(r == 2);

        // 弹出列表中第一个元素（删除并返回第一个元素）
        String s = jedis.lpop("users");
        System.out.println(s);
        Assert.assertEquals(s,"guodegang");

        // 弹出列表中最后一个元素
        s = jedis.rpop("users");
        System.out.println(s);
        Assert.assertEquals(s,"mahuateng");

        // 往队列头部插入元素，列表必须存在
        r = jedis.lpushx("users2","laoyang");
        System.out.println(r == 0);

        // 修改队列中指定索引的值
        s = jedis.lset("users",0,"yangxin");
        System.out.println(s);
        Assert.assertEquals(s,"OK");

        // 截取并保存链表中指定范围的元素
        s = jedis.ltrim("users",0,5);
        System.out.println(s);

        // 返回指定索引的元素
        s = jedis.lindex("users",0);
        System.out.println(s);
        Assert.assertEquals(s,"yangxin");

        System.out.println("users: " + jedis.lrange("users",0,-1));

        // 弹出users最后一个元素，保存到user2链表中，并返回
        s = jedis.rpoplpush("users","users2");
        System.out.println(jedis.lrange("users2",0,-1));

        // 同上，只是有阻塞超时时长，单位：毫秒
        s = jedis.brpoplpush("users","users2",1);
        System.out.println(jedis.lrange("users2",0,-1));
    }

    /**
     * hash表
     * 文档：127.0.0.1:6384> help @hash
     */
    @Test
    public void testHash() {
        jedis.flushDB();
        // 添加元素，如果key存在则修改，且返回0.如果key不存在，则添加，返回1
        long r = jedis.hset("user", "name","yangxin");
        jedis.hset("user","age","18");  // 18显得我年轻~
        Assert.assertEquals(r,1);

        // 如果key不存在则添加，否则操作失败。key存在返回0,否则返回1
        r = jedis.hsetnx("user","name","郭德纲");
        Assert.assertTrue(r == 0);

        // 获取某一key的值
        String s = jedis.hget("user","name");
        System.out.println(s);
        Assert.assertEquals(s,"yangxin");

        // 获取所有值
        Map<String, String> map = jedis.hgetAll("user");
        for (Map.Entry<String,String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "=" + entry.getValue());
        }
        Assert.assertTrue(map.size() == 2);

        // 判断某个key的字段是否存在
        boolean b = jedis.hexists("user","sex");
        Assert.assertTrue(!b);

        // 对某个field累加指定的整数值，返回累加后的值
        r = jedis.hincrBy("user","age",10); // 还是回归现实吧~^^
        System.out.println(r);
        Assert.assertTrue(r == 28);

        // 对某个field累加指定的浮点数值，返回累加后的值
        double f = jedis.hincrByFloat("user","height",1.75);
        System.out.println(f);
        Assert.assertTrue(f == 1.75);

        // 获取hash的字段数量
        r = jedis.hlen("user");
        Assert.assertEquals(r,3);

        // 获取多个字段的值
        List<String> list = jedis.hmget("user","name","age");
        System.out.println(list);
        Assert.assertTrue(list.size() == 2);

        // 获取所有字段的值
        list = jedis.hvals("user");
        System.out.println(list);
        Assert.assertTrue(list.size() == 3);

        // 删除字段
        r = jedis.hdel("user","name","age");
        System.out.println(r);
        Assert.assertTrue(r == 2);

        // 查找字段
        jedis.hset("user","js1","value1");
        jedis.hset("user","xxxjs2","value2");
        jedis.hset("user","abcjs3","value3");
        jedis.hset("user","1abcjs","value4");
        jedis.hset("user","2abc2js3","value5");
        jedis.hset("user","name","yangxin");
        ScanParams scanParams = new ScanParams();
        scanParams.match("*js*");    // 查找包含js的字段
        ScanResult<Map.Entry<String, String>> sr = jedis.hscan("user","0",scanParams);
        System.out.println(sr.getResult().size());
        Assert.assertTrue(sr.getResult().size() == 5);
        for (Iterator<Map.Entry<String, String>> iterator = sr.getResult().iterator(); iterator.hasNext();) {
            Map.Entry<String, String> entry = iterator.next();
            System.out.println(entry.getKey() + "=" + entry.getValue());
        }

    }

    /**
     * 消息发布
     * 文档：127.0.0.1:6384> help @pubsub
     */
    @Test
    public void testPublish() {
        // 发布一个事件
        long r = jedis.publish("event_msg","message_" + System.currentTimeMillis());
        System.out.println(r);
    }

    /**
     * 消息订阅
     * 文档：127.0.0.1:6384> help @pubsub
     */
    @Test
    public void testSubscribe() {
        // 订阅一个事件
        JedisPubSub sub = new JedisPubSub() {

            private int count;

            /**
             * 收到订阅消息回调
             * @param channel 订阅的消息通道
             * @param message 消息内容
             */
            @Override
            public void onMessage(String channel, String message) {
                count++;
                if (count > 3) {
                    unsubscribe(channel);
                    count = 0;
                    return;
                }
                System.out.println("onMessage--->channel: " + channel + ", message: " + message);
            }

            // 消息订阅成功回调
            @Override
            public void onSubscribe(String channel, int subscribedChannels) {
                System.out.println("onSubscribe---->channel:" + channel + ", subscribedChannels: " + subscribedChannels);
            }

            /**
             * 消息取消息订阅回调
             */
            @Override
            public void onUnsubscribe(String channel, int subscribedChannels) {
                System.out.println("onUnsubscribe--->channel: " + channel + ", subscribedChannels: " + subscribedChannels);
            }

            /**
             * 收到模式匹配主题消息回调（可以用*通配符匹配）
             * @param pattern 模式匹配主题
             * @param channel 发送消息的具体主题
             * @param message 消息内容
             */
            @Override
            public void onPMessage(String pattern, String channel, String message) {
                count++;
                if (count > 3) {
                    punsubscribe();
                    count = 0;
                    return;
                }
                System.out.println("onPMessage---->pattern: " + pattern+ ", channel:" + channel + ", message: " + message);
            }

            /**
             * 模式主题订阅成功回调
             * @param pattern 模式匹配主题
             * @param subscribedChannels
             */
            @Override
            public void onPSubscribe(String pattern, int subscribedChannels) {
                System.out.println("onPSubscribe---->pattern:" + pattern + ", subscribedChannels: " + subscribedChannels);
            }

            /**
             * 模式主题取消订阅回调
             * @param pattern 模式匹配主题
             * @param subscribedChannels
             */
            @Override
            public void onPUnsubscribe(String pattern, int subscribedChannels) {
                System.out.println("onUnsubscribe--->pattern: " + pattern + ", subscribedChannels: " + subscribedChannels);
            }
        };
        // 订阅event_msg,event_msg2,event_msg3 三个消息
        //jedis.subscribe(sub,"event_msg","event_msg2","event_msg3");

        // 订阅模式匹配消息
        jedis.psubscribe(sub,"event.msg.*", "event.doc.*");
    }

    /**
     * 事务
     */
    @Test
    public void testTransaction() {
        jedis.flushDB();
        Transaction transaction = jedis.multi();    // 开始执行事务
        transaction.hset("user","name","yangxin");
        transaction.hset("user","age","28");
        transaction.hset("user","sex","man");
        transaction.hset("user","height","1.75");
        transaction.hset("user","weight","65");
        List<Object> objects = transaction.exec();  // 执行事务
        System.out.println(objects.toString());
    }

    /**
     * 批处理
     * 10万个key是单个key存储速度的10倍以上
     */
    @Test
    public void testPipleLine() {
        Pipeline pipeline = jedis.pipelined();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            pipeline.set("key" + i, "value" + i);
            pipeline.hset("user", "key" + i, "vlaue" + i);
            if (i % 1000 == 0) {
                pipeline.sync();
            }
        }
        pipeline.sync();
        long end = System.currentTimeMillis() - start;
        System.out.println(end);
    }

    /**
     * key
     */
    @Test
    public void testKey() {
        jedis.flushDB();
        jedis.hset("user","username","yangxin");
        jedis.set("name","yangxin");
        // 删除key，返回删除key的数量
        long ret = jedis.del("user","name","language");
        System.out.println(ret);
        Assert.assertTrue(ret == 2);    // language这个key不存在

        jedis.set("name","yangxin");
        jedis.set("age","28");
        jedis.set("sex","man");
        jedis.set("height","175");
        jedis.set("weight", "65kg");
        jedis.sadd("hobbys","吃","喝","玩","乐");
        // 随机返回一个key
        String key = jedis.randomKey();
        System.out.println(key);

        // 序列化指定key的值
        byte[] value = jedis.dump("name");
        System.out.println(new String(value));

        // 查询指定的key是否存在
        boolean b = jedis.exists("name");
        Assert.assertTrue(b);

        // 设置指定key的有效期，单位：秒。返回1设置成功，0设置失败（超时或key不存在）
        ret = jedis.expire("name",60 * 10);
        System.out.println(ret);
        Assert.assertTrue(ret == 1);

        // 指定key有效期（1970.1.1 0:0:0以来的秒数）
        Calendar expire = Calendar.getInstance();
        expire.add(Calendar.SECOND, 5);
        ret = jedis.expireAt("age",expire.getTimeInMillis()/1000);
        Assert.assertTrue(ret == 1);

        /**
         * 移动一个key到指定主机指定的数据库
         * 注意：如果目标主机数据库中的key已经存在，则报错
         * arg1: 目标主机IP
         * arg2: 目标主机端口
         * arg3：当前实例的key
         * arg4: 目标主机的数据库序号
         * arg5: 移动超时时长
         */
        String s = jedis.migrate("192.168.0.201",6385,"age",0,5000);
        Assert.assertEquals(s,"OK");

        /**
         * 在当前redis实例移动指定的key到指定序号数据库中
         * 移动成功返回1，否则返回0
         */
        long r = jedis.move("weight",1);
        //Assert.assertTrue(r == 1);
        System.out.println(r);

        //------------------debug 排错------------------
        r = jedis.objectRefcount("height");     // 查看一个对象被引用的次数
        System.out.println(r);
        s = jedis.objectEncoding("height");     // 查看key在redis内部存储的数据类型
        System.out.println(s);
        r = jedis.objectIdletime("height");         // 查看自存储后的空闲时间
        System.out.println(r);

        // 获取一个key的剩余生命周期，以秒为单位，-1：表示没有有效期限制
        r = jedis.ttl("age");
        System.out.println(r);

        // 获取一个key的剩余生命周期，以毫秒为单位, -1：表示没有有效期限制
        r = jedis.pttl("age");
        System.out.println(r);

        // key重命名，如果两个key相同重命名失败，如果新key已经存在，则覆盖
        s = jedis.rename("age","newAge");
        System.out.println(s);

        // 如果新key已经存在，重命名失败
        r = jedis.renamenx("newAge","age");
        System.out.println(r);

        // 搜索key
        ScanParams sp = new ScanParams();
        sp.match("age");
        ScanResult<String> result = jedis.scan(0,sp);
        System.out.println(result.getResult());
        Assert.assertTrue(result.getResult().size() == 1);

        // 对set、list进行排序（只能是数值）
        jedis.sadd("num","1","0","3","10","10.2","8","5","2.2","2");
        System.out.println(jedis.smembers("num"));
        System.out.println(jedis.sort("num"));  // 默认升序
        SortingParams params = new SortingParams();
        params.desc();  // 降序
        System.out.println(jedis.sort("num",params));

        // 将排序结果保存到一个新的列表中（list）
        params.asc();
        System.out.println(jedis.sort("num",params,"sorted_num"));

    }

    @After
    public void after() {
        jedis.close();
    }
}

    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
    

     
    
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
2、非切片链接池
package com.digi_zones;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.ScanResult;

import java.util.List;

/**
 * Jedis连接池测试
 * Created by yangxin on 2016/7/14.
 */
public class JedisPoolTest {

    private JedisPool jedisPool;

    @Before
    public void before() {
        JedisPoolConfig config = new JedisPoolConfig();
        // 设置最大连接数
        config.setMaxTotal(100);
        // 最大空闲连接数
        config.setMaxIdle(5);
        // 最少空闲连接数（初始化连接数）
        config.setMinIdle(1);
        // 连接等待超时时长60秒
        config.setMaxWaitMillis(60 * 1000);
        // 在获取redis连接时，自动测试连接是否可用，保证返回可用的连接
        config.setTestOnBorrow(true);
        // 连接回收到连接池时，自动测试连接是否可用（ping()），如果连接不可用，则不会放回连接池
        config.setTestOnReturn(true);
        // 自动检测空闲连接是否可用
        config.setTestWhileIdle(true);
        // 检测空闲连接是否可用的间隔时间
        config.setTimeBetweenEvictionRunsMillis(60* 1000);

        jedisPool = new JedisPool(config,"192.168.0.201",6384,5000,"yangxin");
    }

    @Test
    public void testString() {
        Jedis resource = jedisPool.getResource();
        resource.sadd("hobbys","吃","喝","玩","乐");
        ScanResult<String> result = resource.sscan("hobbys","0");
        List<String> s = result.getResult();
        System.out.println(s);
        resource.close();   // 回收连接
    }

    @After
    public void after() {
        jedisPool.close();
    }
}

    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
    

     
    
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59