springboot+redisTemplate实现消息队列(pub/sub,list,监听键过期)

redis实现方式主流的有两种，一种是lpush rpop，一种是pub/sub机制，下面来做个演示的例子

大概的分为两个角色，生产者和消费者，然后大概结构是这样的：

主要的角色就是维护主题和消费者关系的一个表，生产者、消费者、监听键过期机制，还有定时任务，这次写出来的例子只是支持滞后消费的重投，超前消费的情况没有得到很好解决。

首先是生产者，生产者主要是根据主题发布消息

package com.gdut.redisdemo.producer;

import com.gdut.redisdemo.VO.MessageVO;
import com.gdut.redisdemo.config.PubSubTable;
import com.google.gson.Gson;
import io.netty.util.CharsetUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

/**
 * @author lulu
 * @Date 2019/6/22 16:47
 */
@Component
public class Producer {

    @Autowired
    private Gson gson;
    @Autowired
    private StringRedisTemplate redisTemplate;
    @Autowired
    private PubSubTable pubSubTable;



    public void sendMessage(String topic, MessageVO messageVO) {
        //这里给订阅该主题的链接的每个队列进行广播该消息
        pubSubTable.boradCast(topic, messageVO.getMessageId());
        redisTemplate.getConnectionFactory().getConnection().publish(topic.getBytes(CharsetUtil.UTF_8), gson.toJson(messageVO).getBytes());
    }
}

而维护他们关系的表,这个主要是用来发布list和监听键

package com.gdut.redisdemo.config;

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

import java.util.*;

/**
 * @author lulu
 * @Date 2019/6/22 17:39
 */

public class PubSubTable {
    //Map的key为主题，Set里面的元素为队列里面的消费者的队列key，该队列用来检测消息是否被正确接受
    private Map<String, Set<String>> pubSubMap = new HashMap();

    @Autowired
    private StringRedisTemplate redisTemplate;
//添加关系
    public Boolean addComsumer(String topic, String comsumer) {
        Set<String> comsumerList = pubSubMap.get(topic);

        if (comsumerList == null) {
            comsumerList = new HashSet<>();
        }
        Boolean b = comsumerList.add(comsumer);
        pubSubMap.put(topic, comsumerList);
        return b;
    }
//删除关系
    public Boolean removeComsumer(String topic, String comsumer) {
        Set<String> comsumerList = pubSubMap.get(topic);
        Boolean b =false;
        if(comsumerList!=null){
           b= comsumerList.remove(comsumer);
            pubSubMap.put(topic, comsumerList);
        }
        return b;
    }


    //广播消息
    public void boradCast(String topic, String messageId) {
        if(pubSubMap.get(topic)!=null){
            for (String comsumer : pubSubMap.get(topic)) {
                //这里不再次进行入队和设监听键的原因是已经有了（对应滞后消费的情况）
                if(!redisTemplate.hasKey("fail_"+topic+"_"+comsumer+"_"+messageId)){
                    //设置监听键
                    redisTemplate.opsForValue().set(topic+"_"+comsumer + "_" + messageId, messageId);
                    //为该队列传入消息id，为后面校验使用
                    redisTemplate.opsForList().leftPush(topic+"_"+comsumer, topic + "_" + messageId);
                }
            }
        }

    }

}

消费者，这里的订阅要对监听容器操作，该容器（RedisMessageListenerContainer）有订阅频道和取消订阅的方法，一开始没找到。。

package com.gdut.redisdemo.comsumer;

import com.gdut.redisdemo.VO.MessageVO;
import com.gdut.redisdemo.VO.UserVO;
import com.gdut.redisdemo.config.PubSubTable;
import com.google.gson.Gson;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.connection.MessageListener;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * @author lulu
 * @Date 2019/6/22 16:54
 */
@Component
public class Comsumer1 implements MessageListener {
    @Autowired
    private Gson gson;

    @Autowired
    private PubSubTable pubSubTable;
    @Autowired
    private StringRedisTemplate redisTemplate;

    public void addChannel(String topic) {

        pubSubTable.addComsumer(topic, this.getClass().getSimpleName());
        System.out.printf("%s 订阅一个主题%s%n", this.getClass().getSimpleName(), topic);

    }


    @Override
    public void onMessage(Message message, @Nullable byte[] pattern) {
        String name = this.getClass().getSimpleName();
        String topic = new String(message.getChannel());
        String content = new String(message.getBody());
        MessageVO messageVO = gson.fromJson(content, MessageVO.class);
        //如果这个取出来的不是正确的id，丢弃并记录。
        String b = redisTemplate.<String>opsForList().rightPop(topic + "_" + name);
        if (b != null && b.equals(topic + "_" + messageVO.getMessageId())) {
            UserVO userVO = gson.fromJson(messageVO.getContent(), UserVO.class);
            System.out.printf("%s从主题%s收到消息:%s%n", name, topic, content);//业务处理
            System.out.printf("消息内容:%s%n", userVO.toString());
            redisTemplate.expire(topic + "_" + name + "_" + messageVO.getMessageId(), 1, TimeUnit.NANOSECONDS);
        } else {
            //把他设为fail,准备重新处理
            redisTemplate.opsForValue().set("fail_" + topic + "_" + name + "_" + messageVO.getMessageId(), content);
        }
    }
}

监听器：使用这个的前提是配置文件要开启事件监听：notify-keyspace-events Ex

package com.gdut.redisdemo.comsumer;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.connection.MessageListener;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.listener.KeyExpirationEventMessageListener;
import org.springframework.data.redis.listener.KeyspaceEventMessageListener;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.stereotype.Component;

