Redis Jedis的使用（下）

单机测试

public class TestRedis {

    private Jedis jedis; // 获取数据库的连接,非切片客户端连接

    @Before
    public void setup() {
      jedis = RedisUtil.getJedis();
    }

    @Test
    public void testRedisPool() {
        //清空redis中所有数据。不可轻易尝试
//      System.out.println("清空库中所有数据："+jedis.flushDB());

        RedisUtil.getJedis().set("test", "中文测试");
        System.out.println(RedisUtil.getJedis().get("test"));
    }

    /** 
     * 事物主要目的是保障，一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令。
     * jedis事物 以 MULTI 开始一个事务， 然后将多个命令入队到事务中， 最后由 EXEC 命令触发事务
     */
//    @Test
    public void testTrans() {
        long start = System.currentTimeMillis();
        Transaction tx = jedis.multi();
        for (int i = 0; i < 100000; i++) {
//            tx.set("t" + i, "t" + i);
            tx.del("t" + i);
        }
        List<Object> results = tx.exec();
        for (Object rt : results) System. out.println(rt.toString());

        long end = System.currentTimeMillis();
        System.out.println("Transaction SET: " + ((end - start)/1000.0) + " s");
        jedis.disconnect();
    }

    /** 
     * 管道采用异步方式，一次发送多个指令，不同步等待其返回结果。提高执行效率
     */
//    @Test
    public void testPipelined() {
        Pipeline pipeline = jedis.pipelined();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
//            pipeline.set("p" + i, "p" + i);
            pipeline.del("p" + i);
        }
        pipeline.syncAndReturnAll();

        long end = System.currentTimeMillis();
        System.out.println("Pipelined SET: " + ((end - start)/1000.0) + " s");
        jedis.disconnect();
    }

    /** 
     * 管道中使用事务
     * 经测试运行时间：Pipelined < Pipelined transaction < Transaction
     */
//    @Test
    public void testCombPipelineTrans() {
        long start = System.currentTimeMillis();
        Pipeline pipeline = jedis.pipelined();
        pipeline.multi();
        for (int i = 0; i < 100000; i++) {
//            pipeline.set("" + i, "" + i);
            pipeline.del("" + i);
        }
        pipeline.exec();
        pipeline.syncAndReturnAll();
        long end = System.currentTimeMillis();
        System.out.println("Pipelined transaction: " + ((end - start)/1000.0) + " s");
        jedis.disconnect();
    }

}

分布式测试

public class TestShardedRedis {

    private ShardedJedis  shardedJedis; //切片客户端  (分布式)

    @Before
    public void setup() {
      shardedJedis = RedisUtil.getShardedJedis();
    }

    /** 
     * 分布式直接连接，并且是同步调用，每步执行都返回执行结果
     */
    @Test
    public void testShardNormal() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
//          shardedJedis.set("sn" + i, "n" + i);
            shardedJedis.del("sn" + i);
        }
        long end = System.currentTimeMillis();
        System.out.println("Simple@Sharing SET: " + ((end - start)/1000.0));
//        shardedJedis.disconnect();
    }

    /** 
     * 分布式直接连接，并且是异步调用，每步执行都返回执行结果
     */
    @Test
    public void testShardpipelined() {
        ShardedJedisPipeline pipeline = shardedJedis.pipelined();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
//            pipeline.set("sp" + i, "p" + i);
            pipeline.del("sp" + i);
        }
        pipeline.syncAndReturnAll();
        long end = System.currentTimeMillis();
        System.out.println("Pipelined@Sharing SET: " + ((end - start)/1000.0));
        shardedJedis.disconnect();
    }

    /** 
     * 分布式调用代码是运行在线程中，那么上面两个直连调用方式就不合适了，因为直连方式是非线程安全的.必须选择连接池调用
     * 同步调用
     */
//    @Test
    public void testShardSimplePool() {
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
//            String result = shardedJedis.set("spn" + i, "n" + i);
            shardedJedis.del("spn" + i);
        }
        long end = System.currentTimeMillis();
        RedisUtil.returnResource(shardedJedis);
        System.out.println("Simple@Pool SET: " + ((end - start)/1000.0) + " seconds");
