Jedis的八种调用方式（功能：事务，管道）

    1. packagecom.irwin.redis;

    2.  

    3. importjava.util.Arrays;

    4. importjava.util.List;

    5.  

    6. importorg.junit.Test;

    7.  

    8. importredis.clients.jedis.Jedis;

    9. importredis.clients.jedis.JedisPoolConfig;

    10. importredis.clients.jedis.JedisShardInfo;

    11. importredis.clients.jedis.Pipeline;

    12. importredis.clients.jedis.ShardedJedis;

    13. importredis.clients.jedis.ShardedJedisPipeline;

    14. importredis.clients.jedis.ShardedJedisPool;

    15. importredis.clients.jedis.Transaction;

    16.  

    17. publicclassRedisConnectKindsTests{

    18. Jedisjedis=newJedis("192.168.56.101",6379);

    19.  

    20. //普通同步方式

    21. //最简单和基础的调用方式，每次执行命令后都可以返回结果，标记是否成功

    22. @Test

    23. publicvoidtestNormal(){

    24.  

    25. longstart=System.currentTimeMillis();

    26. for(inti=0;i<5;i++){

    27. Stringresult=jedis.set("n"+i,"n"+i);

    28. System.out.println(result);

    29. }

    30. longend=System.currentTimeMillis();

    31. System.out.println("SimpleSET:"+((end-start)/1000.0)+"seconds");

    32. jedis.disconnect();

    33. }

    34.  

    35. //事务方式

    36. //保障一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令

    37. //调用jedis.watch(…)方法来监控key，如果调用后key值发生变化，则整个事务会执行失败。

    38. //另外，事务中某个操作失败，并不会回滚其他操作。这一点需要注意。还有，我们可以使用discard()方法来取消事务。

    39. @Test

    40. publicvoidtest2Transactions(){

    41. longstart=System.currentTimeMillis();

    42. Transactiontx=jedis.multi();

    43. for(inti=0;i<10;i++){

    44. tx.set("t"+i,"t"+i);

    45. }

    46. System.out.println(jedis.watch("t1","t2"));

    47.  

    48. //tx.discard();

    49. List<Object>results=tx.exec();

    50. longend=System.currentTimeMillis();

    51. jedis.disconnect();

    52. }

    53.  

    54. //管道

    55. //要采用异步方式，一次发送多个指令，不同步等待其返回结果

    56. @Test

    57. publicvoidtest3Pipelined(){

    58. Pipelinepipeline=jedis.pipelined();

    59. for(inti=0;i<10;i++){

    60. pipeline.set("p"+i,"p"+i);

    61. }

    62. List<Object>results=pipeline.syncAndReturnAll();

    63. for(Objectobject:results){

    64. System.out.println(object);

    65. }

    66. jedis.disconnect();

    67. }

    68.  

    69. //管道中调用事务

    70. //Jedis提供的方法而言，是可以做到在管道中使用事务

    71. @Test

    72. publicvoidtest4combPipelineTrans(){

    73. Pipelinepipeline=jedis.pipelined();

    74. pipeline.multi();

    75.  

    76. for(inti=0;i<10;i++){

    77. pipeline.set(""+i,""+i);

    78. }

    79.  

    80. List<Object>results=pipeline.syncAndReturnAll();

    81. jedis.disconnect();

    82. }

    83.  

    84. //分布式直连同步调用

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

    86. @Test

    87. publicvoidtest4ShardNormal(){

    88. List<JedisShardInfo>shards=Arrays.asList(

    89. newJedisShardInfo("192.168.56.101",6379),

    90. newJedisShardInfo("192.168.56.101",6179)

    91. );

    92.  

    93. ShardedJedissharding=newShardedJedis(shards);

    94.  

    95. for(inti=0;i<10;i++){

    96. Stringresult=sharding.set("sn"+i,"n"+i);

    97. System.out.println(result);

    98. }

    99. sharding.disconnect();

    100. }

    101.  

    102. //分布式直连异步调用

    103. @Test

    104. publicvoidtest6shardpipelined(){

    105. List<JedisShardInfo>shards=Arrays.asList(

    106. newJedisShardInfo("192.168.56.101",6379),

    107. newJedisShardInfo("192.168.56.101",6179)

    108. );

    109.  

    110. ShardedJedissharding=newShardedJedis(shards);

    111.  

    112. ShardedJedisPipelinepipeline=sharding.pipelined();

    113. longstart=System.currentTimeMillis();

    114. for(inti=0;i<100000;i++){

    115. pipeline.set("sp"+i,"p"+i);

    116. }

    117. List<Object>results=pipeline.syncAndReturnAll();

    118. longend=System.currentTimeMillis();

    119. System.out.println("Pipelined@SharingSET:"+((end-start)/1000.0)+"seconds");

    120.  

    121. sharding.disconnect();

    122. }

    123.  

    124. //分布式连接池同步调用

    125. //分布式调用代码是运行在线程中，那么上面两个直连调用方式就不合适了，

    126. //因为直连方式是非线程安全的，这个时候，你就必须选择连接池调用

    127. @Test

    128. publicvoidtest7shardSimplePool(){

    129. List<JedisShardInfo>shards=Arrays.asList(

    130. newJedisShardInfo("192.168.56.101",6379),

    131. newJedisShardInfo("192.168.56.101",6179)

    132. );

    133.  

    134. ShardedJedisPoolpool=newShardedJedisPool(newJedisPoolConfig(),shards);

    135.  

    136. ShardedJedisone=pool.getResource();

    137.  

    138. longstart=System.currentTimeMillis();

    139. for(inti=0;i<10;i++){

    140. Stringresult=one.set("spn"+i,"n"+i);

    141. System.out.println(result);

    142. }

    143. longend=System.currentTimeMillis();

    144. pool.returnResource(one);

    145. System.out.println("Simple@PoolSET:"+((end-start)/1000.0)+"seconds");

    146.  

    147. pool.destroy();

    148. }

    149.  

    150. //分布式连接池异步调用

    151. @Test

    152. publicvoidtest8shardPipelinedPool(){

    153. List<JedisShardInfo>shards=Arrays.asList(

    154. newJedisShardInfo("192.168.56.101",6379),

    155. newJedisShardInfo("192.168.56.101",6179)

    156. );

    157.  

    158. ShardedJedisPoolpool=newShardedJedisPool(newJedisPoolConfig(),shards);

    159.  

    160. ShardedJedisone=pool.getResource();

    161.  

    162. ShardedJedisPipelinepipeline=one.pipelined();

    163.  

    164. longstart=System.currentTimeMillis();

    165. for(inti=0;i<100000;i++){

    166. pipeline.set("sppn"+i,"n"+i);

    167. }

    168. List<Object>results=pipeline.syncAndReturnAll();

    169. longend=System.currentTimeMillis();

    170. pool.returnResource(one);

    171. System.out.println("Pipelined@PoolSET:"+((end-start)/1000.0)+"seconds");

    172. pool.destroy();

    173. }

    174. }

总结：

1、事务和管道都是异步模式。在事务和管道中不能同步查询结果。

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

3、分布式中，连接池的性能比直连的性能略好

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

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