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

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。

闲言少叙，上代码，一目了然：
1. /**
2. * Mar 5, 2013
3. */
4. package org.zlex.redis.support;
6. import java.util.List;
8. import org.springframework.beans.factory.annotation.Autowired;
9. import org.springframework.data.redis.core.StringRedisTemplate;
10. import org.springframework.stereotype.Component;
12. /**
13. *
14. * @author snowolf
15. * @version 1.0
16. * @since 1.0
17. */
18. @Component("listOps")
19. public class ListOps {
21. @Autowired
22. private StringRedisTemplate stringRedisTemplate;
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. }
35. /**
36. * 出栈
37. *
38. * @param key
39. * @return
40. */
41. public String pop(String key) {
42. return stringRedisTemplate.opsForList().leftPop(key);
43. }
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. }
56. /**
57. * 出队
58. *
59. * @param key
60. * @return
61. */
62. public String out(String key) {
63. return stringRedisTemplate.opsForList().leftPop(key);
64. }
66. /**
67. * 栈/队列长
68. *
69. * @param key
70. * @return
71. */
72. public Long length(String key) {
73. return stringRedisTemplate.opsForList().size(key);
74. }
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. }
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. }
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. }
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. }
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替换。

下面进行测试用例，初始、结束时，分别做入队、出队操作，期间进行堆栈，队列操作。不用我细说了，看测试用例，很简单！
1. /**
2. * Mar 5, 2013
3. */
4. package org.zlex.redis;
6. import static org.junit.Assert.*;
8. import java.util.List;
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;
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";
28. @Before
29. public void before() throws Exception {
30. app = new ClassPathXmlApplicationContext("applicationContext.xml");
31. listOps = (ListOps) app.getBean("listOps");
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. }
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. }
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. }
64. long length = listOps.length(key);
65. assertEquals(len, length);
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. }
75. @Test
76. public void index() {
78. // -------------INDEX-------------
79. String value = listOps.index(key, 3);
80. assertEquals("u3", value);
81. }
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);
90. boolean result2 = list.contains("u1");
91. assertEquals(false, result2);
92. }
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. }
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);
111. }
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);
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 （三）
相关阅读:
人性的经典总结54句
 系统程序员成长计划文本处理(XML解析器)
系统程序员成长计划－像机器一样思考(二)
Android输入事件流程
 系统程序员成长计划文本处理(INI解析器)
request范围内共享属性 request_attribute.jsp
系统程序员成长计划－像机器一样思考(三)
系统程序员成长计划－像机器一样思考(一)
Android IPC机制详解
 系统程序员成长计划文本处理(一)状态机(1)
原文地址：https://www.cnblogs.com/sand-tiny/p/3894930.html