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

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

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

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

 

Java代码  

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代码  

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. }  

 

如果想深入体验LINUX系统的新手，也可以先下载一个方德Linux软件中心试用一下。
免费下载地址：http://www.nfs-cloud.cn:81/appCenter/open/softcente