jsonobject中getkey_心血来潮！基于Redis解决业务场景中延迟队列

在一次产品需求设计中，有这样一种场景，对于一个工单，专员可以选择将工单挂起（一次挂起2小时；二次挂起12小时），或者转存（表单输入转存的天数），然后提交工单 到既定时间后，该工单需要重新被领单，然后再次审核。对于工单，有优先级概念，意味着优先级越大，该工单则需要优先被派单，对于这种场景，我们可以基于Redis来解决场景问题。

一、业务概述

我们假定设置两个队列，一个队列维护正式工单，另一个队列维护挂起工单。对于挂起操作，我们通过Redis设置key有效时间，当key失效时，客户端监听失效事件，获取工单，实现 挂起工单队列的移除，正式队列的入队即可。

业务流程图：

二、代码实现

整个业务实现，可以分为三个大模块。

• 队列模块，通过WorkOrderQueueTransfer带外提供内部的调用。
• 工单模块、通过OperateStrategyManager管理器实现工单相关场景的操作。
• 事件监听、通过继承KeyExpirationEventMessageListener，实现对Key过期失效的监听（特别说明：Redis服务器redis.conf需要开启Key过期失效通知）。

2.1、工单队列实现

我们可以基于Redis ZSet数据存储，ZSet是个有序集合，可以实现基于score排序。

2.1.1、定义上下文类（WorkOrderContext）

/**
 * @description: 工单上下文对象
 * @Date : 2020/7/13 下午4:28
 * @Author : 石冬冬-Seig Heil
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class WorkOrderContext {
    /**
     * 是否测试人员专用
     */
    private boolean isTest;
    /**
     * 工单号
     */
    private WorkOrder worOrder;
    /**
     * 队列类型
     */
    private QueueType queueType;


    /**
     * 创建-正式队列（立即需要被派单
     * @return
     */
    public static WorkOrderContext buildImmediate() {
        return WorkOrderContext.builder().queueType(QueueType.immediate).build();
    }

    /**
     * 创建-挂起队列（挂起n小时执行）
     * @return
     */
    public static WorkOrderContext buildSuspended() {
        return WorkOrderContext.builder().queueType(QueueType.suspended).build();
    }


    /**
     * 转存队列（转存n天后执行）
     * @return
     */
    public static WorkOrderContext buildStored() {
        return WorkOrderContext.builder().queueType(QueueType.stored).build();
    }

    /**
     * 创建-正式队列（立即需要被派单）
     *
     * @param workCode
     * @param priority
     * @return
     */
    public static WorkOrderContext buildImmediate(String workCode, double priority) {
        WorkOrder workOrder = WorkOrder.builder().workCode(workCode).priority(priority).delayedTime(0).build();
        return WorkOrderContext.builder().worOrder(workOrder).queueType(QueueType.immediate).build();
    }

    /**
     * 创建-挂起队列（挂起n小时执行）
     *
     * @param workCode
     * @param priority
     * @param delayedTime
     * @return
     */
    public static WorkOrderContext buildSuspended(String workCode, double priority, long delayedTime) {
        WorkOrder workOrder = WorkOrder.builder().workCode(workCode).priority(priority).delayedTime(delayedTime).build();
        return WorkOrderContext.builder().worOrder(workOrder).queueType(QueueType.suspended).build();
    }

    /**
     * 转存队列（转存n天后执行）
     *
     * @param workCode
     * @param priority
     * @param delayedTime
     * @return
     */
    public static WorkOrderContext buildStored(String workCode, double priority, long delayedTime) {
        WorkOrder workOrder = WorkOrder.builder().workCode(workCode).priority(priority).delayedTime(delayedTime).build();
        return WorkOrderContext.builder().worOrder(workOrder).queueType(QueueType.stored).build();
    }


    /**
     * 队列类型
     */
    public enum QueueType {
        /**
         * 正式队列（立即需要被派单）
         */
        immediate,
        /**
         * 挂起队列（挂起n小时执行）
         */
        suspended,
        /**
         * 转存队列（转存n天后执行）
         */
        stored
    }

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @Builder
    public static class WorkOrder {
        /**
         * 工单号
         */
        private String workCode;
        /**
         * 优先级
         */
        private double priority;
        /**
         * 延迟时间
         */
        private long delayedTime;
    }
}

2.1.2、定义抽象缓存类（AbstractCacheManager）

该抽象类定义了一个方法，抽象定义了一个具有重试机制的方法。其中注入的BeanRedisService是咱们子类基于Redis API的封装。

/**
 * @description: 抽象缓存管理器
 * @Date : 2020/7/18 下午9:41
 * @Author : 石冬冬-Seig Heil
 */
@Slf4j
public abstract class AbstractCacheManager {

    final int MAX_RETRIES = 3;

    @Autowired
    RedisService redisService;

    /**
     * 重试操作
     * @param retries 重试次数
     * @param context 上下文
     * @param call 重试动作
     */
    public  void retry(int retries, T context, Function call){
        boolean done = false;
        int retry = 1;
        do {
            try {
                done = call.apply(retry);
                log.info("[retry] context={},retry={},done={}", JSONObject.toJSON(context),retry,done);
                retry ++;
                TimeUnit.MILLISECONDS.sleep(100);
            } catch (Exception e) {
                log.error("[retry] 异常 ctx={}", JSONObject.toJSON(context),e);
                retry ++;
            }
        }while (retry <= retries && !done);
    }
}