/**
 * @author lulu
 * @Date 2019/6/22 18:40
 */
public class CheckKeyExpire extends KeyspaceEventMessageListener {
    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * Creates new {@link MessageListener} for {@code __keyevent@*__:expired} messages.
     *
     * @param listenerContainer must not be {@literal null}.
     */
    public CheckKeyExpire(RedisMessageListenerContainer listenerContainer) {
        super(listenerContainer);
    }

    @Override
    protected void doHandleMessage(Message message) {
        String channel = new String(message.getChannel());
        if (channel.equals("__keyevent@0__:expired")) {

            String body = new String(message.getBody());
            System.out.println("消息id为：" + body + "成功处理");
            redisTemplate.delete("fail_" + new String(message.getChannel())+"_"+ body);
            //如果这里有状态改变为接受成功的消息之类的，可以在这里操作数据库
        }
    }
}

大概的几个核心部分就是这样，然后配置方面，因为不同的消费者不能公用同一个client所以把获取连接的bean设为多例的。

这里一开始做的时候遇到好多坑，后来发现template构造函数有个factory了，然后试着注入到配置类里面，果然可以，解决了一开始的bug

package com.gdut.redisdemo.config;

import com.gdut.redisdemo.comsumer.CheckKeyExpire;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author lulu
 * @Date 2019/6/22 17:31
 */
@Configuration
public class RedisConfig {
@Autowired
RedisConnectionFactory redisConnectionFactory;

    @Bean
    @Scope(BeanDefinition.SCOPE_PROTOTYPE)
    public RedisConnection redisConnection() {
        return redisConnectionFactory.getConnection();
    }

    @Bean
    public RedisMessageListenerContainer container() {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(redisConnectionFactory);
        return container;
    }

    @Bean
    public PubSubTable pubSubTable() {
        return new PubSubTable();
    }

    @Bean
    public CheckKeyExpire checkKeyExpire(
    ) {
        return new CheckKeyExpire(container());
    }

}

下面看一下正常的演示，此时消费者1和消费者2均订阅了user这个主题，如果匹配模式的话要用监听容器的PatternTopic这个类。

然后进行广播：

遍历关系表，设置监听键和消息id确认的队列。此时有这四个键

然后执行onMessage的方法操作数据

结果如下

由于消息被消费完了，会把监听键设置过期，然后执行监听过期的方法，这里是对0数据库的过期事件才进行操作，打印出消息，并删除相关键如果有的话

 protected void doHandleMessage(Message message) {
        String channel = new String(message.getChannel());
        if (channel.equals("__keyevent@0__:expired")) {
            String body = new String(message.getBody());
            System.out.println("消息id为：" + body + "成功处理");
            redisTemplate.delete("fail_" + new String(message.getChannel())+"_"+ body);
            //如果这里有状态改变为接受成功的消息之类的，可以在这里操作数据库
        }
    }

此时redis的数据为空

那么看一下消息滞后的情况，就是队列里面多了几个奇怪的元素，然后里面的消息没有被及时消费，下面模拟一下这个情况：

这里我预先创好存放i消息d的队列，该队列主要是用来查看当前消息是否和收到的内容是一致的，如果不一致，则认为该消息发送失败了，这里先放四个元素。

然后向消费者1发送消息：

这个注解的意思是每15秒执行一次，延迟20s执行

@Scheduled(initialDelay = 20000,fixedRate = 15000)

结果：

重投三次之后，没有再投递了，此时还消息id队列还有这个值，会被下次消息获取时去掉

然后看取消订阅的例子：

订阅主题：

http://localhost:8080/subTopic/1?topic=test

发送消息：

http://localhost:8080/sendMessage/test?name=lele&age=21

业务处理：

消息确认：

通过队列的消息校验和经过业务处理后，会使监听键过期，否则设为失败的消息投递，进行重投

取消订阅：这里面不仅仅要把hashMap里的关系去掉，还要移出监听容器

http://localhost:8080/unSubTopic/1?topic=test

再次发消息，没有结果。可见取消订阅成功了

其实这个例子一开始写的不是很好，第一天做的过程也有很多坑，好像那个配置那些都是迷迷糊糊弄出来的，后来发现也不对，整个设计的也有待完善，但是就当对spring-data-redis一个实操吧，就瞎鼓捣，一些尝试啥的，感觉用起来很多坑，为什么这么说呢，因为用一开始的版本的话，从配置还有监听容器上面和取消订阅有挺多问题的，当时没有仔细考虑这个东西，然后就出现了消费者两个以上出现read timeout的情况，我怀疑是哪里锁住了，第二天把他放到监听容器上就没有了，还可以取消订阅，其实这里对于消息投递失败的处理也不是很正宗，都是收到消息才丢弃的消息，从某种意义看消息投递其实是成功了的，我github的other分支里面就用了一个监听成功、一个监听失败的键（默认5s，即5s消息没有成功就进行重投）的做法，写得不是那么好和完善，就当随便看看吧，这个例子就只是拿来熟悉下redisTemplate，听说还有5.0以上stream也可以实现消息队列，到时候看看。完整代码已放上github。

如何实现简单的延时队列？这里要用到sorted set结构，拿时间戳作为score,消息id作为key,至于消息的内容可以存放在redis或者其他数据库上，计算n秒前的时间戳，再用zrangebyscore获取当前时间戳-ns前的时间戳的消息id集合进行消费