3.Jedis连接方式

Jedis连接方式

/**
 * Jedis连接方式
 * Redis的Java客户端Jedis的八种调用方式(事务、管道、分布式)介绍
 *
 * 事务/非事务
 * 直连/连接池
 * 同步/管道
 * 单机/分布式
 *
 * 参考:http://www.open-open.com/lib/view/open1410485827242.html
 */
public class RedisConnection {

    //<strong>一、普通同步方式</strong>
    //每次set之后都可以返回结果，标记是否成功。
    public void normal() {
        Jedis jedis = new Jedis("localhost");
        //jedis.auth("");  //连接redis的密码 ,如果需要
        long start = System.currentTimeMillis();
        for(int i=0; i<100000; i++) {
            String result = jedis.set("n" + i, "n" + i);//result=OK
        }
        long end = System.currentTimeMillis();
        System.out.println("Simple SET: " + ((end - start)/1000.0) + " seconds");//8.936 seconds(运行时间和机器有关系)
        jedis.disconnect();
    }
    
    //<strong>二、事务方式(Transactions)</strong>
    /* redis的事务很简单，他主要目的是保障，一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令。
     * **MULTI 、EXEC 、DISCARD 和WATCH 是 Redis事务的基础
     * 1.MULTI:执行之后，客户端可以继续向服务器发送任意多条命令，这些命令不会立即被执行，而是被放到一个队列中
     * 2.EXEC:命令被调用时，所有队列中的命令才会被执行(Redis只执行事务中那些入队成功的命令)
     *        Redis在事务失败时不进行回滚，而是继续执行余下的命令
     * 3.DISCARD:命令时，事务会被放弃，事务队列会被清空，并且客户端会从事务状态中退出
     * 4.WATCH:命令可以为 Redis事务提供 check-and-set （CAS）行为
                         被WATCH的键会被监视，并会发觉这些键是否被改动过了。
                         如果有至少一个被监视的键在EXEC执行之前被修改了，那么整个事务都会被取消
     *
     */
    public static void transactions() {
        /*Jedis jedis = new Jedis("localhost");
        Transaction tx = jedis.multi();
        tx.set("transactions1", "transactions1");
        tx.set("transactions2", "transactions2");
        List<Object> results = tx.exec();//results = [OK, OK]
        jedis.disconnect();*/
        
        //WATCH
        Jedis jedisWATCH = new Jedis("localhost");
        jedisWATCH.watch("a");
        Transaction txWATCH = jedisWATCH.multi();
        txWATCH.incr("a");
        //运行下面tx.exec()打断点，然后通过命令行改变a的值
        txWATCH.exec();
        jedisWATCH.disconnect();
        //如果在WATCH执行之后，EXEC执行之前，有其他客户端修改了key值，那么当前客户端的事务就会失败。
        //程序需要做的，就是不断重试这个操作，直到没有发生碰撞为止。
        //这种形式的锁被称作乐观锁，它是一种非常强大的锁机制。
    }
    
    //<strong>三、管道(Pipelining)</strong>
    /**
     * 有时，我们需要采用异步方式，一次发送多个指令，不同步等待其返回结果。这样可以取得非常好的执行效率。这就是管道.
     */
    public void pipelined() {
        Jedis jedis = new Jedis("localhost");
        Pipeline pipeline = jedis.pipelined();
        long start = System.currentTimeMillis();
        for(int i=0; i<100000; i++) {
            pipeline.set("p" + i, "p" + i);
        }
        List<Object> results = pipeline.syncAndReturnAll();
        long end = System.currentTimeMillis();
        System.out.println("Pipelined SET: " + ((end - start)/1000.0) + " seconds");//0.602 seconds(和上面normal的8.936相比)
        jedis.disconnect();
    }
    
    //<strong>四、管道中调用事务--TODO</strong>
    /**
     * 就Jedis提供的方法而言，是可以做到在管道中使用事务，其代码如下：
     */
    public void pipelineTrans() {
        Jedis jedis = new Jedis("localhost");
        long start = System.currentTimeMillis();
        Pipeline pipeline = jedis.pipelined();
        pipeline.multi();
        for(int i=0; i<100000; i++) {
            pipeline.set("pt" + i, "pt" + i);
        }
        pipeline.exec();
        List<Object> results = pipeline.syncAndReturnAll();
        long end = System.currentTimeMillis();
        System.out.println("Pipelined transaction: " + ((end - start)/1000.0) + " seconds");
        jedis.disconnect();
    }
    
    /**
     * 分布式调用中不支持事务。
     * 因为事务是在服务器端实现，而在分布式中，每批次的调用对象都可能访问不同的机器，所以，没法进行事务。
     */
    
    //<strong>五、分布式直连同步调用</strong>
    //这个是分布式直接连接，并且是同步调用，每步执行都返回执行结果。类似地，还有异步管道调用。
    public void shardNormal() {
        List<JedisShardInfo> shards = Arrays.asList(
                new JedisShardInfo("localhost", 6379),
                new JedisShardInfo("localhost", 6380));

        ShardedJedis sharding = new ShardedJedis(shards);

        long start = System.currentTimeMillis();
        for (int i=0; i<100000; i++) {
            String result = sharding.set("sn" + i, "n" + i);
        }
        long end = System.currentTimeMillis();
        System.out.println("Simple@Sharing SET: " + ((end - start)/1000.0) + " seconds");

        sharding.disconnect();
    }
    
    //<strong>六、分布式直连异步调用</strong>
    public void test6shardpipelined() {
        List<JedisShardInfo> shards = Arrays.asList(
                new JedisShardInfo("localhost",6379),
                new JedisShardInfo("localhost",6380));

        ShardedJedis sharding = new ShardedJedis(shards);

        ShardedJedisPipeline pipeline = sharding.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("Pipelined@Sharing SET: " + ((end - start)/1000.0) + " seconds");

        sharding.disconnect();
    }
    
    //<strong>七、分布式连接池同步调用</strong>
    //如果，你的分布式调用代码是运行在线程中，那么上面两个直连调用方式就不合适了，因为直连方式是非线程安全的，这个时候，你就必须选择连接池调用。
    public void test7shardSimplePool() {
        List<JedisShardInfo> shards = Arrays.asList(
                new JedisShardInfo("localhost", 6379),
                new JedisShardInfo("localhost", 6380));

        ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards);

        ShardedJedis one = pool.getResource();

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

        pool.destroy();
    }
    
    //<strong>八、分布式连接池异步调用</strong>
    public void test8shardPipelinedPool() {
        List<JedisShardInfo> shards = Arrays.asList(
                new JedisShardInfo("localhost", 6379),
                new JedisShardInfo("localhost", 6380));

        ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards);
        ShardedJedis one = pool.getResource();
        ShardedJedisPipeline pipeline = one.pipelined();

        long start = System.currentTimeMillis();
        for (int i=0; i<100000; i++) {
            pipeline.set("sppn" + i, "n" + i);
        }
        List<Object> results = pipeline.syncAndReturnAll();
        long end = System.currentTimeMillis();
        pool.returnResource(one);
        System.out.println("Pipelined@Pool SET: " + ((end - start)/1000.0) + " seconds");
        pool.destroy();
    }
    
    public static void main(String[] args) {
        RedisConnection redis = new RedisConnection();
        redis.normal();
        //redis.transactions();
        //redis.pipelined();
        //redis.pipelineTrans();
    }
    
}