2.1.3、定义基于Redis Cache的Manager类（WorkOrderCacheManager）

该类的主要作用，基于Redis String对象存储，实现具有Key失效机制的存储。

• 内部静态类CacheValue，作为Redis String对象存储的Value值。
• 内部枚举类CacheType，维护了缓存Key的业务前缀。
• 特别说明的是，我们构成Redis String存储Key的命名规则，例如：carCarthage:stored_cache_单号。

/**
 * @description: 工单缓存管理器
 * @Date : 2020/7/14 下午4:28
 * @Author : 石冬冬-Seig Heil
 */
@Component
@Slf4j
public class WorkOrderCacheManager extends AbstractCacheManager{

    /**
     * 设置缓存并设置缓存失效日期
     * @param cache
     */
    public void setCacheInExpire(CacheValue cache){
        retry(MAX_RETRIES,cache,idx -> {
            String redisKey = redisService.getKey(getRedisKeySuffix(cache.getType(),cache.getWorkCode()));
            redisService.set(redisKey, JSONObject.toJSONString(cache),cache.getExpireSeconds());
            log.info("[setCacheInExpire],redisKey={},CacheValue={}",redisKey,JSONObject.toJSONString(cache));
            return Boolean.TRUE;
        });
    }

    /**
     * 查询某个工单号的缓存值
     * @param cacheType 缓存类型 {@link CacheType}
     * @param workCode 工单号
     * @return
     */
    public CacheValue get(CacheType cacheType,String workCode){
        String redisKey = redisService.getKey(getRedisKeySuffix(cacheType,workCode));
        String value =  redisService.get(redisKey,String.class);
        return JSONObject.parseObject(value,CacheValue.class);
    }

    /**
     * 从上下文队列类型获取队列redis key
     * @param cacheType 缓存类型 {@link CacheType}
     * @param workCode 工单号
     * @return
     */
    String getRedisKeySuffix(CacheType cacheType,String workCode){
        switch (cacheType){
            case stored_cache:
                return CacheType.stored_cache.getKey() + workCode;
            case suspended_cache:
                return CacheType.suspended_cache.getKey() + workCode;
            default:
                break;
        }
        return null;
    }

    /**
     * 缓存值
     */
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @Builder
    public static class CacheValue{
        /**
         * 缓存类型
         */
        private CacheType type;
        /**
         * 工单号
         */
        private String workCode;
        /**
         * 优先级
         */
        private double priority;
        /**
         * 延迟截止时间(单位：时间戳)
         */
        private long delayedTime;
        /**
         * 缓存失效时间(单位：秒)
         */
        private long expireSeconds;

        /**
         * 创建-挂起队列（挂起n小时执行）
         *
         * @param workCode
         * @param priority
         * @param delayedTime
         * @param expireSeconds
         * @return
         */
        public static CacheValue buildSuspended(String workCode, double priority, long delayedTime,long expireSeconds) {
            return CacheValue.builder()
                    .type(CacheType.suspended_cache)
                    .workCode(workCode)
                    .priority(priority)
                    .delayedTime(delayedTime)
                    .expireSeconds(expireSeconds)
                    .build();
        }

        /**
         * 转存队列（转存n天后执行）
         *
         * @param workCode
         * @param priority
         * @param delayedTime
         * @param expireSeconds
         * @return
         */
        public static CacheValue buildStored(String workCode, double priority, long delayedTime,long expireSeconds) {
            return CacheValue.builder()
                    .type(CacheType.stored_cache)
                    .workCode(workCode)
                    .priority(priority)
                    .delayedTime(delayedTime)
                    .expireSeconds(expireSeconds)
                    .build();
        }
    }

    /**
     * 实现 挂起|转存 缓存key
     */
    @Getter
    public enum CacheType{
        stored_cache("stored_cache_"),
        suspended_cache("suspended_cache_"),
        ;
        CacheType(String key) {
            this.key = key;
        }
        private String key;
    }
}

2.1.4、工单队列管理器（WorkOrderQueueManager）

该类基于Redis ZSet 对象结构的有序集合，可以实现按照优先级出队。

相关方法介绍：

• String getRedisKey(WorkOrderContext context)：从 WorkOrderContext中获取队列类型，返回集合要存储的Key。
• Long queueSize(WorkOrderContext context)：返回队列大小
• Boolean leftPush(WorkOrderContext context)：执行处理（入队操作）
• Boolean leftPushIfAbsent(WorkOrderContext context)：执行处理（入队操作），如果入队元素缺席则入队，返回true；否则返回false。
• Long remove(WorkOrderContext context)：从队列移除某个元素
• WorkOrderContext.WorkOrder pop(WorkOrderContext context)：从集合中获取评分最小的成员出队
• Set rank(WorkOrderContext context)：按照升序查看队列中所有成员
• Long removeRange(String key, long start, long end)：按照范围移除队列元素
• Long removeValues(String key, List