Spring data redis-StringRedisTemplate 用法

Spring-data-redis为spring-data模块中对redis的支持部分，简称为“SDR”，提供了基于jedis客户端API的高度封装以及与spring容器的整合，事实上jedis客户端已经足够简单和轻量级，而spring-data-redis反而具有“过度设计”的嫌疑。

一. jedis客户端在编程实施方面存在如下不足：

    1) connection管理缺乏自动化，connection-pool的设计缺少必要的容器支持。

    2) 数据操作需要关注“序列化”/“反序列化”，因为jedis的客户端API接受的数据类型为string和byte，对结构化数据(json,xml,pojo等)操作需要额外的支持。

    3) 事务操作纯粹为硬编码

    4) pub/sub功能，缺乏必要的设计模式支持，对于开发者而言需要关注的太多。

    不过jedis与spring整合，也是非常的简单，参见“jedis连接池实例”.

 

二. spring-data-redis针对jedis提供了如下功能：

    1. 连接池自动管理，提供了一个高度封装的“RedisTemplate”类

    2. 针对jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口

• ValueOperations：简单K-V操作
• SetOperations：set类型数据操作
• ZSetOperations：zset类型数据操作
• HashOperations：针对map类型的数据操作

• ListOperations：针对list类型的数据操作

    3. 提供了对key的“bound”(绑定)便捷化操作API，可以通过bound封装指定的key，然后进行一系列的操作而无须“显式”的再次指定Key，即BoundKeyOperations：

• BoundValueOperations
• BoundSetOperations
• BoundListOperations
• BoundSetOperations
• BoundHashOperations

  

    4. 将事务操作封装，有容器控制。

    5. 针对数据的“序列化/反序列化”，提供了多种可选择策略(RedisSerializer)

• JdkSerializationRedisSerializer：POJO对象的存取场景，使用JDK本身序列化机制，将pojo类通过ObjectInputStream/ObjectOutputStream进行序列化操作，最终redis-server中将存储字节序列。是目前最常用的序列化策略。
• StringRedisSerializer：Key或者value为字符串的场景，根据指定的charset对数据的字节序列编码成string，是“new String(bytes, charset)”和“string.getBytes(charset)”的直接封装。是最轻量级和高效的策略。
• JacksonJsonRedisSerializer：jackson-json工具提供了javabean与json之间的转换能力，可以将pojo实例序列化成json格式存储在redis中，也可以将json格式的数据转换成pojo实例。因为jackson工具在序列化和反序列化时，需要明确指定Class类型，因此此策略封装起来稍微复杂。【需要jackson-mapper-asl工具支持】
• OxmSerializer：提供了将javabean与xml之间的转换能力，目前可用的三方支持包括jaxb，apache-xmlbeans；redis存储的数据将是xml工具。不过使用此策略，编程将会有些难度，而且效率最低；不建议使用。【需要spring-oxm模块的支持】

    针对“序列化和发序列化”中JdkSerializationRedisSerializer和StringRedisSerializer是最基础的策略，原则上，我们可以将数据存储为任何格式以便应用程序存取和解析(其中应用包括app，hadoop等其他工具)，不过在设计时仍然不推荐直接使用“JacksonJsonRedisSerializer”和“OxmSerializer”，因为无论是json还是xml，他们本身仍然是String。

    如果你的数据需要被第三方工具解析，那么数据应该使用StringRedisSerializer而不是JdkSerializationRedisSerializer。

    如果你的数据格式必须为json或者xml，那么在编程级别，在redisTemplate配置中仍然使用StringRedisSerializer，在存储之前或者读取之后，使用“SerializationUtils”工具转换转换成json或者xml，请参见下文实例。

    6. 基于设计模式，和JMS开发思路，将pub/sub的API设计进行了封装，使开发更加便捷。

    7.spring-data-redis中，并没有对sharding提供良好的封装，如果你的架构是基于sharding，那么你需要自己去实现，这也是sdr和jedis相比，唯一缺少的特性。

