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

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

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

springboot+redisTemplate实现消息队列(pub/sub,list,监听键过期)_第1张图片

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

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

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> pubSubMap = new HashMap();

    @Autowired
    private StringRedisTemplate redisTemplate;
//添加关系
    public Boolean addComsumer(String topic, String comsumer) {
        Set 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 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.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确认的队列。此时有这四个键

springboot+redisTemplate实现消息队列(pub/sub,list,监听键过期)_第2张图片

然后执行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)

结果:

springboot+redisTemplate实现消息队列(pub/sub,list,监听键过期)_第3张图片

重投三次之后,没有再投递了,此时还消息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集合进行消费

 

你可能感兴趣的:(redis)