jedis操作redis的几种方式

Redis是一个著名的key-value存储系统，也是nosql中的最常见的一种。其实，个人认为，redis最强大的地方不在于其存储，而在于其强大的缓存作用。

我们可以把它想象成一个巨大的(多借点集群，聚合多借点的内存)的Map，也就是Key-Value。

所以，我们可以把它做成缓存组件。

官方推荐的Java版客户端是jedis，非常强大和稳定，支持事务、管道及有jedis自身实现。我们对redis数据的操作，都可以通过jedis来完成。

更多redis的概念，请参考：Redis集群(Redis3.0)

那我们就来看一看，jedis不同的调用方式：

(1)普通同步方式

这是一种最简单和最基础的调用方式，对于简单的数据存取需求，我们可以通过这种方式调用。

[java]  view plain  copy

 print ?

1. public void jedisNormal() {  
2.     Jedis jedis = new Jedis("localhost");  
3.     long start = System.currentTimeMillis();  
4.     for (int i = 0; i < 100000; i++) {  
5.         String result = jedis.set("n" + i, "n" + i);  
6.     }  
7.     long end = System.currentTimeMillis();  
8.     System.out.println("Simple SET: " + ((end - start)/1000.0) + " seconds");  
9.     jedis.disconnect();  
10. }  
11. //每次set之后都可以返回结果，标记是否成功。  

(2)事务方式(Transactions)

所谓事务，即一个连续操作，是否执行是一个事务，要么完成，要么失败，没有中间状态。

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

[java]  view plain  copy

 print ?

1. public void jedisTrans() {  
2.     Jedis jedis = new Jedis("localhost");  
3.     long start = System.currentTimeMillis();  
4.     Transaction tx = jedis.multi();  
5.     for (int i = 0; i < 100000; i++) {  
6.         tx.set("t" + i, "t" + i);  
7.     }  
8.     List<Object> results = tx.exec();  
9.     long end = System.currentTimeMillis();  
10.     System.out.println("Transaction SET: " + ((end - start)/1000.0) + " seconds");  
11.     jedis.disconnect();  
12. }  
13. //我们调用jedis.watch(…)方法来监控key，如果调用后key值发生变化，则整个事务会执行失败。另外，事务中某个操作失败，并不会回滚其他操作。这一点需要注意。还有，我们可以使用discard()方法来取消事务。  

(3)管道(Pipelining)

管道是一种两个进程之间单向通信的机制。

那再redis中，为何要使用管道呢？有时候，我们需要采用异步的方式，一次发送多个指令，并且，不同步等待其返回结果。这样可以取得非常好的执行效率。

[java]  view plain  copy

 print ?

1. public void jedisPipelined() {  
2.     Jedis jedis = new Jedis("localhost");  
3.     Pipeline pipeline = jedis.pipelined();  
4.     long start = System.currentTimeMillis();  
5.     for (int i = 0; i < 100000; i++) {  
6.         pipeline.set("p" + i, "p" + i);  
7.     }  
8.     List<Object> results = pipeline.syncAndReturnAll();  
9.     long end = System.currentTimeMillis();  
10.     System.out.println("Pipelined SET: " + ((end - start)/1000.0) + " seconds");  
11.     jedis.disconnect();  
12. }  

(4)管道中调用事务

对于，事务以及管道，这两个概念我们都清楚了。

在某种需求下，我们需要异步执行命令，但是，又希望多个命令是有连续的，所以，我们就采用管道加事务的调用方式。jedis是支持在管道中调用事务的。

[java]  view plain  copy

 print ?

1. public void jedisCombPipelineTrans() {  
2.     jedis = new Jedis("localhost");   
3.     long start = System.currentTimeMillis();  
4.     Pipeline pipeline = jedis.pipelined();  
5.     pipeline.multi();  
6.     for (int i = 0; i < 100000; i++) {  
7.         pipeline.set("" + i, "" + i);  
8.     }  
9.     pipeline.exec();  
10.     List<Object> results = pipeline.syncAndReturnAll();  
11.     long end = System.currentTimeMillis();  
12.     System.out.println("Pipelined transaction: " + ((end - start)/1000.0) + " seconds");  
13.     jedis.disconnect();  
14. }  
15. //效率上可能会有所欠缺  

(5)分布式直连同步调用

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

其实就是分片。

[java]  view plain  copy

 print ?

