架构与系统设计 / 系统课时

订单号生成

订单号生成

本课设计一套适用于多实例支付服务的订单号方案:编号按业务与日期分段,数据库负责原子分配号段,每个实例在内存中高速取号。最终方案既避免单点自增瓶颈,也能在扩容、重启和并发抢号时保持全局唯一。

学习目标

  • 设计可读但不泄露敏感业务信息的订单号格式
  • 使用数据库号段保证多实例并发下的唯一性
  • 处理日期切换、号段耗尽、实例重启和唯一约束兜底

先确定编号格式

订单号可以采用 业务前缀 + yyyyMMdd + 10 位流水号,例如 P202608030000000001。前缀用于区分支付、退款等业务,日期便于排查和归档,固定宽度流水号便于排序。编号中不要放商户号、手机号或通道号,避免泄露业务规模与客户信息。

订单号只承担唯一标识和有限的可运维性,不应承载可变业务规则。数据库主键仍可使用自增或雪花 ID,外部订单号单独建立唯一索引。每天 10 位流水最多支持 99 亿笔,超出前必须扩展位数或调整格式。

号段方案如何工作

每个“业务类型 + 日期”对应数据库中的一行序列。实例发现本地号段耗尽时,通过事务把 current_value 原子增加一个步长,并取得新的区间;随后绝大多数请求只在本机内存中递增,不再访问数据库。

多实例订单号号段分配流程

号段允许出现少量空洞,因为实例重启后未使用完的号码不会回收。订单号的关键目标是唯一,而不是绝对连续;强求连续会引入全局锁、性能下降和故障恢复复杂度。

建立序列表并验证分配

下面的 SQL 是本地验证脚本,会重建测试表并分配第一个 1000 大小的号段。生产环境不要执行 DROP TABLE,应通过正式迁移脚本创建表。

sql
DROP TABLE IF EXISTS pay_order_sequence;

CREATE TABLE pay_order_sequence (
    biz_type VARCHAR(32) NOT NULL,
    biz_date DATE NOT NULL,
    current_value BIGINT NOT NULL DEFAULT 0,
    step INT NOT NULL DEFAULT 1000,
    version BIGINT NOT NULL DEFAULT 0,
    PRIMARY KEY (biz_type, biz_date)
) ENGINE = InnoDB;

INSERT INTO pay_order_sequence (
    biz_type, biz_date, current_value, step, version
) VALUES (
    'PAY', '2026-08-03', 0, 1000, 0
);

START TRANSACTION;

UPDATE pay_order_sequence
SET current_value = LAST_INSERT_ID(current_value + step),
    version = version + 1
WHERE biz_type = 'PAY'
  AND biz_date = '2026-08-03';

SELECT
    LAST_INSERT_ID() - step + 1 AS segment_start,
    LAST_INSERT_ID() AS segment_end
FROM pay_order_sequence
WHERE biz_type = 'PAY'
  AND biz_date = '2026-08-03';

COMMIT;

预期结果:

text
segment_start | segment_end
1             | 1000

LAST_INSERT_ID() 的值与数据库连接绑定,因此更新和查询必须在同一连接、同一事务中完成。InnoDB 会锁住目标序列行,并发实例只能依次更新,得到的区间不会重叠。

在应用内消费号段

下面是片段示例,依赖同一个 DataSource、前述 MySQL 表和支付订单表。它只在号段失效或日期变化时访问数据库,正常取号使用 AtomicLong 完成。

java
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.ReentrantLock;

public final class OrderNumberGenerator {
    private static final DateTimeFormatter DAY = DateTimeFormatter.BASIC_ISO_DATE;
    private static final long MAX_DAILY_SEQUENCE = 9_999_999_999L;

    private final DataSource dataSource;
    private final String bizType;
    private final String prefix;
    private final ReentrantLock refillLock = new ReentrantLock();
    private final AtomicReference<Window> window =
            new AtomicReference<>(new Window(LocalDate.MIN, new AtomicLong(1), 0));

