征服 Redis + Jedis + Spring （三）—— 列表操作

通过spring-data-redis完成LINDEX, LLEN, LPOP, LPUSH, LRANGE, LREM, LSET, LTRIM, RPOP, RPUSH命令。其实还有一些命令，当前版本不支持。不过，这些List的操作方法可以实现队列，堆栈的正常操作，足够用了。

为了简便操作，我使用了StringRedisTemplate。用字符串操作做展示。当然，你可以继续使用RedisTemplate。

闲言少叙，上代码，一目了然：

Java代码

1. /**
2. *Mar5,2013
3. */
4. packageorg.zlex.redis.support;
6. importjava.util.List;
8. importorg.springframework.beans.factory.annotation.Autowired;
9. importorg.springframework.data.redis.core.StringRedisTemplate;
10. importorg.springframework.stereotype.Component;
12. /**
13. *
14. *@authorsnowolf
15. *@version1.0
16. *@since1.0
17. */
18. @Component("listOps")
19. publicclassListOps{
21. @Autowired
22. privateStringRedisTemplatestringRedisTemplate;
24. /**
25. *压栈
26. *
27. *@paramkey
28. *@paramvalue
29. *@return
30. */
31. publicLongpush(Stringkey,Stringvalue){
32. returnstringRedisTemplate.opsForList().leftPush(key,value);
33. }
35. /**
36. *出栈
37. *
38. *@paramkey
39. *@return
40. */
41. publicStringpop(Stringkey){
42. returnstringRedisTemplate.opsForList().leftPop(key);
43. }
45. /**
46. *入队
47. *
48. *@paramkey
49. *@paramvalue
50. *@return
51. */
52. publicLongin(Stringkey,Stringvalue){
53. returnstringRedisTemplate.opsForList().rightPush(key,value);
54. }
56. /**
57. *出队
58. *
59. *@paramkey
60. *@return
61. */
62. publicStringout(Stringkey){
63. returnstringRedisTemplate.opsForList().leftPop(key);
64. }
66. /**
67. *栈/队列长
68. *
69. *@paramkey
70. *@return
71. */
72. publicLonglength(Stringkey){
73. returnstringRedisTemplate.opsForList().size(key);
74. }
76. /**
77. *范围检索
78. *
79. *@paramkey
80. *@paramstart
81. *@paramend
82. *@return
83. */
84. publicList<String>range(Stringkey,intstart,intend){
85. returnstringRedisTemplate.opsForList().range(key,start,end);
86. }
88. /**
89. *移除
90. *
91. *@paramkey
92. *@parami
93. *@paramvalue
94. */
95. publicvoidremove(Stringkey,longi,Stringvalue){
96. stringRedisTemplate.opsForList().remove(key,i,value);
97. }
99. /**
100. *检索
101. *
102. *@paramkey
103. *@paramindex
104. *@return
105. */
106. publicStringindex(Stringkey,longindex){
107. returnstringRedisTemplate.opsForList().index(key,index);
108. }
110. /**
111. *置值
112. *
113. *@paramkey
114. *@paramindex
115. *@paramvalue
116. */
117. publicvoidset(Stringkey,longindex,Stringvalue){
118. stringRedisTemplate.opsForList().set(key,index,value);
119. }
121. /**
122. *裁剪
123. *
124. *@paramkey
125. *@paramstart
126. *@paramend
127. */
128. publicvoidtrim(Stringkey,longstart,intend){
129. stringRedisTemplate.opsForList().trim(key,start,end);
130. }
131. }

这里说明下，例如LPUSH，RPUSH，其实就是从左边压栈，还是从右边压栈的不同命令。可以把堆栈看作是一个从左至右的数组。如果左边压栈，右边出栈，那就是队列的入队/出队操作；如果左边压栈，左边出栈，那就是堆栈操作。

举个具体的例子：

队列操作：LPUSH入队，RPOP出队，同理，可把L|R替换。

堆栈操作：LPUSH压栈，LPOP出栈，同理，可把L|R替换。

下面进行测试用例，初始、结束时，分别做入队、出队操作，期间进行堆栈，队列操作。不用我细说了，看测试用例，很简单！

Java代码

1. /**
2. *Mar5,2013
3. */
4. packageorg.zlex.redis;
6. importstaticorg.junit.Assert.*;
8. importjava.util.List;
10. importorg.junit.Before;
11. importorg.junit.After;
12. importorg.junit.Test;
13. importorg.springframework.context.ApplicationContext;
14. importorg.springframework.context.support.ClassPathXmlApplicationContext;
15. importorg.zlex.redis.support.ListOps;
17. /**
18. *
19. *@authorsnowolf
20. *@version1.0
21. *@since1.0
22. */
23. publicclassListOpsTest{
24. privateApplicationContextapp;
25. privateListOpslistOps;
26. privateStringkey="queue";
28. @Before
29. publicvoidbefore()throwsException{
30. app=newClassPathXmlApplicationContext("applicationContext.xml");
31. listOps=(ListOps)app.getBean("listOps");
33. System.out.println("------------IN---------------");
34. for(inti=0;i<5;i++){
35. Stringuid="u"+i;
36. System.out.println(uid);
37. listOps.in(key,uid);
38. }
39. }
41. @After
42. publicvoidafter(){
43. //------------OUT---------------
44. System.out.println("------------OUT---------------");
45. longlength=listOps.length(key);
46. for(longi=0;i<length;i++){
47. Stringuid=listOps.out(key);
48. System.out.println(uid);
49. }
50. }
52. @Test
53. publicvoidstack(){
54. //------------PUSH---------------
55. Stringkey="stack";
56. intlen=5;
57. System.out.println("------------PUSH---------------");
58. for(inti=0;i<len;i++){
59. Stringuid="u"+System.currentTimeMillis();
60. System.out.println(uid);
61. listOps.push(key,uid);
62. }
64. longlength=listOps.length(key);
65. assertEquals(len,length);
67. //------------POP---------------
68. System.out.println("------------POP---------------");
69. for(longi=0;i<length;i++){
70. Stringuid=listOps.pop(key);
71. System.out.println(uid);
72. }
73. }
75. @Test
76. publicvoidindex(){
78. //-------------INDEX-------------
79. Stringvalue=listOps.index(key,3);
80. assertEquals("u3",value);
81. }
83. @Test
84. publicvoidrange(){
85. //-------------RANGE-------------
86. List<String>list=listOps.range(key,3,5);
87. booleanresult1=list.contains("u3");
88. assertEquals(true,result1);
90. booleanresult2=list.contains("u1");
91. assertEquals(false,result2);
92. }
94. @Test
95. publicvoidtrim(){
96. //------------TRIM---------------
97. List<String>list=listOps.range(key,3,5);
98. listOps.trim(key,3,5);
99. booleanresult3=list.contains("u1");
100. assertEquals(false,result3);
101. }
103. @Test
104. publicvoidset(){
105. //------------SET-----------------
106. List<String>list=listOps.range(key,3,5);
107. listOps.set(key,4,"ux4");
108. booleanresult4=list.contains("u4");
109. assertEquals(true,result4);
111. }
113. @Test
114. publicvoidremove(){
115. //------------REMOVE-----------------
116. listOps.remove(key,4,"u4");
117. Stringvalue=listOps.index(key,4);
118. assertEquals(null,value);
120. }
121. }

回头继续整理，这个套路没错！