java学习之使用redission实现自动关单功能

在我们日常开发中会经常遇到超时自动取消的操作,其实实现该功能有许多方法:

1、被动关闭(不推荐)

2、定时任务(推荐，适合时间精确度要求不高的场景)

3、DelayQueue(不推荐，基于内存，无法持久化)

4、时间轮(不推荐，基于内存，无法持久化)

5、kafka(MQ 方案不推荐，大量无效调度)

6、RocketMQ延迟消息(MQ方案不推荐，大量无效调度)

7、RabbitMQ死信队列(MQ方案不推荐，大量无效调度)

8、RabbitMQ插件(MQ方案不推荐，大量无效调度)

9、Redis过期监听(不推荐，容易丢消息)

10、Redis的ZSet(不推荐，可能会重复消费)

11、Redisson(推荐，可以用)

这里主要讲述redisson实现该功能的原理及实现具体方式

实现原理:

Redisson中定义了分布式延迟队列RDelayQueue,这是一种zset结构实现的延时队列,其实就是在zset的基础上增加了一个基于内存的延迟队列,当我们添加一个数据到延时队列的时候,redisson会把数据+超时时间放到zset中,并起一个延时任务,当延时任务到期的时候,再去zset中把数据去出来,返回给客户端使用

具体实现: 这里是实现了commandLineRunner接口会在启动时执行指定的代码,注意业务枚举类beanId需要和实现类小写驼峰名称相同不然匹配不到,因为spring加载bean时会把beanId命名为相应类的小写驼峰形式

<!--        引入 redisson-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.15.4</version>
        </dependency>

spring:
  redis:
    host: 127.0.0.1
    port: 6379
    password: redis
    database: 1
    timeout: 6000

package com.msb.crm.config;
 
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
/**
 * 创建 RedissonConfig 配置
 * <p>
 * Created by fengqx
 */
@Configuration
public class RedissonConfig {
 
    @Value("${spring.redis.host}")
    private String host;
 
    @Value("${spring.redis.port}")
    private int port;
 
    @Value("${spring.redis.database}")
    private int database;
 
    @Value("${spring.redis.password}")
    private String password;
 
    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer()
                .setAddress("redis://" + host + ":" + port)
                .setDatabase(database);
//                .setPassword(password);
        return Redisson.create(config);
    }
}

import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RBlockingDeque;
import org.redisson.api.RDelayedQueue;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
import java.util.Map;
import java.util.concurrent.TimeUnit;
 
/**
 * 封装 Redis 延迟队列工具
 * <p>
 * Created by fengq
 */
@Slf4j
@Component
public class RedisDelayQueueUtil {
 
    @Autowired
    private RedissonClient redissonClient;
 
    /**
     * 添加延迟队列
     *
     * @param t
     * @param delay
     * @param timeUnit
     * @param queueCode
     * @param <T>
     */
    public <T> void addDelayQueue(T t, long delay, TimeUnit timeUnit, String queueCode) {
        try {
            RBlockingDeque<Object> blockingDeque = redissonClient.getBlockingDeque(queueCode);
            RDelayedQueue<Object> delayedQueue = redissonClient.getDelayedQueue(blockingDeque);
            delayedQueue.offer(t, delay, timeUnit);
            log.info("添加延时队列成功，队列键：{}，队列值：{}，延迟时间：{}", queueCode, t, timeUnit.toSeconds(delay) + "秒");
        } catch (Exception e) {
            log.error("添加延时队列失败：{}", e.getMessage());
            throw new RuntimeException("添加延时队列失败");
        }
    }
 
    /**
     * 获取延迟队列
     *
     * @param queueCode
     * @param <T>
     * @return
     * @throws InterruptedException
     */
    public <T> T getDelayQueue(String queueCode) throws InterruptedException {
        RBlockingDeque<Map> blockingDeque = redissonClient.getBlockingDeque(queueCode);
        T value = (T) blockingDeque.take();
        return value;
    }
}

package com.msb.crm.util;
 
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
 
/**
 * SpringUtil 工具类
 * <p>
 * Created by fengq
 */
@Slf4j
@Component
public class SpringUtil implements ApplicationContextAware {
 
    private static ApplicationContext applicationContext;
 
    /**
     * 服务器启动，Spring容器初始化时，当加载了当前类为bean组件后，将会调用下面方法注入ApplicationContext实例
     *
     * @param applicationContext
     * @throws BeansException
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        log.info("applicationContext 初始化了");
        SpringUtil.applicationContext = applicationContext;
    }
 
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }
 
    public static <T> T getBean(String beanId) {
        return (T) applicationContext.getBean(beanId);
    }
 
    public static <T> T getBean(Class<T> clazz) {
        return (T) applicationContext.getBean(clazz);
    }
}

/**
 * 延迟队列业务枚举
 * <p>
 * Created by fengq
 */
@Getter
@NoArgsConstructor
@AllArgsConstructor
public enum RedisDelayQueue {
 