三. 有关BoundKeyOperations中API的用法

1. /**
2. * 需要指定hashtable的名字
3. *
4. * @param tableName
5. */
6. public void boundHashOps(String tableName) {
7. System.out.println("==================Hash==============");
8. BoundHashOperations<String, String, String> ops = stringRedisTemplate
9. .boundHashOps(tableName);
10. stringRedisTemplate.delete("student");
11. stringRedisTemplate.delete("student:1");
12. ops.put("cs01", "123");// 存入数据 ops.putAll(maps); 存入多条数据
13. String key1 = ops.getKey();// tableName的名字
14. System.out.println("key1:" + key1);
15. String key11 = ops.get("cs01");
16. System.out.println("key11:" + key11);// 获取key的值
17.  
18. ops.putIfAbsent("cs02", "456");
19. String key2 = ops.getKey();
20. System.out.println("ops.getKey()-key2:" + key2);
21. String key21 = ops.get("cs02");
22. System.out.println("ops.get(cs02)-key21:" + key21);
23.  
24. Map<String, String> maps = ops.entries();// 获取所有的key-value值
25. for (String key : maps.keySet()) {
26. System.out.println("map-key:" + key + "map-value:" + maps.get(key));
27. }
28. // ops.persist();//删除过期(如果有的话)的数据。
29. System.out.println("ops.getExpire():" + ops.getExpire());// -1
30. System.out.println("ops.expireAt(new Date()):"
31. + ops.expireAt(new Date()));// true 设置生存过期时间
32. System.out.println("ops.getType():" + ops.getType());// Hash
33. System.out.println("ops.hasKey(cs01):" + ops.hasKey("cs01"));// true
34. System.out.println("ops.hasKey(cs02):" + ops.hasKey("cs02"));// true
35. System.out.println("ops.size():" + ops.size());// 2
36.  
37. Set<String> keys = ops.keys();// 获取所有的key
38. for (String string : keys) {
39. System.out.println("ops.keys():" + string);
40. }
41.  
42. System.out.println("ops.values():" + ops.values());// 获取所有的value
43. System.out.println("ops.size():" + ops.size());// 2 获取数量
44.  
45. ops.delete("cs01");// 删除key为cs01的数据
46. }
47.  
48. /**
49. * 未指定hashtable的名字
50. *
51. * @param tableName
52. */
53. public void opsForHash(String tableName) {
54. System.out.println("==================Hash==============");
55. HashOperations<String, Object, Object> ops = stringRedisTemplate
56. .opsForHash();
57. stringRedisTemplate.delete("student");
58. stringRedisTemplate.delete("student:1");
59. ops.put(tableName, "cs01", "123");// 存入数据 ops.putAll(maps); 存入多条数据
60. Object key11 = ops.get(tableName, "cs01");
61. System.out.println("key11:" + key11);// 获取key的值
62.  
63. ops.putIfAbsent(tableName, "cs02", "456");
64. Object key21 = ops.get(tableName, "cs02");
65. System.out.println("ops.get(cs02)-key21:" + key21);
66.  
67. Map<Object, Object> maps = ops.entries(tableName);// 获取所有的key-value值
68. for (Object key : maps.keySet()) {
69. System.out.println("map-key:" + key + "map-value:" + maps.get(key));
70. }
71. // ops.persist();//删除过期(如果有的话)的数据。
72. System.out.println("ops.hasKey(cs01):"
73. + ops.hasKey(tableName, "cs01"));// true
74. System.out.println("ops.hasKey(cs02):"
75. + ops.hasKey(tableName, "cs02"));// true
76. System.out.println("ops.size():" + ops.size(tableName));// 2
77.  
78. Set<Object> keys = ops.keys(tableName);// 获取所有的key
79. for (Object string : keys) {
80. System.out.println("ops.keys():" + string);
81. }
82.  
83. System.out.println("ops.values():"
84. + ops.values(tableName));// 获取所有的value
85. System.out.println("ops.size():"
86. + ops.size(tableName));// 2 获取数量
87.  
88. ops.delete("cs01");// 删除key为cs01的数据
89. }
90.  
91. /**
92. * List 里面有重复数据
93. *
94. * @param tableName
95. */
96. public void boundListOps(String tableName) {
97. System.out.println("==================List==============");
98. BoundListOperations<String, String> ops = stringRedisTemplate
99. .boundListOps(tableName);
100. ops.leftPush("cs01");// left push 左侧入栈，先进后出，和右侧相比，左侧先出
101. ops.leftPushIfPresent("cs011");// 不知道和上面的有什么区别
102. ops.leftPush("cs01", "cs0111");// 在cs01的左侧入栈
103. ops.leftPushAll("cs01111", "cs011111");
104.  
105. List<String> values = ops.range(0, -1);
106. for (String string : values) {
107. System.out.println("letf push:" + string);
108. }
109.  
110. ops.rightPush("cs02");// right push 右侧入栈 先进先出 ，和左侧相比，左侧先出
111. ops.rightPushIfPresent("cs022");
112. ops.rightPush("cs02", "cs0222");// 在cs02的右侧入栈
113. ops.rightPushAll("cs02222", "cs022222");
114.  
115. ops.set(0, "cs04");// 把第一个数据替换成cs04
116. // ops.trim(0, 3);//从第一个数据到第4个数据删除
117.  
118. List<String> values1 = ops.range(0, -1);// 查出所有数据
119. for (String string : values1) {
120. System.out.println("right push:" + string);
121. }
122.  
123. List<String> values2 = ops.range(1, 2);// 查出从第二个到第三个
124. for (String string : values2) {
125. System.out.println("right push1:" + string);
126. }
127. System.out.println("ops.index(1):" + ops.index(0));// 获得第一个数据
128. System.out.println("ops.remove(0, cs01):"
129. + ops.remove(0, "cs01"));// 1,删除“cs01”
130. System.out.println("ops.leftPop():" + ops.leftPop());// 左侧出栈
131. System.out.println("ops.rightPop():" + ops.rightPop());// 右侧出栈
132. System.out.println("ops.remove(0, cs01)1:"
133. + ops.remove(0, "cs01"));// 0 ,如果“cs01”不存在返回0
134.  
135. // ops.persist();//删除过期(如果有的话)的数据。
136. }
137.  
138. public void boundSetOps() {
139. System.out.println("==================Set==============");
140. String tableName2 = "caoshuai03";
141. BoundSetOperations<String, String> ops = stringRedisTemplate
142. .boundSetOps(tableName2);
143.  
144. String[] values = { "cs03", "cs04" };
145. System.out.println("ops.add(values):"
146. + ops.add(values));// 添加多条数据到set里,返回添加的数量
147.  
148. Set<String> sets1 = ops.members();// 获取set里的所有数据,每次显示的顺序可能不一样
149. for (String string : sets1) {
150. System.out.println("ops.members()1:" + string);
151. }
152.  
153. // 获取随机的数
154. System.out.println("ops.randomMember():" + ops.randomMember());
155. // 获取一个随机数
156. System.out.println("ops.randomMembers(1):" + ops.randomMembers(1));
157. // 获取两个随机数，值可能一样
158. System.out.println("ops.randomMembers(2):" + ops.randomMembers(2));
159.  
160. System.out.println("ops.distinctRandomMembers(1):"
161. + ops.distinctRandomMembers(1));// 获取一个随机数
162. System.out.println("ops.distinctRandomMembers(2):"
163. + ops.distinctRandomMembers(2));// 获取两个不一样的随机数
164.  
165. System.out.println(ops.isMember("cs04"));// 是否含有cs04,有的话返回true
166. System.out.println(ops.isMember("cs01"));// 没有返回false
167.  
168. System.out.println(ops.size());// set里数据量
169.  
170. System.out.println(ops.getKey());// 获取set的名字
171.  
172. System.out.println(ops.getType());// 获取类型
173.  
174. Set<String> set7 = ops.diff("caoshuai02");// 获取和另一set里不一样的数据，差集
175. for (String string : set7) {
176. System.out.println("ops.diff(caoshuai02):" + string);
177. }
178.  
179. // 获取和另一set里一样的数据，交集
180. Set<String> set8 = ops.intersect("caoshuai02");
181. for (String string : set8) {
182. System.out.println("ops.intersect(caoshuai02):" + string);
183. }
184.  
185. // 获取另一set所有的数据，和自己合并起来，去掉重复的数据，并集
186. Set<String> set6 = ops.union("caoshuai02");
187. for (String string : set6) {
188. System.out.println("ops.union(caoshuai02):" + string);
189. }
190.  
191. // 获取和其它set里一样的数据，交集
192. List<String> keys = new ArrayList<String>();
193. keys.add("caoshuai02");
194. Set<String> set = ops.intersect(keys);
195. for (String string : set) {
196. System.out.println("ops.intersect(keys):" + string);
197. }
198.  
199. // 获取和其它set里不一样的数据，差集
200. List<String> keys1 = new ArrayList<String>();
201. keys1.add("caoshuai02");
202. Set<String> set3 = ops.diff(keys);
203. for (String string : set3) {
204. System.out.println("ops.diff(keys)3:" + string);
205. }
206.  
207. // 获取其它set所有的数据，和自己合并起来，去掉重复的数据，并集
208. List<String> keys2 = new ArrayList<String>();
209. keys2.add("caoshuai02");
210. Set<String> set4 = ops.union(keys2);
211. for (String string : set4) {
212. System.out.println("ops.union(keys2):" + string);
213. }
214.  
215. // 获取和另一set里不一样的数据，差集,存入到另一set里
216. ops.diffAndStore("caoshuai02", "caoshuai04");
217. // ops.diffAndStore(keys, destKey);
218.  
219. // 获取和另一set里一样的数据，交集，存入到另一set里
220. ops.intersectAndStore("caoshuai02", "caoshuai05");
221. // ops.intersectAndStore(keys, destKey);
222.  
223. // 获取另一set里的所有数据，并集，存入到另一set里
224. ops.unionAndStore("caoshuai02", "caoshuai06");
225. // ops.unionAndStore(keys, destKey);
226.  
227. // 把指定的数据移到另一set里，移动成功返回true
228. System.out.println(ops.move("caoshuai07", "cs03"));
229. // 把指定的数据移到另一set里，移动失败，返回false，注：当前set里没有cs01
230. System.out.println(ops.move("caoshuai07", "cs01"));
231.  
232. System.out.println(ops.pop());// pop出一个数据,第一个数据被pop出
233.  
234. System.out.println(ops.remove("cs03"));// 删除多个数据，返回删除的个数
235. System.out.println(ops.remove("cs01"));// 删除数据，返回删除的个数
236. }
237.  
238. public void boundValueOps() {
239. System.out.println("==================String==============");
240. String tableName2 = "LiMing01";
241. BoundValueOperations<String, String> ops = stringRedisTemplate
242. .boundValueOps(tableName2);
243.  
244. System.out.println(ops.append("stu01"));// 添加数据，返回添加数据字符的个数
245.  
246. // 先获取原先存在的数据，再添加数据覆盖原先的
247. System.out.println(ops.getAndSet("stu02"));
248.  
249. System.out.println(ops.get());// 获取添加的数据
250.  
251. System.out.println(ops.get(0, 1));//获取从第一个开始到第二个结束的字符
252. System.out.println(ops.get(0, 5));//获取从第一个开始到第六个结束的数据，注实际只有两个数据
253.  
254. System.out.println(ops.size());//获取数据字符的个数
255. ops.set("stu03");//添加数据
256. System.out.println("ops.set(stu03):" + ops.get());// 获取添加的数据
257. ops.set("stu04", 0);//在位置0处添加数据
258. System.out.println("ops.set(stu04, 0):" + ops.get());// 获取添加的数据
259.  
260. //如果原先的string里有数据，则使用此方法set新数据会失败，并返回false
261. System.out.println(ops.setIfAbsent("stu04"));
262. System.out.println("ops.setIfAbsent(stu04):" +ops.get());// 获取添加的数据
263.  
264. stringRedisTemplate.delete(tableName2);//删除此string
265. //如果原先的string里没有数据，则使用此方法set新数据会成功并返回true
266. System.out.println(ops.setIfAbsent("stu06"));
267. System.out.println("ops.setIfAbsent(stu06):" + ops.get());// 获取添加的数据
268. ops.set("stu05", 30, TimeUnit.SECONDS);//设置30秒过期
269. }
270.  
271. public void boundZSetOps() {
272. System.out.println("==================Zset==============");
273. String tableName2 = "LiMing03";
274. BoundZSetOperations<String, String> ops = stringRedisTemplate
275. .boundZSetOps(tableName2);
276.  
277. System.out.println(ops.add("stu01", 1));//Zset里添加数据
278. System.out.println(ops.add("stu03", 1));//Zset里添加数据
279.  
280. System.out.println(ops.count(0, 1));//返回score在给定区间的数量
281.  
282. //添加数据和score,返回score的大小，如果stu04存在，则只需score相加即可
283. //例如：原先存在数据stu04 score是2.0，执行下面语句后变为:stu04， score:6.0
284. System.out.println(ops.incrementScore("stu04", 4));
285.  
286. ops.intersectAndStore("LiMing02", "LiMing04");
287. //ops.intersectAndStore(otherKeys, destKey);
288. ops.unionAndStore("LiMing02", "LiMing05");
289. //ops.unionAndStore(otherKeys, destKey);
290.  
291. Set<TypedTuple<String>> sets = new HashSet<TypedTuple<String>>();
292. TypedTuple<String> typedTuple = new TypedTuple<String>() {
293.  
294. @Override
295. public int compareTo(TypedTuple<String> o) {
296. // TODO Auto-generated method stub
297. return 0;
298. }
299.  
300. @Override
301. public String getValue() {
302. // TODO Auto-generated method stub
303. return "stu06";
304. }
305.  
306. @Override
307. public Double getScore() {
308. // TODO Auto-generated method stub
309. return 6.0;
310. }
311. };
312. sets.add(typedTuple);
313. ops.add(sets);//添加数据
314.  
315. Set<String> set1 = ops.range(0, -1); //返回指定区间的元素
316. for (String string : set1) {
317. System.out.println("ops.range(0, 1):" + string);
318. }
319.  
320. Set<String> set2 = ops.rangeByScore(1, 4);//返回指定score区间的元素，包含1和4
321. for (String string : set2) {
322. System.out.println("ops.rangeByScore(0, 4):" + string);
323. }
324.  
325. //返回指定位置的元素
326. Set<TypedTuple<String>> set3 = ops.rangeWithScores(0, 4);
327. for (TypedTuple<String> string : set3) {
328. System.out.println("ops.rangeByScore(0, 4):" + string.getValue()
329. + "score:" + string.getScore());
330. }
331.  
332. System.out.println(ops.remove("stu01"));//删除数据，返回删除数据的个数
333.  
334. Set<String> set5 = ops.range(0, -1); //返回指定区间的元素
335. for (String string : set5) {
336. System.out.println("ops.range(0, 1)5:" + string);
337. }
338.  
339. ops.removeRangeByScore(1, 4);//删除score的范围是1和4的数，包含1和4
340.  
341. Set<String> set6 = ops.range(0, -1); //返回指定区间的元素
342. for (String string : set6) {
343. System.out.println("ops.range(0, 1)6:" + string);
344. }
345.  
346. ops.removeRange(0, 1);//删除懂第一个开始到第二个结束的数据
347.  
348. Set<String> set7 = ops.range(0, -1); //返回指定区间的元素
349. for (String string : set7) {
350. System.out.println("ops.range(0, 1)7:" + string);
351. }
352. }