Spring-data-redis: 分布式队列

Redis中list数据结构，具有“双端队列”的特性，同时redis具有持久数据的能力，因此redis实现分布式队列是非常安全可靠的。它类似于JMS中的“Queue”，只不过功能和可靠性(事务性)并没有JMS严格。

Redis中的队列阻塞时，整个connection都无法继续进行其他操作，因此在基于连接池设计是需要注意。

我们通过spring-data-redis，来实现“同步队列”，设计风格类似与JMS。

一.配置文件：

[java] view
plain copy

1. <beans xmlns="http://www.springframework.org/schema/beans"
2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd" default-autowire="byName">
4. <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
5. <property name="maxActive" value="32"></property>
6. <property name="maxIdle" value="6"></property>
7. <property name="maxWait" value="15000"></property>
8. <property name="minEvictableIdleTimeMillis" value="300000"></property>
9. <property name="numTestsPerEvictionRun" value="3"></property>
10. <property name="timeBetweenEvictionRunsMillis" value="60000"></property>
11. <property name="whenExhaustedAction" value="1"></property>
12. </bean>
13. <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy">
14. <property name="poolConfig" ref="jedisPoolConfig"></property>
15. <property name="hostName" value="127.0.0.1"></property>
16. <property name="port" value="6379"></property>
17. <property name="password" value="0123456"></property>
18. <property name="timeout" value="15000"></property>
19. <property name="usePool" value="true"></property>
20. </bean>
21. <bean id="jedisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
22. <property name="connectionFactory" ref="jedisConnectionFactory"></property>
23. <property name="defaultSerializer">
24. <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
25. </property>
26. </bean>
27. <bean id="jedisQueueListener" class="com.sample.redis.sdr.QueueListener"/>
28. <bean id="jedisQueue" class="com.sample.redis.sdr.RedisQueue" destroy-method="destroy">
29. <property name="redisTemplate" ref="jedisTemplate"></property>
30. <property name="key" value="user:queue"></property>
31. <property name="listener" ref="jedisQueueListener"></property>
32. </bean>
33. </beans>

二.程序实例：

1) QueueListener：当队列中有数据时，可以执行类似于JMS的回调操作。

[java] view
plain copy

1. public interface RedisQueueListener<T> {
2. public void onMessage(T value);
3. }

[java] view
plain copy

1. public class QueueListener<String> implements RedisQueueListener<String> {
2. @Override
3. public void onMessage(String value) {
4. System.out.println(value);
5. }
6. }

2) RedisQueue:队列操作，内部封装redisTemplate实例；如果配置了“listener”，那么queue将采用“消息回调”的方式执行，listenerThread是一个后台线程，用来自动处理“队列信息”。如果不配置“listener”，那么你可以将redisQueue注入到其他spring bean中，手动去“take”数据即可。

[java] view
plain copy

1. public class RedisQueue<T> implements InitializingBean,DisposableBean{
2. private RedisTemplate redisTemplate;
3. private String key;
4. private int cap = Short.MAX_VALUE;//最大阻塞的容量，超过容量将会导致清空旧数据
5. private byte[] rawKey;
6. private RedisConnectionFactory factory;
7. private RedisConnection connection;//for blocking
8. private BoundListOperations<String, T> listOperations;//noblocking
9. private Lock lock = new ReentrantLock();//基于底层IO阻塞考虑
10. private RedisQueueListener listener;//异步回调
11. private Thread listenerThread;
12. private boolean isClosed;
13. public void setRedisTemplate(RedisTemplate redisTemplate) {
14. this.redisTemplate = redisTemplate;
15. }
16. public void setListener(RedisQueueListener listener) {
17. this.listener = listener;
18. }
19. public void setKey(String key) {
20. this.key = key;
21. }
22. @Override
23. public void afterPropertiesSet() throws Exception {
24. factory = redisTemplate.getConnectionFactory();
25. connection = RedisConnectionUtils.getConnection(factory);
26. rawKey = redisTemplate.getKeySerializer().serialize(key);
27. listOperations = redisTemplate.boundListOps(key);
28. if(listener != null){
29. listenerThread = new ListenerThread();
30. listenerThread.setDaemon(true);
31. listenerThread.start();
32. }
33. }
34. /**
35. * blocking
36. * remove and get last item from queue:BRPOP
37. * @return
38. */
39. public T takeFromTail(int timeout) throws InterruptedException{
40. lock.lockInterruptibly();
41. try{
42. List<byte[]> results = connection.bRPop(timeout, rawKey);
43. if(CollectionUtils.isEmpty(results)){
44. return null;
45. }
46. return (T)redisTemplate.getValueSerializer().deserialize(results.get(1));
47. }finally{
48. lock.unlock();
49. }
50. }
51. public T takeFromTail() throws InterruptedException{
52. return takeFromHead(0);
53. }
54. /**
55. * 从队列的头，插入
56. */
57. public void pushFromHead(T value){
58. listOperations.leftPush(value);
59. }
60. public void pushFromTail(T value){
61. listOperations.rightPush(value);
62. }
63. /**
64. * noblocking
65. * @return null if no item in queue
66. */
67. public T removeFromHead(){
68. return listOperations.leftPop();
69. }
70. public T removeFromTail(){
71. return listOperations.rightPop();
72. }
73. /**
74. * blocking
75. * remove and get first item from queue:BLPOP
76. * @return
77. */
78. public T takeFromHead(int timeout) throws InterruptedException{
79. lock.lockInterruptibly();
80. try{
81. List<byte[]> results = connection.bLPop(timeout, rawKey);
82. if(CollectionUtils.isEmpty(results)){
83. return null;
84. }
85. return (T)redisTemplate.getValueSerializer().deserialize(results.get(1));
86. }finally{
87. lock.unlock();
88. }
89. }
90. public T takeFromHead() throws InterruptedException{
91. return takeFromHead(0);
92. }
93. @Override
94. public void destroy() throws Exception {
95. if(isClosed){
96. return;
97. }
98. shutdown();
99. RedisConnectionUtils.releaseConnection(connection, factory);
100. }
101. private void shutdown(){
102. try{
103. listenerThread.interrupt();
104. }catch(Exception e){
105. //
106. }
107. }
108. class ListenerThread extends Thread {
109. @Override
110. public void run(){
111. try{
112. while(true){
113. T value = takeFromHead();//cast exceptionyou should check.
114. //逐个执行
115. if(value != null){
116. try{
117. listener.onMessage(value);
118. }catch(Exception e){
119. //
120. }
121. }
122. }
123. }catch(InterruptedException e){
124. //
125. }
126. }
127. }
128. }

3) 使用与测试：

[java] view
plain copy

1. public static void main(String[] args) throws Exception{
2. ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring-redis-beans.xml");
3. RedisQueue<String> redisQueue = (RedisQueue)context.getBean("jedisQueue");
4. redisQueue.pushFromHead("test:app");
5. Thread.sleep(15000);
6. redisQueue.pushFromHead("test:app");
7. Thread.sleep(15000);
8. redisQueue.destroy();
9. }

在程序运行期间，你可以通过redis-cli(客户端窗口)执行“lpush”，你会发现程序的控制台仍然能够正常打印队列信息。