资讯

精准传达 • 有效沟通

从品牌网站建设到网络营销策划,从策略到执行的一站式服务

RedisJava客户端Jedis的八种调用方式是什么

本篇文章为大家展示了redis Java客户端Jedis的八种调用方式是什么,内容简明扼要并且容易理解,绝对能使你眼前一亮,通过这篇文章的详细介绍希望你能有所收获。

成都创新互联公司是专业的绿春网站建设公司,绿春接单;提供成都网站建设、网站建设,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行绿春网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

在这里对jedis关于事务、管道和分布式的调用方式做一个简单的介绍和对比:

一、普通同步方式

最简单和基础的调用方式,

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

很简单吧,每次set之后都可以返回结果,标记是否成功。

二、事务方式(Transactions)

redis的事务很简单,他主要目的是保障,一个client发起的事务中的命令可以连续的执行,而中间不会插入其他client的命令。

看下面例子:

@Test
public void test2Trans() {
    Jedis jedis = new Jedis("localhost");
    long start = System.currentTimeMillis();
    Transaction tx = jedis.multi();
    for (int i = 0; i < 100000; i++) {
        tx.set("t" + i, "t" + i);
    }
    List results = tx.exec();
    long end = System.currentTimeMillis();
    System.out.println("Transaction SET: " + ((end - start)/1000.0) + " seconds");
    jedis.disconnect();
}

我们调用jedis.watch(…)方法来监控key,如果调用后key值发生变化,则整个事务会执行失败。另外,事务中某个操作失败,并不会回滚其他操作。这一点需要注意。还有,我们可以使用discard()方法来取消事务。

三、管道(Pipelining)

有时,我们需要采用异步方式,一次发送多个指令,不同步等待其返回结果。这样可以取得非常好的执行效率。这就是管道,调用方法如下:

@Test
public void test3Pipelined() {
    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 results = pipeline.syncAndReturnAll();
    long end = System.currentTimeMillis();
    System.out.println("Pipelined SET: " + ((end - start)/1000.0) + " seconds");
    jedis.disconnect();
}

四、管道中调用事务

就Jedis提供的方法而言,是可以做到在管道中使用事务,其代码如下:

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

但是经测试(见本文后续部分),发现其效率和单独使用事务差不多,甚至还略微差点。

五、分布式直连同步调用

@Test
public void test5shardNormal() {
    List 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();
}

这个是分布式直接连接,并且是同步调用,每步执行都返回执行结果。类似地,还有异步管道调用。

六、分布式直连异步调用

@Test
public void test6shardpipelined() {
    List 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 results = pipeline.syncAndReturnAll();
    long end = System.currentTimeMillis();
    System.out.println("Pipelined@Sharing SET: " + ((end - start)/1000.0) + " seconds");

    sharding.disconnect();
}

七、分布式连接池同步调用

如果,你的分布式调用代码是运行在线程中,那么上面两个直连调用方式就不合适了,因为直连方式是非线程安全的,这个时候,你就必须选择连接池调用。

@Test
public void test7shardSimplePool() {
    List 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();
}

上面是同步方式,当然还有异步方式。

八、分布式连接池异步调用

@Test
public void test8shardPipelinedPool() {
    List 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 results = pipeline.syncAndReturnAll();
    long end = System.currentTimeMillis();
    pool.returnResource(one);
    System.out.println("Pipelined@Pool SET: " + ((end - start)/1000.0) + " seconds");
    pool.destroy();
}

