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