//        RedisUtil.destroyShardedJedisPool();
    }

    /** 
     * 分布式连接池异步调用
     */
//    @Test
    public void testShardPipelinedPool() {
        ShardedJedisPipeline pipeline = shardedJedis.pipelined();

        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
//            pipeline.set("sppn" + i, "n" + i);
            pipeline.del("sppn" + i);
        }
        pipeline.syncAndReturnAll();
        long end = System.currentTimeMillis();
        RedisUtil.returnResource(shardedJedis);
        System.out.println("Pipelined@Pool SET: " + ((end - start)/1000.0) + " seconds");
        RedisUtil.destroyShardedJedisPool();
    }
}

直接连接	连接池调用

订阅

public class RedisMsgPubSubListener extends JedisPubSub {

     // 取得订阅的消息后的处理  
    public void onMessage(String channel, String message) {  
        System.out.println("取得订阅的消息后的处理  >>"+channel + "=" + message);  
    }  

    // 初始化订阅时候的处理  
    public void onSubscribe(String channel, int subscribedChannels) {  
         System.out.println("初始化订阅时候的处理    >>"+channel + "=" + subscribedChannels);  
    }  

    public void onUnsubscribe(String channel, int subscribedChannels) {  
         System.out.println("取消订阅时候的处理    >>"+channel + "=" + subscribedChannels);  
    }  

    // 初始化按表达式的方式订阅时候的处理  
    public void onPSubscribe(String pattern, int subscribedChannels) {  
         System.out.println("初始化按表达式的方式订阅时候的处理    >>"+pattern + "=" + subscribedChannels);  
    }  

    // 取消按表达式的方式订阅时候的处理  
    public void onPUnsubscribe(String pattern, int subscribedChannels) {  
         System.out.println("取消按表达式的方式订阅时候的处理    >>"+pattern + "=" + subscribedChannels);  
    }  

    // 取得按表达式的方式订阅的消息后的处理  
    public void onPMessage(String pattern, String channel, String message) {  
        System.out.println("取得按表达式的方式订阅的消息后的处理    >>"+pattern + "=" + channel + "=" + message);  
    }

}

public class TestSubscribe {

    private Jedis jedis; // 获取数据库的连接,非切片客户端连接

    @Before
    public void setup() {
        jedis = RedisUtil.getJedis();
    }

    @Test  
    public void testSubscribe() throws Exception{  
       RedisMsgPubSubListener listener = new RedisMsgPubSubListener();   
       //可以订阅多个频道  
       //订阅得到信息在lister的onMessage(...)方法中进行处理  
       jedis.subscribe(listener, "redisChatTest");   
       jedis.subscribe(listener, "test1", "test2");  
        //也用数组的方式设置多个频道  
       jedis.subscribe(listener, new String[]{"hello_foo","hello_test"}); 

       //这里启动了订阅监听，线程将在这里被阻塞  
       //订阅得到信息在lister的onPMessage(...)方法中进行处理  
       jedis.psubscribe(listener, new String[]{"hello_*"});//使用模式匹配的方式设置频道
       jedis.publish("redisChatTest", "heqing"); 
    }  
}

常用命令

连接操作命令

命令	作用
quit	关闭连接（connection）
auth	简单密码认证
help cmd	查看cmd帮助，例如：help quit

持久化

命令	作用
save	将数据同步保存到磁盘
bgsave	将数据异步保存到磁盘
lastsave	返回上次成功将数据保存到磁盘的Unix时戳
shundown	将数据同步保存到磁盘，然后关闭服务

远程服务控制

命令	作用
info	提供服务器的信息和统计
monitor	实时转储收到的请求
slaveof	改变复制策略设置
config	在运行时配置Redis服务器

对value操作的命令

命令	作用
exists(key)	确认一个key是否存在
del(key)	删除一个key
type(key)	返回值的类型
keys(pattern)	返回满足给定pattern的所有key
randomkey	随机返回key空间的一个
keyrename(oldname, newname)	重命名key
dbsize	返回当前数据库中key的数目
expire	设定一个key的活动时间（s）
ttl	获得一个key的活动时间
select(index)	按索引查询
move(key, dbindex)	移动当前数据库中的key到dbindex数据库
flushdb	删除当前选择数据库中的所有key
flushall	删除所有数据库中的所有key

