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

曾经终败给现在 2021-06-10 20:42 374阅读 0赞

[http://snowolf.iteye.com/blog/1824868/][http_snowolf.iteye.com_blog_1824868]

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

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

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

Java代码   ![收藏代码][icon_star.png]

1.  /\*\* 
2.   \* Mar 5, 2013 
3.   \*/  
4.  **package** org.zlex.redis.support;  
5.    
6.  **import** java.util.List;  
7.    
8.  **import** org.springframework.beans.factory.annotation.Autowired;  
9.  **import** org.springframework.data.redis.core.StringRedisTemplate;  
10. **import** org.springframework.stereotype.Component;  
11.   
12. /\*\* 
13.  \*  
14.  \* @author snowolf 
15.  \* @version 1.0 
16.  \* @since 1.0 
17.  \*/  
18. @Component("listOps")  
19. **public** **class** ListOps \{  
20.   
21.     @Autowired  
22.     **private** StringRedisTemplate stringRedisTemplate;  
23.   
24.     /\*\* 
25.      \* 压栈 
26.      \*  
27.      \* @param key 
28.      \* @param value 
29.      \* @return 
30.      \*/  
31.     **public** Long push(String key, String value) \{  
32.         **return** stringRedisTemplate.opsForList().leftPush(key, value);  
33.     \}  
34.   
35.     /\*\* 
36.      \* 出栈 
37.      \*  
38.      \* @param key 
39.      \* @return 
40.      \*/  
41.     **public** String pop(String key) \{  
42.         **return** stringRedisTemplate.opsForList().leftPop(key);  
43.     \}  
44.   
45.     /\*\* 
46.      \* 入队 
47.      \*  
48.      \* @param key 
49.      \* @param value 
50.      \* @return 
51.      \*/  
52.     **public** Long in(String key, String value) \{  
53.         **return** stringRedisTemplate.opsForList().rightPush(key, value);  
54.     \}  
55.   
56.     /\*\* 
57.      \* 出队 
58.      \*  
59.      \* @param key 
60.      \* @return 
61.      \*/  
62.     **public** String out(String key) \{  
63.         **return** stringRedisTemplate.opsForList().leftPop(key);  
64.     \}  
65.   
66.     /\*\* 
67.      \* 栈/队列长 
68.      \*  
69.      \* @param key 
70.      \* @return 
71.      \*/  
72.     **public** Long length(String key) \{  
73.         **return** stringRedisTemplate.opsForList().size(key);  
74.     \}  
75.   
76.     /\*\* 
77.      \* 范围检索 
78.      \*  
79.      \* @param key 
80.      \* @param start 
81.      \* @param end 
82.      \* @return 
83.      \*/  
84.     **public** List<String> range(String key, **int** start, **int** end) \{  
85.         **return** stringRedisTemplate.opsForList().range(key, start, end);  
86.     \}  
87.   
88.     /\*\* 
89.      \* 移除 
90.      \*  
91.      \* @param key 
92.      \* @param i 
93.      \* @param value 
94.      \*/  
95.     **public** **void** remove(String key, **long** i, String value) \{  
96.         stringRedisTemplate.opsForList().remove(key, i, value);  
97.     \}  
98.   
99.     /\*\* 
100.      \* 检索 
101.      \*  
102.      \* @param key 
103.      \* @param index 
104.      \* @return 
105.      \*/  
106.     **public** String index(String key, **long** index) \{  
107.         **return** stringRedisTemplate.opsForList().index(key, index);  
108.     \}  
109.   
110.     /\*\* 
111.      \* 置值 
112.      \*  
113.      \* @param key 
114.      \* @param index 
115.      \* @param value 
116.      \*/  
117.     **public** **void** set(String key, **long** index, String value) \{  
118.         stringRedisTemplate.opsForList().set(key, index, value);  
119.     \}  
120.   
121.     /\*\* 
122.      \* 裁剪 
123.      \*  
124.      \* @param key 
125.      \* @param start 
126.      \* @param end 
127.      \*/  
128.     **public** **void** trim(String key, **long** start, **int** end) \{  
129.         stringRedisTemplate.opsForList().trim(key, start, end);  
130.     \}  
131. \}

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

举个具体的例子：

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

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

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

Java代码   ![收藏代码][icon_star.png]

1.  /\*\* 
2.   \* Mar 5, 2013 
3.   \*/  
4.  **package** org.zlex.redis;  
5.    
6.  **import** **static** org.junit.Assert.\*;  
7.    
8.  **import** java.util.List;  
9.    
10. **import** org.junit.Before;  
11. **import** org.junit.After;  
12. **import** org.junit.Test;  
13. **import** org.springframework.context.ApplicationContext;  
14. **import** org.springframework.context.support.ClassPathXmlApplicationContext;  
15. **import** org.zlex.redis.support.ListOps;  
16.   
17. /\*\* 
18.  \*  
19.  \* @author snowolf 
20.  \* @version 1.0 
21.  \* @since 1.0 
22.  \*/  
23. **public** **class** ListOpsTest \{  
24.     **private** ApplicationContext app;  
25.     **private** ListOps listOps;  
26.     **private** String key = "queue";  
27.   
28.     @Before  
29.     **public** **void** before() **throws** Exception \{  
30.         app = **new** ClassPathXmlApplicationContext("applicationContext.xml");  
31.         listOps = (ListOps) app.getBean("listOps");  
32.   
33.         System.out.println("------------IN---------------");  
34.         **for** (**int** i = 0; i < 5; i++) \{  
35.             String uid = "u" + i;  
36.             System.out.println(uid);  
37.             listOps.in(key, uid);  
38.         \}  
39.     \}  
40.   
41.     @After  
42.     **public** **void** after() \{  
43.         // ------------OUT---------------  
44.         System.out.println("------------OUT---------------");  
45.         **long** length = listOps.length(key);  
46.         **for** (**long** i = 0; i < length; i++) \{  
47.             String uid = listOps.out(key);  
48.             System.out.println(uid);  
49.         \}  
50.     \}  
51.   
52.     @Test  
53.     **public** **void** stack() \{  
54.         // ------------PUSH---------------  
55.         String key = "stack";  
56.         **int** len = 5;  
57.         System.out.println("------------PUSH---------------");  
58.         **for** (**int** i = 0; i < len; i++) \{  
59.             String uid = "u" + System.currentTimeMillis();  
60.             System.out.println(uid);  
61.             listOps.push(key, uid);  
62.         \}  
63.   
64.         **long** length = listOps.length(key);  
65.         assertEquals(len, length);  
66.   
67.         // ------------POP---------------  
68.         System.out.println("------------POP---------------");  
69.         **for** (**long** i = 0; i < length; i++) \{  
70.             String uid = listOps.pop(key);  
71.             System.out.println(uid);  
72.         \}  
73.     \}  
74.   
75.     @Test  
76.     **public** **void** index() \{  
77.   
78.         // -------------INDEX-------------  
79.         String value = listOps.index(key, 3);  
80.         assertEquals("u3", value);  
81.     \}  
82.   
83.     @Test  
84.     **public** **void** range() \{  
85.         // -------------RANGE-------------  
86.         List<String> list = listOps.range(key, 3, 5);  
87.         **boolean** result1 = list.contains("u3");  
88.         assertEquals(**true**, result1);  
89.   
90.         **boolean** result2 = list.contains("u1");  
91.         assertEquals(**false**, result2);  
92.     \}  
93.   
94.     @Test  
95.     **public** **void** trim() \{  
96.         // ------------TRIM---------------  
97.         List<String> list = listOps.range(key, 3, 5);  
98.         listOps.trim(key, 3, 5);  
99.         **boolean** result3 = list.contains("u1");  
100.         assertEquals(**false**, result3);  
101.     \}  
102.   
103.     @Test  
104.     **public** **void** set() \{  
105.         // ------------SET-----------------  
106.         List<String> list = listOps.range(key, 3, 5);  
107.         listOps.set(key, 4, "ux4");  
108.         **boolean** result4 = list.contains("u4");  
109.         assertEquals(**true**, result4);  
110.   
111.     \}  
112.   
113.     @Test  
114.     **public** **void** remove() \{  
115.         // ------------REMOVE-----------------  
116.         listOps.remove(key, 4, "u4");  
117.         String value = listOps.index(key, 4);  
118.         assertEquals(**null**, value);  
119.   
120.     \}  
121. \}

[http_snowolf.iteye.com_blog_1824868]: http://snowolf.iteye.com/blog/1824868/
[smiley-frown.gif]: /images/20210527/cd7fa57463754369980de3a495b9238e.png
[icon_star.png]: /images/20210527/8f0d29b321334978a365b6545e1fa4dd.png