【Wechat】用redis实现的延迟消息队列完成小程序订阅消息

需求

• 预约，用户订阅消息，到点之后再调用微信的订阅消息接口发送消息
• 抽奖的奖励发放，发放失败后过一段时间重试

Controller

@RestController
@RequestMapping("${wxPath}/subscribe")
public class IdvSubscribeController {
    @Autowired
    private IdvSubscribeService service;

    /**
     * 小程序订阅消息
     * @param vo
     * @param request
     * @return
     */
    @PostMapping("/send")
    public Object send(@RequestBody TemplateVO vo, HttpServletRequest request) {
        service.send(vo,request);
        return BackMessage.ok();
    }
}

TemplateVO

@Data
public class TemplateVO {
    
    /**
     * 接收者（用户）的 openid
     */
    private String touser;
    /**
     * 跳转小程序类型：developer为开发版；trial为体验版；formal为正式版；默认为正式版
     */
    private String miniprogram_state;
    /**
     * 所需下发的订阅模板id
     */
    private String template_id;
    /**
     * 发送时间（时间戳）
     */
    private Long sendTime;
    /**
     * 延迟的时间（ms）
     */
    private Long delayedTime;
    /**
     * 点击模板卡片后的跳转页面，仅限本小程序内的页面。支持带参数,（示例index?foo=bar）。该字段不填则模板无跳转。
     */
    private String page;
    /**
     * 发送的数据
     */
    private Map<String,Object> data;

}

Service

@Autowired
private RedisDelayedQueueManager manager;

public void send(TemplateVO vo, HttpServletRequest request) {
    IdvUser wxUser = wxUserUtil.getWXUser(request.getHeader("wxToken"));
    if (wxUser == null) {
        throw new CustomException("未登录");
    }
    //通过token解析用户信息，获取openId
    vo.setTouser(wxUser.getOpenId());
    //计算多久之后发送
    long delayedTime = 0L;
    if(vo.getSendTime() != null && vo.getSendTime()>System.currentTimeMillis()){
        delayedTime = vo.getSendTime()-System.currentTimeMillis();
    }
    //保存消息内容
    DelayedMessage delayedMessage = new DelayedMessage(IDV_DESCRIBE,"TimingDeliveryApply", delayedTime, JSON.toJSONString(vo));
    //消息延时发送
    manager.putMessage(delayedMessage,true);
}

TimingDeliveryApply

到点处理发送消息的逻辑

import com.epro.idv.service.idvSubscribe.delayedQueue.DelayMessageHandler;
import com.epro.idv.service.idvSubscribe.delayedQueue.DelayedMessage;
import com.epro.idv.service.idvSubscribe.delayedQueue.RedisDelayedQueueManager;
import com.epro.idv.service.idvUser.IdvUserService;
import com.epro.utils.WXUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


@Component("TimingDeliveryApply")
@Slf4j
public class TimingDeliveryApply implements DelayMessageHandler<String> {
    
    @Autowired
    private IdvUserService idvUserService;
    @Autowired
    private RedisDelayedQueueManager manager;


    @Override
    public void handlerMessage(DelayedMessage<String> delayedMessage) {

        //未达到时间继续存放
        log.info("接受到的参数为{}",delayedMessage);
        if(System.currentTimeMillis()<delayedMessage.getStartTime()){
           manager.continuePutMessage(delayedMessage);
           return;
        }
        //发送消息
        try{
            String templateVO = delayedMessage.getData();
            String accessToken = idvUserService.getWxAccessToken();
            WXUtils.sendSubscribe(accessToken, templateVO);
        }catch (Exception e){
            log.error("发送消息异常：{}",e);
            delayedMessage.setDelayedTime(5*60*1000L);
            manager.continuePutMessage(delayedMessage);
        }
    }
}

DelayedMessage

import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 通用的延迟队列信息
 */
@Data
@NoArgsConstructor
public class DelayedMessage<T> {
    private String messageId;
    //消息队列key
    private String queueKey;

    //消息处理类名，通过这个来找类实例的
    //private Class<H> handlerClass;
    //消息处理方法名，通过这个来找方法实例的
    private String handlerClassName;