1. public void jedisShardNormal() {  
2.     List<JedisShardInfo> shards = Arrays.asList(  
3.             new JedisShardInfo("localhost",6379),  
4.             new JedisShardInfo("localhost",6380));  
5.    
6.     ShardedJedis sharding = new ShardedJedis(shards);  
7.    
8.     long start = System.currentTimeMillis();  
9.     for (int i = 0; i < 100000; i++) {  
10.         String result = sharding.set("sn" + i, "n" + i);  
11.     }  
12.     long end = System.currentTimeMillis();  
13.     System.out.println("Simple@Sharing SET: " + ((end - start)/1000.0) + " seconds");  
14.    
15.     sharding.disconnect();  
16. }  

(6)分布式直连异步调用

[java]  view plain  copy

 print ?

1. public void jedisShardpipelined() {  
2.     List<JedisShardInfo> shards = Arrays.asList(  
3.             new JedisShardInfo("localhost",6379),  
4.             new JedisShardInfo("localhost",6380));  
5.    
6.     ShardedJedis sharding = new ShardedJedis(shards);  
7.    
8.     ShardedJedisPipeline pipeline = sharding.pipelined();  
9.     long start = System.currentTimeMillis();  
10.     for (int i = 0; i < 100000; i++) {  
11.         pipeline.set("sp" + i, "p" + i);  
12.     }  
13.     List<Object> results = pipeline.syncAndReturnAll();  
14.     long end = System.currentTimeMillis();  
15.     System.out.println("Pipelined@Sharing SET: " + ((end - start)/1000.0) + " seconds");  
16.    
17.     sharding.disconnect();  
18. }  

(7)分布式连接池同步调用

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

连接池的调用方式，适合大规模的redis集群，并且多客户端的操作。

[java]  view plain  copy

 print ?

1. public void jedisShardSimplePool() {  
2.     List<JedisShardInfo> shards = Arrays.asList(  
3.             new JedisShardInfo("localhost",6379),  
4.             new JedisShardInfo("localhost",6380));  
5.    
6.     ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards);  
7.    
8.     ShardedJedis one = pool.getResource();  
9.    
10.     long start = System.currentTimeMillis();  
11.     for (int i = 0; i < 100000; i++) {  
12.         String result = one.set("spn" + i, "n" + i);  
13.     }  
14.     long end = System.currentTimeMillis();  
15.     pool.returnResource(one);  
16.     System.out.println("Simple@Pool SET: " + ((end - start)/1000.0) + " seconds");  
17.    
18.     pool.destroy();  
19. }  

(8)分布式连接池异步调用

[java]  view plain  copy

 print ?

1. public void jedisShardPipelinedPool() {  
2.     List<JedisShardInfo> shards = Arrays.asList(  
3.             new JedisShardInfo("localhost",6379),  
4.             new JedisShardInfo("localhost",6380));  
5.    
6.     ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards);  
7.    
8.     ShardedJedis one = pool.getResource();  
9.    
10.     ShardedJedisPipeline pipeline = one.pipelined();  
11.    
12.     long start = System.currentTimeMillis();  
13.     for (int i = 0; i < 100000; i++) {  
14.         pipeline.set("sppn" + i, "n" + i);  
15.     }  
16.     List<Object> results = pipeline.syncAndReturnAll();  
17.     long end = System.currentTimeMillis();  
18.     pool.returnResource(one);  
19.     System.out.println("Pipelined@Pool SET: " + ((end - start)/1000.0) + " seconds");  
20.     pool.destroy();  
21. }  

(9)需要注意的地方

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

• [java]  view plain  copy

   print ?

  1. Transaction tx = jedis.multi();  
  2.  for (int i = 0; i < 100000; i++) {  
  3.      tx.set("t" + i, "t" + i);  
  4.  }  
  5.  System.out.println(tx.get("t1000").get());  //不允许  
  6.    
  7.  List<Object> results = tx.exec();  
  8.    
  9.  …  
  10.  …  
  11.    
  12.  Pipeline pipeline = jedis.pipelined();  
  13.  long start = System.currentTimeMillis();  
  14.  for (int i = 0; i < 100000; i++) {  
  15.      pipeline.set("p" + i, "p" + i);  
  16.  }  
  17.  System.out.println(pipeline.get("p1000").get()); //不允许  
  18.    
  19.  List<Object> results = pipeline.syncAndReturnAll();  
  
  
  

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

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

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

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

(10)总结

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

• 经测试分布式中用到的机器越多，调用会越慢。