String

命令	作用
set(key, value)	给数据库中名称为key的string赋予值value
get(key)	返回数据库中名称为key的string的value
getset(key, value)	给名称为key的string赋予上一次的value
mget(key1, key2,…, key N)	返回库中多个string的value
setnx(key, value)	添加string，名称为key，值为value
setex(key, time, value)	向库中添加string，设定过期时间time
mset(key N, value N)	批量设置多个string的值
msetnx(key N, value N)	如果所有名称为key i的string都不存在
incr(key)	名称为key的string增1操作
incrby(key, integer)	名称为key的string增加integer
decr(key)	名称为key的string减1操作
decrby(key, integer)	名称为key的string减少integer
append(key, value)	名称为key的string的值附加value
substr(key, start, end)	返回名称为key的string的value的子串

List

命令	作用
rpush(key, value)	在名称为key的list尾添加一个值为value的元素
lpush(key, value)	在名称为key的list头添加一个值为value的 元素
llen(key)	返回名称为key的list的长度
lrange(key, start, end)	返回名称为key的list中start至end之间的元素
ltrim(key, start, end)	截取名称为key的list
lindex(key, index)	返回名称为key的list中index位置的元素
lset(key, index, value)	给名称为key的list中index位置的元素赋值
lrem(key, count, value)	删除count个key的list中值为value的元素
lpop(key)	返回并删除名称为key的list中的首元素
rpop(key)	返回并删除名称为key的list中的尾元素
blpop(key1, key2,… key N, timeout)	lpop命令的block版本。
brpop(key1, key2,… key N, timeout)	rpop的block版本。
rpoplpush(srckey, dstkey)	返回并删除名称为srckey的list的尾元素，并将该元素添加到名称为dstkey的list的头部

Set

命令	作用
sadd(key, member)	向名称为key的set中添加元素member
srem(key, member)	删除名称为key的set中的元素member
spop(key)	随机返回并删除名称为key的set中一个元素
smove(srckey, dstkey, member)	移到集合元素
scard(key)	返回名称为key的set的基数
sismember(key, member)	member是否是名称为key的set的元素
sinter(key1, key2,…key N)	求交集
sinterstore(dstkey, (keys))	求交集并将交集保存到dstkey的集合
sunion(key1, (keys))	求并集
sunionstore(dstkey, (keys))	求并集并将并集保存到dstkey的集合
sdiff(key1, (keys))	求差集
sdiffstore(dstkey, (keys))	求差集并将差集保存到dstkey的集合
smembers(key)	返回名称为key的set的所有元素
srandmember(key)	随机返回名称为key的set的一个元素

Hash

命令	作用
hset(key, field, value)	向名称为key的hash中添加元素field
hget(key, field)	返回名称为key的hash中field对应的value
hmget(key, (fields))	返回名称为key的hash中field i对应的value
hmset(key, (fields))	向名称为key的hash中添加元素field
hincrby(key, field, integer)	将名称为key的hash中field的value增加integer
hexists(key, field)	名称为key的hash中是否存在键为field的域
hdel(key, field)	删除名称为key的hash中键为field的域
hlen(key)	返回名称为key的hash中元素个数
hkeys(key)	返回名称为key的hash中所有键
hvals(key)	返回名称为key的hash中所有键对应的value
hgetall(key)	返回名称为key的hash中所有的键（field）及其对应的value

清空数据库慎用

jedis.flushDB();

参考资料

• jedis 源码 ：https://github.com/xetorthio/jedis/wiki/Getting-started
• jedis-2.1.0 在线文档 ： http://tool.oschina.net/apidocs/apidoc?api=jedis-2.1.0

示例代码

本代码中不排除存在错误，望指出。
存在MongoDB代码，不需要可删除相关的包。
下载地址 ： http://download.csdn.net/detail/hq0556/9818252