当前位置： 首页 > article >正文

订单超时自动取消的7种方案

article 2024/12/22 15:21:43

大家好，我是苏三，又跟大家见面了。

前言

在电商、外卖、票务等系统中，订单超时未支付自动取消是一个常见的需求。

这个功能乍一看很简单，甚至很多初学者会觉得："不就是加个定时器么？" 但真到了实际工作中，细节的复杂程度往往会超乎预期。

这里我们从基础到高级，逐步分析各种实现方案，最后分享一些在生产中常见的优化技巧，希望对你会有所帮助。

1. 使用延时队列（DelayQueue）

适用场景：订单数量较少，系统并发量不高。

延时队列是Java并发包（java.util.concurrent）中的一个数据结构，专门用于处理延时任务。

订单在创建时，将其放入延时队列，并设置超时时间。

延时时间到了以后，队列会触发消费逻辑，执行取消操作。

示例代码：

import java.util.concurrent.*;

public class OrderCancelService {
    private static final DelayQueue<OrderTask> delayQueue = new DelayQueue<>();

    public static void main(String[] args) throws InterruptedException {
        // 启动消费者线程
        new Thread(() -> {
            while (true) {
                try {
                    OrderTask task = delayQueue.take(); // 获取到期任务
                    System.out.println("取消订单：" + task.getOrderId());
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }).start();

        // 模拟订单创建
        for (int i = 1; i <= 5; i++) {
            delayQueue.put(new OrderTask(i, System.currentTimeMillis() + 5000)); // 5秒后取消
            System.out.println("订单" + i + "已创建");
        }
    }

    static class OrderTask implements Delayed {
        private final long expireTime;
        private final int orderId;

        public OrderTask(int orderId, long expireTime) {
            this.orderId = orderId;
            this.expireTime = expireTime;
        }

        public int getOrderId() {
            return orderId;
        }

        @Override
        public long getDelay(TimeUnit unit) {
            return unit.convert(expireTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
        }

        @Override
        public int compareTo(Delayed o) {
            return Long.compare(this.expireTime, ((OrderTask) o).expireTime);
        }
    }
}

优点：

  • 实现简单，逻辑清晰。

缺点：

  • 依赖内存，系统重启会丢失任务。

  • 随着订单量增加，内存占用会显著上升。

2. 基于数据库轮询

适用场景：订单数量较多，但系统对实时性要求不高。

轮询是最容易想到的方案：定期扫描数据库，将超时的订单状态更新为“已取消”。

示例代码：

public void cancelExpiredOrders() {
    String sql = "UPDATE orders SET status = 'CANCELLED' WHERE status = 'PENDING' AND create_time < ?";
    try (Connection conn = dataSource.getConnection();
         PreparedStatement ps = conn.prepareStatement(sql)) {
        ps.setTimestamp(1, new Timestamp(System.currentTimeMillis() - 30 * 60 * 1000)); // 30分钟未支付取消
        int affectedRows = ps.executeUpdate();
        System.out.println("取消订单数量：" + affectedRows);
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

优点：

  • 数据可靠性强，不依赖内存。

  • 实现成本低，无需引入第三方组件。

缺点：

  • 频繁扫描数据库，会带来较大的性能开销。

  • 实时性较差（通常定时任务间隔为分钟级别）。

优化建议：

  • 为相关字段加索引，避免全表扫描。

  • 结合分表分库策略，减少单表压力。

3. 基于Redis队列

适用场景：适合对实时性有要求的中小型项目。

Redis 的 List 或 Sorted Set 数据结构非常适合用作延时任务队列。

我们可以把订单的超时时间作为 Score，订单 ID 作为 Value 存到 Redis 的 ZSet 中，定时去取出到期的订单进行取消。

例子：

public void addOrderToQueue(String orderId, long expireTime) {
    jedis.zadd("order_delay_queue", expireTime, orderId);
}

public void processExpiredOrders() {
    long now = System.currentTimeMillis();
    Set<String> expiredOrders = jedis.zrangeByScore("order_delay_queue", 0, now);
    for (String orderId : expiredOrders) {
        System.out.println("取消订单：" + orderId);
        jedis.zrem("order_delay_queue", orderId); // 删除已处理的订单
    }
}

优点：

  1. 实时性高。

  2. Redis 的性能优秀，延迟小。

缺点：

  1. Redis 容量有限，适合中小规模任务。

  2. 需要额外处理 Redis 宕机或数据丢失的问题。

4. Redis Key 过期回调

适用场景：对超时事件实时性要求高，并且希望依赖 Redis 本身的特性实现简单的任务调度。

Redis 提供了 Key 的过期功能，结合 keyevent 事件通知机制，可以实现订单的自动取消逻辑。

当订单设置超时时间后，Redis 会在 Key 过期时发送通知，我们只需要订阅这个事件并进行相应的处理。

例子：

  1. 设置订单的过期时间：

public void setOrderWithExpiration(String orderId, long expireSeconds) {
    jedis.setex("order:" + orderId, expireSeconds, "PENDING");
}

  1. 订阅 Redis 的过期事件：

public void subscribeToExpirationEvents() {
    Jedis jedis = new Jedis("localhost");
    jedis.psubscribe(new JedisPubSub() {
        @Override
        public void onPMessage(String pattern, String channel, String message) {
            if (channel.equals("__keyevent@0__:expired")) {
                System.out.println("接收到过期事件，取消订单：" + message);
                // 执行取消订单的业务逻辑
            }
        }
    }, "__keyevent@0__:expired"); // 订阅过期事件
}

优点：

  1. 实现简单，直接利用 Redis 的过期机制。

  2. 实时性高，过期事件触发后立即响应。

缺点：

  1. 依赖 Redis 的事件通知功能，需要开启 notify-keyspace-events 配置。

  2. 如果 Redis 中大量使用过期 Key，可能导致性能问题。

注意事项：要使用 Key 过期事件，需要确保 Redis 配置文件中 notify-keyspace-events 的值包含 Ex。比如：

notify-keyspace-events Ex

5. 基于消息队列（如RabbitMQ）

适用场景：高并发系统，实时性要求高。

订单创建时，将订单消息发送到延迟队列（如RabbitMQ 的 x-delayed-message 插件）。

延迟时间到了以后，消息会重新投递到消费者，消费者执行取消操作。

示例代码（以RabbitMQ为例）：

public void sendOrderToDelayQueue(String orderId, long delay) {
    Map<String, Object> args = new HashMap<>();
    args.put("x-delayed-type", "direct");
    ConnectionFactory factory = new ConnectionFactory();
    try (Connection connection = factory.newConnection();
         Channel channel = connection.createChannel()) {
        channel.exchangeDeclare("delayed_exchange", "x-delayed-message", true, false, args);
        channel.queueDeclare("delay_queue", true, false, false, null);
        channel.queueBind("delay_queue", "delayed_exchange", "order.cancel");

        AMQP.BasicProperties props = new AMQP.BasicProperties.Builder()
                .headers(Map.of("x-delay", delay)) // 延迟时间
                .build();
        channel.basicPublish("delayed_exchange", "order.cancel", props, orderId.getBytes());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

优点：

  1. 消息队列支持分布式，高并发下表现优秀。

  2. 数据可靠性高，不容易丢消息。

缺点：

  1. 引入消息队列增加了系统复杂性。

  2. 需要处理队列堆积的问题。

6. 使用定时任务框架

适用场景：订单取消操作复杂，需要分布式支持。

定时任务框架，比如：Quartz、Elastic-Job，能够高效地管理任务调度，适合处理批量任务。

比如 Quartz 可以通过配置 Cron 表达式，定时执行订单取消逻辑。

示例代码：

@Scheduled(cron = "0 */5 * * * ?")
public void scanAndCancelOrders() {
    System.out.println("开始扫描并取消过期订单");
    // 这里调用数据库更新逻辑
}

优点：

  1. 成熟的调度框架支持复杂任务调度。

  2. 灵活性高，支持分布式扩展。

缺点：

  1. 对实时性支持有限。

  2. 框架本身较复杂。

7. 基于触发式事件流处理

适用场景：需要处理实时性较高的订单取消，同时结合复杂业务逻辑，例如根据用户行为动态调整超时时间。

可以借助事件流处理框架（如 Apache Flink 或 Spark Streaming），实时地处理订单状态，并触发超时事件。

每个订单生成后，可以作为事件流的一部分，订单未支付时通过流计算触发超时取消逻辑。

示例代码（以 Apache Flink 为例）：

DataStream<OrderEvent> orderStream = env.fromCollection(orderEvents);

orderStream
    .keyBy(OrderEvent::getOrderId)
    .process(new KeyedProcessFunction<String, OrderEvent, Void>() {
        @Override
        public void processElement(OrderEvent event, Context ctx, Collector<Void> out) throws Exception {
            // 注册一个定时器
            ctx.timerService().registerProcessingTimeTimer(event.getTimestamp() + 30000); // 30秒超时
        }

        @Override
        public void onTimer(long timestamp, OnTimerContext ctx, Collector<Void> out) throws Exception {
            // 定时器触发，执行订单取消逻辑
            System.out.println("订单超时取消，订单ID：" + ctx.getCurrentKey());
        }
    });

优点：

  1. 实时性高，支持复杂事件处理逻辑。

  2. 适合动态调整超时时间，满足灵活的业务需求。

缺点：

  1. 引入了流计算框架，系统复杂度增加。

  2. 对运维要求较高。

总结

每种方案都有自己的适用场景，大家在选择的时候，记得结合业务需求、订单量、并发量来综合考虑。

如果你的项目规模较小，可以直接用延时队列或 Redis；而在大型高并发系统中，消息队列和事件流处理往往是首选。

当然，代码实现只是第一步，更重要的是在实际部署和运行中进行性能调优，保证系统的稳定性。

希望这篇文章能给大家一些启发，也欢迎讨论其他可能的实现思路！


http://www.kler.cn/a/446653.html

相关文章：

  • python如何保存.npy
  • 周末总结(2024/12/21)
  • web3跨链桥协议-Nomad
  • 微信小程序实现画板画布自由绘制、选择画笔粗细及颜色、记录撤回、画板板擦、清空、写字板、导出绘图、canvas，开箱即用
  • 机器学习中做时间序列模型考虑把时间作为特征分析
  • HTTP—02
  • 深入理解YOLO系列目标检测头的设定方式
  • 如何有效划分服务器磁盘空间？具体的步骤和流程
  • 本地摄像头视频流在html中打开
  • 【机器学习】以机器学习为翼，翱翔网络安全创新苍穹
  • 汽车IVI中控开发入门及进阶（43）：NanoVG
  • 打造智慧医院挂号枢纽：SSM 与 Vue 融合的系统设计与实施
  • 【单片机原理】第1章 微机基础知识，运算器，控制器，寄存器，微机工作过程，数制转换
  • HuggingFace datasets - 下载数据
  • C语言数据库管理系统示例：文件操作、内存管理、错误处理与动态数据库设计 栈和堆的内存分配
  • [c++进阶(二)] 智能指针详细剖析--RAII思想
  • 在 .NET 5.0 运行 .NET 8.0 教程：使用 ASP.NET Core 创建 Web API
  • python 模拟法
  • 学技术学英文：SpringBoot的内置监控组件-Spring Boot Actuator
  • Android 10 Launcher3 删除谷歌搜索
  • c++中如何处理对象的创建与销毁的时机？
  • Python发送带key的kafka消息
  • TCP为什么需要三次握手和四次挥手？
  • 创新性融合丨卡尔曼滤波+目标检测 新突破！
  • C/C++语言基础--C++STL库之仿函数、函数对象、bind、function简介
  • 单元测试（C++）——gmock通用测试模版（个人总结）