九、需要注意的地方

  1. 事务和管道都是异步模式。在事务和管道中不能同步查询结果。比如下面两个调用,都是不允许的:

     Transaction tx = jedis.multi();
     for (int i = 0; i < 100000; i++) {
         tx.set("t" + i, "t" + i);
     }
     System.out.println(tx.get("t1000").get());  //不允许
    
     List results = tx.exec();
    
     …
     …
    
     Pipeline pipeline = jedis.pipelined();
     long start = System.currentTimeMillis();
     for (int i = 0; i < 100000; i++) {
         pipeline.set("p" + i, "p" + i);
     }
     System.out.println(pipeline.get("p1000").get()); //不允许
    
     List results = pipeline.syncAndReturnAll();

  2. 事务和管道都是异步的,个人感觉,在管道中再进行事务调用,没有必要,不如直接进行事务模式。

  3. 分布式中,连接池的性能比直连的性能略好(见后续测试部分)。

  4. 分布式调用中不支持事务。

    因为事务是在服务器端实现,而在分布式中,每批次的调用对象都可能访问不同的机器,所以,没法进行事务。

  5. 十、测试

    运行上面的代码,进行测试,其结果如下:

    Simple SET: 5.227 seconds
    
    Transaction SET: 0.5 seconds
    Pipelined SET: 0.353 seconds
    Pipelined transaction: 0.509 seconds
    
    Simple@Sharing SET: 5.289 seconds
    Pipelined@Sharing SET: 0.348 seconds
    
    Simple@Pool SET: 5.039 seconds
    Pipelined@Pool SET: 0.401 seconds

    另外,经测试分布式中用到的机器越多,调用会越慢。上面是2片,下面是5片:

    Simple@Sharing SET: 5.494 seconds
    Pipelined@Sharing SET: 0.51 seconds
    Simple@Pool SET: 5.223 seconds
    Pipelined@Pool SET: 0.518 seconds

    下面是10片:

    Simple@Sharing SET: 5.9 seconds
    Pipelined@Sharing SET: 0.794 seconds
    Simple@Pool SET: 5.624 seconds
    Pipelined@Pool SET: 0.762 seconds

    下面是100片:

    Simple@Sharing SET: 14.055 seconds
    Pipelined@Sharing SET: 8.185 seconds
    Simple@Pool SET: 13.29 seconds
    Pipelined@Pool SET: 7.767 seconds

    分布式中,连接池方式调用不但线程安全外,根据上面的测试数据,也可以看出连接池比直连的效率更好。

    十一、完整的测试代码

    package com.example.NOSQLclient;
    
    import java.util.Arrays;
    import java.util.List;
    
    import org.junit.AfterClass;
    import org.junit.BeforeClass;
    import org.junit.Test;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPoolConfig;
    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;
    
    import org.junit.FixMethodOrder;
    import org.junit.runners.MethodSorters;
    
    @FixMethodOrder(MethodSorters.NAME_ASCENDING)
    public class TestJedis {
    
        private static Jedis jedis;
        private static ShardedJedis sharding;
        private static ShardedJedisPool pool;
    
        @BeforeClass
        public static void setUpBeforeClass() throws Exception {
            List shards = Arrays.asList(
                    new JedisShardInfo("localhost",6379),
                    new JedisShardInfo("localhost",6379)); //使用相同的ip:port,仅作测试
    
    
            jedis = new Jedis("localhost"); 
            sharding = new ShardedJedis(shards);
    
            pool = new ShardedJedisPool(new JedisPoolConfig(), shards);
        }
    
        @AfterClass
        public static void tearDownAfterClass() throws Exception {
            jedis.disconnect();
            sharding.disconnect();
            pool.destroy();
        }
    
        @Test
        public void test1Normal() {
            long start = System.currentTimeMillis();
            for (int i = 0; i < 100000; i++) {
                String result = jedis.set("n" + i, "n" + i);
            }
            long end = System.currentTimeMillis();
            System.out.println("Simple SET: " + ((end - start)/1000.0) + " seconds");
        }
    
        @Test
        public void test2Trans() {
            long start = System.currentTimeMillis();
            Transaction tx = jedis.multi();
            for (int i = 0; i < 100000; i++) {
                tx.set("t" + i, "t" + i);
            }
            //System.out.println(tx.get("t1000").get());
    
            List results = tx.exec();
            long end = System.currentTimeMillis();
            System.out.println("Transaction SET: " + ((end - start)/1000.0) + " seconds");
        }
    
        @Test
        public void test3Pipelined() {
            Pipeline pipeline = jedis.pipelined();
            long start = System.currentTimeMillis();
            for (int i = 0; i < 100000; i++) {
                pipeline.set("p" + i, "p" + i);
            }
            //System.out.println(pipeline.get("p1000").get());
            List results = pipeline.syncAndReturnAll();
            long end = System.currentTimeMillis();
            System.out.println("Pipelined SET: " + ((end - start)/1000.0) + " seconds");
        }
    
        @Test
        public void test4combPipelineTrans() {
            long start = System.currentTimeMillis();
            Pipeline pipeline = jedis.pipelined();
            pipeline.multi();
            for (int i = 0; i < 100000; i++) {
                pipeline.set("" + i, "" + i);
            }
            pipeline.exec();
            List results = pipeline.syncAndReturnAll();
            long end = System.currentTimeMillis();
            System.out.println("Pipelined transaction: " + ((end - start)/1000.0) + " seconds");
        }
    
        @Test
        public void test5shardNormal() {
            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");
        }
    
        @Test
        public void test6shardpipelined() {
            ShardedJedisPipeline pipeline = sharding.pipelined();
            long start = System.currentTimeMillis();
            for (int i = 0; i < 100000; i++) {
                pipeline.set("sp" + i, "p" + i);
            }
            List results = pipeline.syncAndReturnAll();
            long end = System.currentTimeMillis();
            System.out.println("Pipelined@Sharing SET: " + ((end - start)/1000.0) + " seconds");
        }
    
        @Test
        public void test7shardSimplePool() {
            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");
        }
    
        @Test
        public void test8shardPipelinedPool() {
            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 results = pipeline.syncAndReturnAll();
            long end = System.currentTimeMillis();
            pool.returnResource(one);
            System.out.println("Pipelined@Pool SET: " + ((end - start)/1000.0) + " seconds");
        }
    }

    上述内容就是Redis Java客户端Jedis的八种调用方式是什么,你们学到知识或技能了吗?如果还想学到更多技能或者丰富自己的知识储备,欢迎关注创新互联行业资讯频道。


    网站名称:RedisJava客户端Jedis的八种调用方式是什么
    分享网址:http://cdkjz.cn/article/jephdi.html
    多年建站经验

    多一份参考,总有益处

    联系快上网,免费获得专属《策划方案》及报价

    咨询相关问题或预约面谈,可以通过以下方式与我们联系

    大客户专线   成都:13518219792   座机:028-86922220