用户连点两次「确认支付」,你的后端凭什么只扣一次钱?

0 阅读11分钟

上周跟一个朋友吃饭,他刚从某厂面完回来,一脸菜色。

我问咋了。他说被一道题打穿了。

面试官开场很随意:你说你做过支付,那用户在支付页面连点两下确认,你怎么保证同一个请求只处理一次?

他答得也挺随意:加个防重 token 呗,请求进来先查 Redis,有就拦掉,没有就写进去。

面试官点点头,接着问:两个请求同时到,落在两台不同的机器上呢?

他愣了一下:Redis 不是共享的吗,应该能拦住吧。

面试官又问:token 校验完了,业务还在扣款,第二个请求这时候进来了。token 你删了还是没删?删早了业务挂了怎么办,没删重复扣了怎么办?

他就不说话了。

这道题在支付岗、交易岗的面试里出现频率极高,属于那种「看起来简单、一追就崩」的类型。答「用 Redis 存一下」的人太多了,面试官早就听麻了。

但说实话,这四个字不是错,是不够。它底下压着三个坑,而这三个坑,正好把分布式幂等的难点全占齐了。

坑一:先查后写,并发下等于没查

绝大多数人的第一版代码长这样:

Order order = orderMapper.selectByOrderNo(orderNo);
if (order.getStatus() == PAID) {
    return "已支付";
}
doPay(order);   // 扣款

单机低并发跑一年也不会出事。但只要两万个请求里有一次撞上了,就是双重扣费。

原因很朴素:两个线程同时执行 selectByOrderNo,读到的都是「待支付」。它们都认为自己是第一个来的,都往下走,都去扣款。数据库根本没有机会说「等等,这个已经处理过了」—— 因为你压根没让它做判断,判断是在应用内存里做的。

有人会说加锁啊。单机加 synchronized 有用,两台机器就没用了。换分布式锁?能用,但锁的粒度、续期、超时、持锁期间挂掉,又是一整套新问题,而且它本质上还是「先查后写」—— 只是把窗口期从几毫秒缩到了微秒,窗口还在。

真正要改的不是加锁,是换个思路:

「判断这件事有没有被处理过」和「标记它已经被处理过」,必须是同一个不可分割的动作。

一步做完,中间没有缝,别人就插不进来。这叫原子性。后面所有的方案,本质都是在不同的层面上实现这句话。

坑二:你拦住的是请求,不是扣款

第二个坑更隐蔽。

很多人的实现是:请求进来校验 token,通过就删掉 token,然后开始走业务。看起来没问题。

问题在于 —— 删 token 的那一刻,业务还没成功。

如果后面调用第三方支付网关超时了呢?本地事务回滚了呢?这时候 token 已经没了,用户重试,请求畅通无阻地进来,重新扣一次。

反过来也一样。如果你把删除放到业务成功之后,那么在「校验通过」到「业务成功」这段时间里,两个请求都能通过校验,因为你把「消费令牌」和「执行扣款」拆成了两步,中间又开了一道门。

这就是面试官问「token 删了还是没删」时真正想听的东西:你的幂等边界,和你的业务事务边界,是不是重合的。

不重合,就一定有人能在缝里钻进来。

坑三:Redis 不是绝对可靠的

这层很多候选人根本想不到。

Redis 主从是异步复制的。主库 SETNX 成功就返回了,但从库可能还没同步。这时候主库宕机,哨兵切到从库,你刚写进去的令牌 —— 没了。

于是重试的请求开开心心重新拿到令牌,理直气壮地又扣一次。

反方向也会出问题:主库上「删除令牌」的操作没同步过去,从库升主之后令牌还在,重复请求被误拦。这个方向倒是安全(宁可拦错不扣错),但用户体验就是「我明明没付成功,它非说我重复提交」。

所以结论很直接:不能把资金安全的最后一道防线,押在一个 AP 系统上。

Redis 适合做「快速拦截」,不适合做「最终裁决」。裁决权得留给数据库。


到这儿,三层方案的逻辑就自然长出来了。它们不是三个并列的招数,是三个纵深阵地:Redis 挡第一波,状态机挡第二波,唯一索引兜最后。