    public OrderNumberGenerator(DataSource dataSource, String bizType, String prefix) {
        this.dataSource = dataSource;
        this.bizType = bizType;
        this.prefix = prefix;
    }

    public String nextOrderNo() {
        while (true) {
            LocalDate today = LocalDate.now();
            Window current = window.get();

            if (today.equals(current.date())) {
                long value = current.cursor().getAndIncrement();
                if (value <= current.end()) {
                    return format(today, value);
                }
            }

            refillLock.lock();
            try {
                Window latest = window.get();
                if (today.equals(latest.date())
                        && latest.cursor().get() <= latest.end()) {
                    continue; // 其他线程已经完成补段
                }

                Segment segment = allocateSegment(today);
                window.set(new Window(
                        today,
                        new AtomicLong(segment.start()),
                        segment.end()));
            } finally {
                refillLock.unlock();
            }
        }
    }

    private Segment allocateSegment(LocalDate date) {
        String insertSql = """
                INSERT INTO pay_order_sequence(
                    biz_type, biz_date, current_value, step, version
                ) VALUES (?, ?, 0, 1000, 0)
                ON DUPLICATE KEY UPDATE biz_type = VALUES(biz_type)
                """;
        String updateSql = """
                UPDATE pay_order_sequence
                SET current_value = LAST_INSERT_ID(current_value + step),
                    version = version + 1
                WHERE biz_type = ? AND biz_date = ?
                """;
        String selectSql = """
                SELECT LAST_INSERT_ID() AS segment_end, step
                FROM pay_order_sequence
                WHERE biz_type = ? AND biz_date = ?
                """;

        try (Connection connection = dataSource.getConnection()) {
            connection.setAutoCommit(false);
            try {
                execute(connection, insertSql, date);
                execute(connection, updateSql, date);

                try (PreparedStatement statement = connection.prepareStatement(selectSql)) {
                    statement.setString(1, bizType);
                    statement.setDate(2, Date.valueOf(date));
                    try (ResultSet resultSet = statement.executeQuery()) {
                        resultSet.next();
                        long end = resultSet.getLong("segment_end");
                        long start = end - resultSet.getInt("step") + 1;
                        if (end > MAX_DAILY_SEQUENCE) {
                            throw new IllegalStateException("当日订单流水号已耗尽");
                        }
                        connection.commit();
                        return new Segment(start, end);
                    }
                }
            } catch (Exception exception) {
                connection.rollback();
                throw exception;
            }
        } catch (Exception exception) {
            throw new IllegalStateException("分配订单号段失败", exception);
        }
    }

    private void execute(Connection connection, String sql, LocalDate date)
            throws Exception {
        try (PreparedStatement statement = connection.prepareStatement(sql)) {
            statement.setString(1, bizType);
            statement.setDate(2, Date.valueOf(date));
            statement.executeUpdate();
        }
    }

    private String format(LocalDate date, long value) {
        return prefix + DAY.format(date) + String.format("%010d", value);
    }

    private record Segment(long start, long end) {
    }

    private record Window(LocalDate date, AtomicLong cursor, long end) {
    }
}

生效行为是:多个实例会从数据库获得互不重叠的号段,单个实例在号段内仅做内存递增。验证时可同时启动两个实例,各生成 2000 个编号,汇总后检查总数与去重后的数量是否一致。

边界与故障处理

日期变化时必须放弃前一天剩余号段,并以新日期重新分配。实例重启可以直接申请新号段,不要尝试恢复旧游标。数据库暂时不可用时应快速失败或短暂重试,不能退回本地随机递增,否则会破坏唯一性保证。

订单表还应对 order_no 建立唯一索引,这是防止代码缺陷、错误配置和人工导入造成重复的最后一道防线。号段步长越大,数据库压力越低,但实例故障造成的空洞越多;可根据峰值吞吐与实例数量选择 1000、5000 或更大的步长。

验收标准包括:并发生成无重复、跨实例无重复、跨日期前缀正确、实例重启后不复用旧号段、流水溢出时明确失败,以及数据库异常时不生成不受控编号。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

订单号生成

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通