Redis实战之征服 Redis + Jedis + Spring （三）

一开始以为Spring下操作哈希表，列表，真就是那么土。恍惚间发现“stringRedisTemplate.opsForList()”的强大，抓紧时间恶补下。

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

 

相关链接：

Redis实战

Redis实战之Redis + Jedis

Redis实战之征服 Redis + Jedis + Spring （一）

Redis实战之征服 Redis + Jedis + Spring （二）

Redis实战之征服 Redis + Jedis + Spring （三）

 

为了简便操作，我使用了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. }  

/**
 * Mar 5, 2013
 */
package org.zlex.redis.support;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

/**
 * 
 * @author snowolf
 * @version 1.0
 * @since 1.0
 */
@Component("listOps")
public class ListOps {

@Autowired
private StringRedisTemplate stringRedisTemplate;

/**
 * 压栈
 * 
 * @param key
 * @param value
 * @return
 */
public Long push(String key, String value) {
return stringRedisTemplate.opsForList().leftPush(key, value);
}

/**
 * 出栈
 * 
 * @param key
 * @return
 */
public String pop(String key) {
return stringRedisTemplate.opsForList().leftPop(key);
}

/**
 * 入队
 * 
 * @param key
 * @param value
 * @return
 */
public Long in(String key, String value) {
return stringRedisTemplate.opsForList().rightPush(key, value);
}

/**
 * 出队
 * 
 * @param key
 * @return
 */
public String out(String key) {
return stringRedisTemplate.opsForList().leftPop(key);
}

/**
 * 栈/队列长
 * 
 * @param key
 * @return
 */
public Long length(String key) {
return stringRedisTemplate.opsForList().size(key);
}

/**
 * 范围检索
 * 
 * @param key
 * @param start
 * @param end
 * @return
 */
public List<String> range(String key, int start, int end) {
return stringRedisTemplate.opsForList().range(key, start, end);
}

/**
 * 移除
 * 
 * @param key
 * @param i
 * @param value
 */
public void remove(String key, long i, String value) {
stringRedisTemplate.opsForList().remove(key, i, value);
}

/**
 * 检索
 * 
 * @param key
 * @param index
 * @return
 */
public String index(String key, long index) {
return stringRedisTemplate.opsForList().index(key, index);
}

/**
 * 置值
 * 
 * @param key
 * @param index
 * @param value
 */
public void set(String key, long index, String value) {
stringRedisTemplate.opsForList().set(key, index, value);
}

/**
 * 裁剪
 * 
 * @param key
 * @param start
 * @param end
 */
public void trim(String key, long start, int end) {
stringRedisTemplate.opsForList().trim(key, start, end);
}
}

 

 

 

这里说明下，例如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. }  

/**
 * Mar 5, 2013
 */
package org.zlex.redis;

import static org.junit.Assert.*;

import java.util.List;

import org.junit.Before;
import org.junit.After;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.zlex.redis.support.ListOps;

/**
 * 
 * @author snowolf
 * @version 1.0
 * @since 1.0
 */
public class ListOpsTest {
private ApplicationContext app;
private ListOps listOps;
private String key = "queue";

@Before
public void before() throws Exception {
app = new ClassPathXmlApplicationContext("applicationContext.xml");
listOps = (ListOps) app.getBean("listOps");

System.out.println("------------IN---------------");
for (int i = 0; i < 5; i++) {
String uid = "u" + i;
System.out.println(uid);
listOps.in(key, uid);
}
}

@After
public void after() {
// ------------OUT---------------
System.out.println("------------OUT---------------");
long length = listOps.length(key);
for (long i = 0; i < length; i++) {
String uid = listOps.out(key);
System.out.println(uid);
}
}

@Test
public void stack() {
// ------------PUSH---------------
String key = "stack";
int len = 5;
System.out.println("------------PUSH---------------");
for (int i = 0; i < len; i++) {
String uid = "u" + System.currentTimeMillis();
System.out.println(uid);
listOps.push(key, uid);
}

long length = listOps.length(key);
assertEquals(len, length);

// ------------POP---------------
System.out.println("------------POP---------------");
for (long i = 0; i < length; i++) {
String uid = listOps.pop(key);
System.out.println(uid);
}
}

@Test
public void index() {

// -------------INDEX-------------
String value = listOps.index(key, 3);
assertEquals("u3", value);
}

@Test
public void range() {
// -------------RANGE-------------
List<String> list = listOps.range(key, 3, 5);
boolean result1 = list.contains("u3");
assertEquals(true, result1);

boolean result2 = list.contains("u1");
assertEquals(false, result2);
}

@Test
public void trim() {
// ------------TRIM---------------
List<String> list = listOps.range(key, 3, 5);
listOps.trim(key, 3, 5);
boolean result3 = list.contains("u1");
assertEquals(false, result3);
}

@Test
public void set() {
// ------------SET-----------------
List<String> list = listOps.range(key, 3, 5);
listOps.set(key, 4, "ux4");
boolean result4 = list.contains("u4");
assertEquals(true, result4);

}

@Test
public void remove() {
// ------------REMOVE-----------------
listOps.remove(key, 4, "u4");
String value = listOps.index(key, 4);
assertEquals(null, value);

}
}

 

 

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

相关链接：

Redis实战

Redis实战之Redis + Jedis

Redis实战之征服 Redis + Jedis + Spring （一）

Redis实战之征服 Redis + Jedis + Spring （二）

Redis实战之征服 Redis + Jedis + Spring （三）