第一层:入口层,把判重和占位压成一个动作

标准做法是「令牌 + SET NX」。

用户打开支付页,前端先向后端要一个令牌,后端往 Redis 里写:

String key   = "pay:token:" + orderNo;
String token = UUID.randomUUID().toString().replace("-", "");

// SET key value NX PX 300000 —— NX 就是「不存在才写」,这一步本身就是原子的
Boolean ok = redisTemplate.opsForValue()
        .setIfAbsent(key, token, Duration.ofMinutes(5));

return ok ? token : null;

注意两件事。 第一,key 用的是订单号,不是随机串。 这是个细节,但很要命。如果幂等键是纯随机 token,用户手抖刷新一下页面,前端又去要了一个新 token,两个 token 都能通过校验,防重直接失效。幂等键必须落在业务维度上,一笔订单有且只有一个。

第二,消费令牌必须用 Lua,不能 GET 完再 DEL。

-- KEYS[1] = pay:token:{orderNo}
-- ARGV[1] = 客户端带上来的 token
local v = redis.call('GET', KEYS[1])
if v == ARGV[1] then
    redis.call('DEL', KEYS[1])
    return 1
end
return 0

GET 和 DEL 是两条命令,中间那个窗口期足够第二个请求挤进来,两个都读到令牌存在,两个都放行。Lua 脚本在 Redis 里是单线程串行执行的,整段脚本执行期间不会被打断,这才叫原子。

为什么不直接 DEL 再判断返回值?因为 DEL 返回的是「删掉了几个」,它没法校验令牌内容。任何拿着这个订单号来的人都能消费掉别人的令牌,这不叫防重,这叫送人头。

顺带一个容易踩的坑:如果你在 Lua 里还想顺手检查点别的东西(比如黑名单 key),注意 Redis Cluster 下所有 key 必须在同一个 slot,否则直接 CROSSSLOT 报错。用 hash tag 把 key 前缀固定住就行。

到这一层,两个并发请求里只有一个能拿到令牌,另一个拿到 0,直接返回「请勿重复提交」。

但这只是挡住了「同一时刻的重复」。它挡不住重试,挡不住 Redis 丢数据,也挡不住用户等了十分钟又点了一次。

第二层:业务层,让订单状态只能往前走

令牌放行之后,才真正进入支付逻辑。这里靠的不是锁,是状态机。

状态定义清楚,单向流转,不许回头:

WAIT_PAY(0) → PAYING(1) → PAID(2)
                ↘ FAILED(3)

关键在更新这一下,把当前状态写进 WHERE 里:

UPDATE pay_order
SET status = 1,
    version = version + 1,
    update_time = NOW()
WHERE order_no = 'P20260108001'
  AND status = 0
  AND version = 7;

然后看影响行数。 affectedRows == 0 就是全部答案。 它说明这一行已经不是你以为的那个状态了 —— 有人在你看之前就把它改了。这时候不要报错,去查一次最新状态:

  • 已经是 PAID → 返回「支付成功」,用户看到的结果是对的
  • 是 PAYING → 返回「处理中,请稍后查询」
  • 是 FAILED → 可以重新发起

这里有个很多人都搞混的点,我得说清楚:affectedRows == 0 不等于失败,它等于「这件事已经有人做过了」。 幂等处理的正确定义不是「拒绝重复请求」,而是「让重复请求也拿到正确的结果」。这两者的体验差别,在客诉量上能看出来。

至于 version,坦白讲,在支付这种「状态每次都在变」的场景里,AND status = 0 这个条件本身就已经是当前读 + 行锁了,够用。version 真正的价值在别的地方:当你的更新不改变状态、但会覆盖其他字段的时候(比如同时有人改金额、改备注),没有版本号就会被静默覆盖。

两个都留着不亏,但别以为 version 才是关键 ——WHERE status = 0 才是。

第三层:数据层,唯一索引兜底

最后一层,交给数据库。

支付流水表上给订单号建唯一索引:

CREATE TABLE pay_flow (
    id          BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    order_no    VARCHAR(64) NOT NULL COMMENT '订单号',
    channel_no  VARCHAR(64) DEFAULT NULL COMMENT '渠道流水号',
    amount      DECIMAL(12,2) NOT NULL,
    create_time DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
    UNIQUE KEY uk_order_no (order_no)
) ENGINE=InnoDB;

两个请求就算前面两道关全被绕过了,走到插流水这一步,也只有一个能成功。另一个撞唯一键冲突,插入失败,事务回滚,后面的资金扣减代码根本执行不到。

这是整套方案里唯一一个「即使所有应用层都出错也不会出错」的地方。 因为约束是数据库自己守的,不依赖任何人的代码写对。

不过这里有个非常真实的坑,很多人踩了都不知道自己踩了:

try {
    payFlowMapper.insert(flow);          // 撞唯一键
} catch (DuplicateKeyException e) {
    return "重复请求";                    // 然后在这里返回
}
// 同一个事务里继续干别的 → 抛 UnexpectedRollbackException

Spring 的事务里,一旦抛出 DataIntegrityViolationException,事务会被标记成 rollback-only。你 catch 住了异常,代码是继续往下走了,但只要这个事务还要提交,就会炸一个 UnexpectedRollbackException,而且报错信息跟重复键八竿子打不着,排查起来很痛苦。

正确姿势两种:要么让这个插入走独立事务(REQUIRES_NEW),失败就是失败,跟外层没关系;要么干脆不用异常控制流程,INSERT IGNORE 或者 ON DUPLICATE KEY UPDATE,看返回的影响行数判断。

我个人倾向前者,语义更清楚。


面试官要是继续挖,就把这张牌打出来

到这儿已经能答完题了。但如果对面还想听点更深的,有个思路值得讲:把「幂等记录」本身当成一个有状态的实体来管,而不是一次性的缓存开关。

Redis 令牌有个天然缺陷:它是个二值的东西,要么在,要么不在,不携带任何「进展到哪一步」的信息。所以它没法回答一个关键问题 —— 那个先到的请求,到底成功了没有?

改成一张表:

CREATE TABLE pay_idempotent (
    id          BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    biz_key     VARCHAR(64) NOT NULL COMMENT '业务幂等键,比如订单号',
    status      TINYINT NOT NULL DEFAULT 0 COMMENT '0处理中 1成功 2失败',
    result_code VARCHAR(32) DEFAULT NULL COMMENT '成功后回放给调用方的结果',
    expire_time DATETIME NOT NULL,
    UNIQUE KEY uk_biz_key (biz_key)
) ENGINE=InnoDB;

流程变成这样:

  1. 请求进来,先 INSERT 一条 status = 0 的记录,只有插入成功的那个请求,才有资格去调支付网关。插入失败的,说明有人正在处理。

  2. 插入失败的那个请求,去读这条记录的状态:

    • 0 处理中 → 返回「处理中,请稍候」,不要返回成功,也不要返回失败
    • 1 成功 → 直接把 result_code 回放给它,这就是结果幂等
    • 2 失败 → 允许重试
  3. 调网关成功 + 本地写库,同一个事务里把状态改成 1。

这套东西解决了一个前面三层都没解决的问题:「网关那边扣成功了,但我本地写库失败了」怎么办。

这时候业务其实是成功的,钱已经出去了,只是你没记录。如果靠「删令牌允许重试」,用户重试就会扣第二次。而在状态机方案里,重试进来看到的是 0 或 1,它不会重新扣款,只会告诉你「在查,稍等」。

至于卡在 0 一直不动的记录,靠 expire_time 加一个补单任务去渠道侧主动查单,查到结果回填。绝对不能简单地删掉它当没发生过 —— 删掉就等于放弃了对这笔钱的记忆。

配套还有个东西值得一起提:发件箱模式(Outbox)。

支付结果要通知订单系统、积分系统、风控、消息推送,这些下游挂一个,不能把资金主链路拖死。做法是把「要发什么消息」和「改支付状态」写在同一个本地事务里,落到一张 outbox 表,再由异步任务去投递,投不进的进死信队列重试。

这样主链路只管一件事:把钱扣对。通知的事,慢一点、重一点,都无所谓。