    //消息发送时间
    private Long startTime;
    private Long delayedTime;
    private Long deadLine;

    private Class<T> dataClass;
    private T data;

    public DelayedMessage(String queueKey, String handlerClassName, Long delayedTime, T data) {
        this.queueKey = queueKey;
        this.handlerClassName = handlerClassName;
        this.delayedTime = delayedTime;
        this.data = data;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

DelayMessageHandler

public interface DelayMessageHandler<T> {
    void handlerMessage(DelayedMessage<T> delayedMessage);
}

RedisDelayedQueueManager

网上的redis的延迟队列实现是通过每个redisKey开启一个线程来做监听，这样的话，如果rediskey比较多的话，线程可能受不了

我们可以沿用同一个rediskey，然后只不过注册了不同的处理事件而已

import org.springframework.beans.BeansException;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;
import java.util.function.Consumer;


@Component
public class RedisDelayedQueueManager implements ApplicationContextAware, CommandLineRunner {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    private static final String DELAYED_PREFIX="delayed::";

    private ApplicationContext applicationContext;

    public void show (){
        System.out.println(applicationContext.getClass());
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }


    private Map<String,RedisDelayedQueueT> redisDelayedQueueTMap =new HashMap<>();


    public synchronized <T>  boolean putMessage(DelayedMessage<T> delayedMessage,boolean isNew){
        if(isNew) {
            long current = System.currentTimeMillis();
            delayedMessage.setStartTime(current);
        }
        String queueKey = delayedMessage.getQueueKey();
        String realQueueKey =DELAYED_PREFIX+queueKey;
        if(queueKey==null || "".equals(queueKey)){
            throw new IllegalStateException("请设置queueKey!");
        }
        RedisDelayedQueueT queue = redisDelayedQueueTMap.get(realQueueKey);
        if(queue==null){
            Consumer handler =null;
            try{
                DelayMessageHandler handlerObj = applicationContext.getBean( delayedMessage.getHandlerClassName(),DelayMessageHandler.class);
                Method method = DelayMessageHandler.class.getMethod("handlerMessage",DelayedMessage.class);
                handler = toConsumer(handlerObj, method);
            }catch (Exception e){
                throw new RuntimeException(e);
            }
            queue= new RedisDelayedQueueT(realQueueKey,DelayedMessage.class,applicationContext);
            queue.setStringRedisTemplate(stringRedisTemplate);
            redisDelayedQueueTMap.put(realQueueKey,queue);
        }

        Long deadLine = delayedMessage.getDeadLine();
        Long delayedTime = delayedMessage.getDelayedTime();
        boolean success=false;
        if(deadLine==null){
            if(delayedTime==null){
                throw new IllegalStateException("至少设置一个日期!");
            }
            success= queue.putForDelayedTime(delayedMessage,delayedTime);
        }else{
            success=  queue.putForDeadLine(delayedMessage,deadLine);
        }
        return success;
    }

    public synchronized <T>  boolean putMessage(DelayedMessage<T> delayedMessage){
        return putMessage(delayedMessage,true);
    }
    public synchronized <T>  boolean continuePutMessage(DelayedMessage<T> delayedMessage){
        return putMessage(delayedMessage,false);
    }


    public static <T> Consumer<T> toConsumer(Object annotated, Method m) {
        return T -> {
            try {
                m.invoke(annotated, T);
            } catch (IllegalAccessException | InvocationTargetException e) {
                throw new RuntimeException(e);
            }
        };
    }


    @Override
    public void run(String... args) throws Exception {
        Set<String> keys =stringRedisTemplate.execute((RedisCallback<Set<String>>) connection->{
            Set<String> keysTemp=new HashSet<>();
            Cursor<byte[]> cursor =connection.scan(new ScanOptions.ScanOptionsBuilder().match(DELAYED_PREFIX+"*").count(100).build());
            while(cursor.hasNext()){
                keysTemp.add(new String(cursor.next()));
            }
            return keysTemp;
        });
        if (keys!=null){
            System.out.println(("初始化延迟队列"+Arrays.toString(keys.toArray())));
            for(String key : keys){
                RedisDelayedQueueT queue= new RedisDelayedQueueT(key,DelayedMessage.class,applicationContext);
                queue.setStringRedisTemplate(stringRedisTemplate);
                redisDelayedQueueTMap.put(key,queue);
            }
        }
    }
}

RedisDelayedQueueT

用ZSet实现延时消息队列

集群模式下的消息也不会被重复消费

package com.epro.idv.service.idvSubscribe.delayedQueue;


import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationContext;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;

import java.lang.reflect.Method;
import java.util.Set;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;

/**
 * @author nick
 */
@Slf4j
public class RedisDelayedQueueT {

    private static final AtomicInteger COUNTER = new AtomicInteger(1);

    private volatile boolean started = false;

    private String queueKey;


    private Class<DelayedMessage> classOfT;

    private StringRedisTemplate stringRedisTemplate;

    private ApplicationContext applicationContext;

    /**
     * @param queueKey 队列键值
     * @param classOfT 元素的类型
     */
    public RedisDelayedQueueT(String queueKey, Class<DelayedMessage> classOfT, ApplicationContext applicationContext) {
        this.queueKey = queueKey;
        this.classOfT = classOfT;
        this.applicationContext=applicationContext;
    }

    /**
     * 往该延时队列中放入数据,达到指定时间时处理
     *
     * @param value    数据
     * @param deadLine 截止时间戳，单位是毫秒
     * @return 是否执行成功
     */
    public boolean putForDeadLine(DelayedMessage value, long deadLine) {
        if (value == null) {
            return false;
        }
        long current = System.currentTimeMillis();

        if (deadLine < current) {
            throw new IllegalArgumentException(String.format("deadline: %d 小于当前时间: %d !", deadLine, current));
        }
        if (stringRedisTemplate == null) {
            throw new IllegalStateException("请设置stringRedisTemplate!");
        }
        String json = null;
        try {
            json = new ObjectMapper().writeValueAsString(value);
        } catch (JsonProcessingException e) {
            throw new IllegalStateException("序列化失败!");
        }
        Boolean flag = stringRedisTemplate.opsForZSet().add(queueKey, json, deadLine);
        return Boolean.TRUE.equals(flag);
    }

    /**
     * 往该延时队列中放入数据,指定时间后执行
     *
     * @param value       数据
     * @param delayedTime 需要延长的时间，单位是毫秒
     * @return 是否执行成功
     */
    public boolean putForDelayedTime(DelayedMessage value, long delayedTime) {
        return putForDeadLine(value, System.currentTimeMillis() + delayedTime);
    }

    /**
     * 清除队列中的数据
     */
    public void clear() {
        stringRedisTemplate.opsForZSet().removeRangeByScore(queueKey, Double.MIN_VALUE, Double.MAX_VALUE);
    }

    /**
     * 验证队列是否存在 true 存在  false 不存在
     */
    public Boolean verify() {
        Long value = stringRedisTemplate.opsForZSet().zCard(queueKey);
        return value != null ? value > 0 : false;
    }


    public void setStringRedisTemplate(StringRedisTemplate stringRedisTemplate) {
        if (this.stringRedisTemplate == null && !started) {
            this.stringRedisTemplate = stringRedisTemplate;
            Worker worker = new Worker();
            worker.setName("delayed-queue-task-" + queueKey + "-" + COUNTER.getAndIncrement());
            worker.start();
            started = true;
        }
    }

    class Worker extends Thread {

        @SneakyThrows
        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {
                long current = System.currentTimeMillis();
                Set<ZSetOperations.TypedTuple<String>> typedTuples = stringRedisTemplate.opsForZSet()
                        .rangeByScoreWithScores(queueKey, 0, current, 0, 1);
                if (typedTuples!=null && typedTuples.size()>0) {
                    ZSetOperations.TypedTuple<String> next = typedTuples.iterator().next();
                    if (next.getScore() != null && next.getScore() < current) {
                        Long removedCount = stringRedisTemplate.opsForZSet().remove(queueKey, next.getValue());
                        // 只有一个线程可以删除成功，代表拿到了这个需要处理的数据
                        if (removedCount != null && removedCount > 0) {
                           invokeHandler(new ObjectMapper().readValue(next.getValue(),DelayedMessage.class));
                        }
                    }
                }
                try {
                    TimeUnit.MILLISECONDS.sleep(1000L + ThreadLocalRandom.current().nextInt(10));//NOSONAR
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            started = false;
        }
    }


    private void invokeHandler(DelayedMessage message){
        Consumer handler =null;
        try{
            DelayMessageHandler handlerObj = applicationContext.getBean( message.getHandlerClassName(),DelayMessageHandler.class);
            Method method = DelayMessageHandler.class.getMethod("handlerMessage", DelayedMessage.class);
            method.invoke(handlerObj, message);
        }catch (Exception e){
            log.error("调用方法失败{}",e);
        }
    }
}

WxUtils

• 获取微信Token
• 获取用户的openId
• 给指定用户发送订阅消息

import com.epro.utils.redis.RedisUtil;
import com.epro.wx.utils.HttpUtil;
import com.jeesite.common.utils.ResultEnm;
import com.jeesite.common.utils.StringUtils;
import lombok.extern.slf4j.Slf4j;
import net.sf.json.JSONObject;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class WXUtils {

    public final static String GET_PAGE_ACCESS_TOKEN_URL = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=SECRET";
    public final static String SUBSCRIBR_SEND_URL = "https://api.weixin.qq.com/cgi-bin/message/subscribe/send?access_token=ACCESS_TOKEN";
    public final static String GET_OPENID_URL = "https://api.weixin.qq.com/sns/jscode2session?appid=APPID&secret=SECRET&grant_type=authorization_code&js_code=CODE";

    private static String WX_TOKEN = "WX:token:";
    /**
     * 小程序ID
     */
    private static String appId;
    /**
     * 小程序secret
     */
    private static String appSecret;

    @Value("${wx.appid}")
    private void setAppId(String appId) {
        WXUtils.appId = appId;
    }

    @Value("${wx.appsecret}")
    private void setSecret(String secret) {
        WXUtils.appSecret = secret;
    }


    /**
     * 获取openId
     * @param code
     * @return
     */
    public static JSONObject getSessionKeyOrOpenId(String code) {
        String requestUrl = GET_OPENID_URL.replace("APPID", appId).replace("SECRET", appSecret).replace("CODE",code);
        JSONObject jsonObject = null;
        try{
            // 发送post请求读取调用微信 https://api.weixin.qq.com/sns/jscode2session 接口获取openid用户唯一标识
            jsonObject = HttpUtil.GetJson(requestUrl);
        } catch (Exception e) {
            log.error("获取openId异常：{}",e);
        }
        log.info("微信获取openId返回:"+jsonObject.toString());
        return jsonObject;
    }

    /**
     * 获取token
     * @return
     */
    public static String getAccessToken() {
        String requestUrl = GET_PAGE_ACCESS_TOKEN_URL.replace("APPID", appId).replace("SECRET", appSecret);
        String accessToken = (String) RedisUtil.get(WX_TOKEN+appId);
        if(StringUtils.isBlank(accessToken)){
            try {
                JSONObject tokenJson = HttpUtil.GetJson(requestUrl);
                log.info("微信获取token返回，"+tokenJson.toString());
                accessToken = String.valueOf(tokenJson.get("access_token"));
                RedisUtil.setEx(WX_TOKEN+appId,accessToken,3600);
            } catch (Exception e) {
                log.error("获取微信的token异常：{}",e);
            }
        }
        return accessToken;
    }

    /**
     * 小程序发送订阅
     * @param accessToken
     * @return
     */
    public static Boolean sendSubscribe(String accessToken, String requestUrlParam) {
        String requestUrl = SUBSCRIBR_SEND_URL.replace("ACCESS_TOKEN", accessToken);
        try {
            JSONObject jsonObject = HttpUtil.PostJson(requestUrl, requestUrlParam);
            log.info("小程序发送订阅返回:"+jsonObject.toString());
            if(jsonObject !=null && ResultEnm.SUCCESS.getMessage().equals(jsonObject.get("errmsg"))){
                return true;
            }
        } catch (Exception e) {
            log.error("小程序发送订阅异常：{}",e);
        }
        return false;
    }
}