    ORDER_PAYMENT_TIMEOUT("ORDER_PAYMENT_TIMEOUT", "订单支付超时，自动取消订单", "orderPaymentTimeout"),
 
    ORDER_TIMEOUT_NOT_EVALUATED("ORDER_TIMEOUT_NOT_EVALUATED", "订单超时未评价，系统默认好评", "orderTimeoutNotEvaluated"),
 
    ;
 
    /**
     * 延迟队列 Redis Key
     */
    private String code;
 
    /**
     * 中文描述
     */
    private String desc;
 
    /**
     * 延迟队列具体业务实现的 Bean
     * 可通过 Spring 的上下文获取
     */
    private String beanId;
}

package com.msb.crm.redis;
 
/**
 * 延迟队列执行器
 * <p>
 * Created by fenq
 */
public interface RedisDelayQueueHandle<T> {
 
    void execute(T t);
}

package com.msb.crm.redis;
 
import com.msb.crm.entity.RedisDelayQueue;
import com.msb.crm.util.RedisDelayQueueUtil;
import com.msb.crm.util.SpringUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
 
/**
 * 创建延迟队列消费线程
 * <p>
 * Created by fenq
 */
@Slf4j
@Component
public class RedisDelayQueueRunner implements CommandLineRunner {
 
    @Autowired
    private RedisDelayQueueUtil redisDelayQueueUtil;
 
    @Autowired
    private SpringUtil springUtil;
 
    /**
     * 启动延迟队列
     *
     * @param args
     */
    @Override
    public void run(String... args) {
        new Thread(() -> {
            while (true) {
                try {
                    RedisDelayQueue[] queues = RedisDelayQueue.values();
                    for (RedisDelayQueue queue : queues) {
                        Object o = redisDelayQueueUtil.getDelayQueue(queue.getCode());
                        if (null != o) {
                            RedisDelayQueueHandle redisDelayQueueHandle = springUtil.getBean(queue.getBeanId());
                            redisDelayQueueHandle.execute(o);
                        }
                    }
                } catch (InterruptedException e) {
                    log.error("Redis延迟队列异常中断：{}", e.getMessage());
                }
            }
        }).start();
        log.info("Redis延迟队列启动成功");
    }
}

package com.msb.crm.redis;
 
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
 
import java.util.Map;
 
/**
 * 订单支付超时处理
 * <p>
 * Created by fenq
 */
@Slf4j
@Component
public class OrderPaymentTimeout implements RedisDelayQueueHandle<Map<String, Object>> {
    @Override
    public void execute(Map<String, Object> map) {
        // TODO-MICHAEL: 2023-08-05 订单支付超时，自动取消订单处理业务...
        log.info("收到订单支付超时延迟消息：{}", map);
    }
}

package com.msb.crm.redis;
 
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
 
import java.util.Map;
 
/**
 * 订单超时未评价处理
 * <p>
 * Created by fqngq
 */
@Slf4j
@Component
public class OrderTimeoutNotEvaluated implements RedisDelayQueueHandle<Map<String, Object>> {
    @Override
    public void execute(Map<String, Object> map) {
        // TODO-MICHAEL: 2023-08-05 订单超时未评价，系统默认好评处理业务...
        log.info("收到订单超时未评价延迟消息：{}", map);
    }
}

package com.msb.crm.controller;
 
import com.msb.crm.entity.RedisDelayQueue;
import com.msb.crm.util.RedisDelayQueueUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
 
/**
 * 延迟队列测试
 * <p>
 * Created by fqngq
 */
@RestController
@RequestMapping("/api/redis/delayQueue")
public class RedisDelayQueueController {
 
    @Autowired
    private RedisDelayQueueUtil redisDelayQueueUtil;
 
    @GetMapping("/add")
    public void addQueue() {
        Map<String, Object> map1 = new HashMap<>();
        map1.put("orderId", "100");
        map1.put("remark", "订单支付超时，自动取消订单");
 
        Map<String, String> map2 = new HashMap<>();
        map2.put("orderId", "200");
        map2.put("remark", "订单超时未评价，系统默认好评");
 
        // 添加订单支付超时，自动取消订单延迟队列。为了测试效果，延迟30秒钟
        redisDelayQueueUtil.addDelayQueue(map1, 30, TimeUnit.SECONDS, RedisDelayQueue.ORDER_PAYMENT_TIMEOUT.getCode());
 
        // 订单超时未评价，系统默认好评。为了测试效果，延迟60秒钟
        redisDelayQueueUtil.addDelayQueue(map2, 60, TimeUnit.SECONDS, RedisDelayQueue.ORDER_TIMEOUT_NOT_EVALUATED.getCode());
    }
}