面试官:设计一个自动售货机系统。我:别急着写代码,先问5个问题|状态机+防超卖+断电自愈,一套答法讲透

"来,设计一个自动售货机系统。"

这题我在面人和被面的时候都遇到过,看似送分,实则是场景设计题里的"隐形杀手"------大部分人上来就 class VendingMachine 一顿堆字段,写到一半自己都不知道状态转到哪了。其实这题真正考的不是"写出几个类",而是你能预判系统会在哪里出问题:超卖、掉单、付了钱不出货、断电之后账对不上......

这篇把我压箱底的完整答法拆开讲透:从需求澄清、状态机建模、并发防超卖、支付幂等,到硬件不可靠下的补偿闭环和断电自愈,一套讲完。不管你是准备面试,还是真要做 IoT/交易类系统,都能直接用。

一、破题第一步:先别写代码,把需求问清楚

实际面试中,开口的前 30 秒基本就定了面试官对你的第一印象。很多候选人听到题目就开始堆类图,直接挂掉一半------先澄清需求 = 大厂基本功。

我一般连问 5 个问题:

要确认的 为什么问
单机嵌入式,还是万台设备的联网云平台? 决定是"状态机 + 本地 DB",还是要谈分布式、对账
支付方式:现金 / 扫码 / 刷卡 / 刷脸? 现金要设计找零模块和硬件协议;扫码涉及异步回调和幂等
并发量级?QPS 多少? 单机是低并发强一致,不是秒杀;量大才需要削峰分片
硬件会不会卡货、掉电、不回包?有传感器吗? 必须假设会,这决定了有没有"卡货补偿"链路,是本题灵魂
要不要支持离线售卖? 这是最大的坑,也是最大的加分项(后面细讲)

💡 主动澄清需求 = 你没把面试官当出题机器,而是当"甲方"。这一步做对,气场就稳了。

问完把需求按优先级收敛成三档:

优先级 功能 说明
P0 浏览选品、支付(投币/扫码)、出货、找零、取消退款 核心主流程
P1 补货、库存管理、售罄提示、故障报警 运营必备
P2 远程监控、销售报表、动态定价、会员积分 扩展能力

非功能需求才是区分 P6/P7 的地方,记住五条:库存不超卖、付款必须出货或退款(钱货一致)、支付回调可重入(幂等)、支付方式可插拔(扩展性)、设备离线能降级(可用性)。

二、整体架构:端侧保"不出错货",云端保"账对得上"

按"万台设备 + 扫码支付为主 + 少量现金 + 弱网环境"的主流设定,架构分四块:商品/库存、订单/交易、支付、设备履约。

这里有个关键决策很多人讲漏了:设备不直接调业务接口,而是走 IoT 网关长连接。为什么?因为 NAT 穿透、弱网重连、指令必达(QoS)这些,HTTP 短连接根本搞不定。一句话切分职责:

端侧保证"不出错货"(本地状态机 + 本地库存 + 断电自愈),云端保证"账对得上"(对账、补偿、运营)。

三、本题灵魂:状态机设计

自动售货机的本质是一台会收钱的状态机 。投币、选品、出货、退款,每个动作在不同状态下行为完全不同。如果用 if (state == IDLE) ... else if ... 写,状态一多就是面条代码,还会出现"没付钱就出货"这种非法组合,改一处崩一片。

3.1 状态流转图

状态机把"什么状态下能干什么"显式化:非法迁移直接拒绝,系统永远不会处于"薛定谔状态"。

3.2 状态模式落地(面试可直接默写)

java 复制代码
/** 状态接口:default 方法兜住"非法操作",fail-fast */
public interface VendingState {
    default void insertMoney(VendingMachine m, int amount) {
        throw new IllegalStateException("当前状态不允许投币");
    }
    default void selectProduct(VendingMachine m, String code) {
        throw new IllegalStateException("请先投币");
    }
    default void cancel(VendingMachine m) {
        throw new IllegalStateException("当前状态不支持退款");
    }
}

/** 上下文:持有状态引用,行为全部委托给状态对象 */
public class VendingMachine {
    private volatile VendingState state = new IdleState(); // volatile 保证多线程可见性

    public void selectProduct(String code) { state.selectProduct(this, code); }
    public void changeState(VendingState s) { this.state = s; }
}
java 复制代码
/** 已投币态:核心业务逻辑 */
public class HasMoneyState implements VendingState {
    @Override
    public void selectProduct(VendingMachine m, String code) {
        Slot slot = m.getSlot(code);
        if (slot == null || !slot.hasStock()) { m.alert("已售罄,自动退款"); m.refundAll(); return; }
        if (m.getBalance() < slot.getProduct().getPrice()) { m.alert("余额不足"); return; }

        m.deduct(slot.getProduct().getPrice());       // 先扣款
        m.changeState(new DispensingState());
        if (slot.tryDispense()) {                     // CAS 抢库存
            m.dispense(slot.getProduct());            // 触发硬件出货
            m.giveChange();                           // 找零
            m.changeState(slot.hasStock() ? new IdleState() : new SoldOutState());
        } else {
            m.rollback(slot.getProduct().getPrice()); // 出货失败 → 原路回滚退款
            m.changeState(new HasMoneyState());
        }
    }

    @Override
    public void cancel(VendingMachine m) {
        m.refund(m.getBalance());
        m.changeState(new IdleState());
    }
}

技术亮点 :default 方法兜住非法操作 + volatile 状态委托,把状态流转规则收敛到类级别。新增一个"故障态"只需加一个类,不改老代码,完美符合开闭原则。而且每个状态的 on() 方法天然就是一个单测用例。

3.3 进阶:表驱动状态机

如果状态更多、还要可审计可回放,可以把迁移规则配置化------加状态只加一行:

java 复制代码
public enum VmState {
    IDLE, SELECTED, PAYING, DISPENSING, DISPENSED, REFUNDING, FAULT;

    private static final Map<VmState, Map<VmEvent, VmState>> FSM = new EnumMap<>(VmState.class);

    private static void rule(VmState f, VmEvent e, VmState t) {
        FSM.computeIfAbsent(f, k -> new EnumMap<>(VmEvent.class)).put(e, t);
    }
    static {
        rule(IDLE, SELECT, SELECTED);         rule(SELECTED, PAY, PAYING);
        rule(SELECTED, CANCEL, IDLE);         rule(PAYING, PAY_SUCCESS, DISPENSING);
        rule(PAYING, PAY_TIMEOUT, REFUNDING); rule(DISPENSING, DISPATCH_ACK, DISPENSED);
        rule(DISPENSING, DISPATCH_FAIL, REFUNDING);
        for (VmState s : values()) rule(s, HARDWARE_ERROR, FAULT); // 任意状态可熔断
    }
    public VmState transit(VmEvent e) {
        VmState n = FSM.getOrDefault(this, Map.of()).get(e);
        if (n == null) throw new IllegalTransitionException(this + "-" + e + "->?");
        return n;
    }
}

状态特别复杂时,也可以直接上状态机引擎(Spring StateMachine / Cola),不用自己造轮子。

四、并发防超卖:两个人同时买最后一瓶可乐怎么办

这是必考题。答案按部署形态分三档,我给你做成了对比表:

方案 适用场景 优点 缺点
AtomicInteger + CAS 自旋 单机内存库存 无锁、不阻塞、竞争少时性能最好 分布式下失效
DB 条件更新 / 乐观锁 单机数据库、中小并发 实现简单、天然原子 热点行竞争激烈时需重试
Redis Lua 原子预扣 + DB 兜底 分布式、高并发 扛得住洪峰 要处理缓存与 DB 一致性

4.1 单机版:CAS 无锁扣减

java 复制代码
public class Slot {
    private final AtomicInteger stock;   // 库存用原子类

    public boolean tryDispense() {
        while (true) {
            int cur = stock.get();
            if (cur <= 0) return false;              // 已售罄
            if (stock.compareAndSet(cur, cur - 1)) { // 两人抢最后一瓶,只有一人成功
                return true;
            }
        }
    }
}

为什么不用 synchronized? 单机场景两者都行,但 CAS 竞争不激烈时不阻塞线程;更重要的是------分布式部署下 JVM 锁直接失效,养成用 CAS/条件更新的思维才是正解。

4.2 数据库版:一条 SQL 搞定防超卖

不要先查再扣(检查和扣减不是原子的,必超卖),直接把条件写进 SQL,利用 InnoDB 行锁 + 影响行数判断:

java 复制代码
@Update("UPDATE slot SET stock = stock - 1, version = version + 1, gmt_modified = now() " +
        "WHERE id = #{slotId} AND stock > 0 AND version = #{version} AND machine_id = #{machineId}")
int deduct(@Param("slotId") Long slotId,
           @Param("version") Integer version,
           @Param("machineId") Long machineId);
java 复制代码
@Transactional(rollbackFor = Exception.class)
public void deductWithRetry(Long slotId, int qty) {
    for (int i = 0; i < 3; i++) {                 // 自旋重试,吞吐优于悲观锁
        Slot slot = slotMapper.selectById(slotId);
        int rows = slotMapper.deduct(slotId, qty, slot.getVersion());
        if (rows > 0) return;                     // 扣减成功
        log.warn("库存竞争冲突,重试第{}次", i + 1);
    }
    throw new BizException("手速太快,库存被抢光了");
}

踩坑提醒 :不要用 select ... for update 悲观锁扛这个场景,长事务 + 死锁等着你。还有一个细节------库存的真实载体是货道(Slot)而不是 SKU,一台机器同一瓶可乐可能有 6 个货道,扣错粒度直接影响出货逻辑。

4.3 高并发版:预占库存 + Redis Lua

电商化的售货机(手机下单、到店取货)适合"冻结 / 确认"两阶段:

java 复制代码
// 预占:原子 SQL,stock - locked_stock > 0 才允许锁
@Transactional
public boolean lockStock(String slotId, String orderNo) {
    int rows = jdbc.update("""
        UPDATE inventory SET locked_stock = locked_stock + 1
         WHERE slot_id = ? AND stock - locked_stock > 0
        """, slotId);
    if (rows == 0) return false;
    jdbc.update("INSERT INTO stock_lock(slot_id, order_no, status) VALUES (?, ?, 'LOCKED')",
                slotId, orderNo);
    return true;
}

// 支付成功,确认扣减;支付超时,释放预占
@Transactional
public void confirmStock(String slotId, String orderNo) {
    jdbc.update("UPDATE inventory SET stock = stock - 1, locked_stock = locked_stock - 1 WHERE slot_id = ?", slotId);
    jdbc.update("UPDATE stock_lock SET status = 'CONFIRMED' WHERE order_no = ?", orderNo);
}

洪峰流量先打 Redis 扛住,扣减判断 + 执行必须用 Lua 保证原子:

lua 复制代码
-- KEYS[1] = 库存key, ARGV[1] = 扣减数量
local stock = redis.call('GET', KEYS[1])
if not stock or tonumber(stock) < tonumber(ARGV[1]) then
    return -1 -- 库存不足
end
return redis.call('DECRBY', KEYS[1], ARGV[1])

Java 侧调用(Spring Data Redis):

java 复制代码
private final DefaultRedisScript<Long> preDeductScript = new DefaultRedisScript<>(PRE_DEDUCT_LUA, Long.class);

public boolean preDeduct(String machineId, String skuId) {
    String key = "stock:" + machineId + ":" + skuId;
    Long result = redisTemplate.execute(preDeductScript, Collections.singletonList(key), "1");
    return Long.valueOf(1L).equals(result);
}

配套还要记住两个坑:Redis 与 DB 库存可能不一致 (定时对账 + 补货事件重建缓存);爆款商品单 key 热点(分段库存 / 本地缓存 / Sentinel 限流)。

五、支付链路:幂等三件套 + 本地消息表

钱的部分是红线。支付回调可能重复推 N 次、弱网可能丢回调、用户可能重复点------每一环都要幂等。

5.1 核心交易时序

一句话:交易同步,履约异步,设备指令幂等。

5.2 支付回调处理(直接可默写版)

java 复制代码
@Transactional(rollbackFor = Exception.class)
public void onPayCallback(PayNotifyDTO notify) {
    // ① 验签 + 校验金额,防止"付1分钱买iPhone"
    checkAmountAndSign(notify);

    // ② 幂等:支付流水号唯一索引,重复回调直接返回
    int inserted = payNotifyLogMapper.insertIgnore(notify.getTradeNo(), notify.getOrderNo());
    if (inserted == 0) { log.warn("重复回调 tradeNo={}", notify.getTradeNo()); return; }

    // ③ 订单状态 CAS 推进,防止重复流转
    int updated = orderMapper.casStatus(notify.getOrderNo(),
            OrderStatus.WAIT_PAY.name(), OrderStatus.PAID.name());
    if (updated == 0) return;

    // ④ 同事务写本地消息表(Transactional Outbox),保证后续一定尝试出货
    outboxMapper.insert(new OutboxMessage(notify.getOrderNo(), "DISPATCH"));
}

对应的订单状态 CAS:

java 复制代码
@Update("UPDATE vm_order SET status = #{toStatus}, update_time = NOW() " +
        "WHERE order_no = #{orderNo} AND status = #{fromStatus}")
int casStatus(@Param("orderNo") String orderNo,
              @Param("fromStatus") String fromStatus,
              @Param("toStatus") String toStatus);

技术亮点:支付链路三件套------唯一索引防重 + 状态机 CAS + 本地消息表(Transactional Outbox)。支付成功绝不直接同步调设备服务(网络抖动就丢单),而是先落本地消息表再异步投递 MQ,配合每小时对账任务兜底。

另外三个容易丢分的细节:

  • 订单必须存价格快照 price_snapshot,防止前端篡改价格;
  • 下单时发 RocketMQ 延迟消息,15 分钟未支付自动关单释放预占库存;
  • 非法状态流转记日志告警而不是抛异常,避免 MQ 无限重试。

六、出货履约:和"不可靠的硬件"打交道

这题和纯软件设计题最大的区别就在这里:必须假设电机会卡壳、传感器会超时、网络会断、机器会掉电。

6.1 出货指令幂等------绝不重复出货

重试是家常便饭,但不能因为重试让用户拿到两瓶还只付一瓶的钱:

java 复制代码
public void dispatch(Order order) {
    String commandId = "DISPATCH_" + order.getOrderNo();
    if (commandMapper.existsById(commandId)) return;  // 一个订单只生成一条指令
    commandMapper.insert(new Command(commandId, order.getOrderNo(),
            order.getMachineId(), order.getSkuId(), 1));
    mqttClient.publish("vm/" + order.getMachineId() + "/cmd",
            JsonUtil.toJson(command), MqttQos.AT_LEAST_ONCE); // QoS1 至少一次
}

端侧收到指令后,按 (orderId, seq) 去重执行,已 ACK 的重试直接返回成功;出货结果以光电/红外/重力传感器回执为准 ,不轻信电机"转了就算出"。失败链路:超时重试 2 次 → 仍失败进入退款流程 + FAULT 告警 → 运维人工兜底。

硬件层用策略模式抽象掉厂商差异,新增厂商零侵入:

java 复制代码
public interface ActuatorDriver {
    boolean deliver(String machineId, String slot, String cmdNo); // cmdNo=指令幂等号
    MachineHealth health(String machineId);
}

6.2 王炸加分项:WAL + Reconciler 断电自愈

90% 的候选人讲不到这层。售货机是无人值守设备,掉电重启是常态------内存里的状态一掉电就没了:

java 复制代码
public synchronized void fire(long orderId, VmEvent e) {  // 单机串行,天然消竞态
    VmState from = state, to = from.transit(e); // ① 校验合法迁移
    wal.append(orderId, from, e, to);           // ② 先落盘(掉电可回放)
    try { onEnter(orderId, to); state = to; }   // ③ 副作用 ④ 改内存态
    catch (Exception ex) { state = FAULT; throw ex; }  // 熔断,等 Reconciler
}

重启之后,Reconciler 定时扫描未完成订单,不猜、主动查:

java 复制代码
@Scheduled(fixedDelay = 30_000)
public void reconcile() {
    for (Order o : repo.findUnfinished(machineId)) {
        switch (o.state()) {
            // 别只等回调,主动查支付单
            case PAYING -> pay.query(o.payNo())
                    .ifPresent(r -> fire(o.id(), r.paid() ? PAY_SUCCESS : PAY_FAIL));
            // 直接问硬件"你到底出没出货"
            case DISPENSING -> hw.queryCmd(o.id())
                    .ifPresent(a -> fire(o.id(), a.ok() ? DISPATCH_ACK : DISPATCH_FAIL));
            case REFUNDING -> pay.queryRefund(o.payNo()).ifPresent(r -> fire(o.id(), REFUND_DONE));
        }
    }
}

面试官追问"出了货但 ACK 丢了误退款怎么办",标准答案:硬件去重 + Reconciler 主动核实是第一道防线;真有差异靠 T+1 对账生成差异单追损------这是资金系统的标准兜底。

6.3 同一台机器的操作串行化

多终端同时操作同一台机器(用户在买、后台在补货),两种解法:

  • 细粒度锁 :lockKey = "vending:order:" + deviceId,用 Redisson 按设备分片加锁,比全局锁吞吐高一个数量级;
  • MQ 顺序消费(更优) :消息按 machineId 做 shardingKey,同一台机器的事件进同一队列单线程顺序消费,天然串行,不需要分布式锁:
java 复制代码
rocketMQTemplate.syncSendOrderly("DELIVER_TOPIC", msg, machineId);

七、找零算法:贪心够用,但要知道边界

现金场景绕不开找零。零钱库面额 {100, 50, 10, 5, 1}(分),从大到小贪心:

java 复制代码
public List<Integer> giveChange(int change, Map<Integer, Integer> cashBox) {
    List<Integer> result = new ArrayList<>();
    int[] denominations = {100, 50, 10, 5, 1};
    for (int d : denominations) {
        while (change >= d && cashBox.getOrDefault(d, 0) > 0) {
            change -= d;
            cashBox.merge(d, -1, Integer::sum);
            result.add(d);
        }
    }
    if (change != 0) throw new IllegalStateException("零钱不足,需退款或换机");
    return result;
}

两个坑 :① 贪心只对"标准面额体系"能保证最优解,如果面额是 {1,3,4} 找 6 这种非标准组合,要改动态规划;② 下单前就要校验硬币箱余额并冻结,找不开就直接拒绝现金支付、引导扫码,别等付完钱才发现找不开。

八、工程化加分项:从"能跑"到"工业级"

讲完主链路,这些点随便抛出两三个,面试官就知道你是真干过活的:

补货预警(观察者模式):库存低于安全阈值触发事件,推送告警给运营;再配上 XXL-Job 定时扫描生成补货路线任务。补货动作本身要走补货单 + 操作流水 + 审计日志,防止误操作把库存搞乱。

离线售卖(90% 的人答不出来):

text 复制代码
在线正常:云端下单 → 云端扣库存 → 出货
弱网/断网:终端本地下单 → 本地 SQLite 扣库存 → 出货 → 网络恢复后 outbox 异步上报对账

风险是同一张会员卡离线时在 A 机刷完又去 B 机刷,余额透支。解法是离线额度(offline quota):允许离线透支比如 20 元,云端记录已发放额度,上线后核销------跟信用卡离线交易一个思路,典型的信用额度模型。

海量设备的心跳洪峰:10 万台设备的心跳和遥测不能直接打 MySQL。IoT 网关聚合心跳、只上报变化,指标进时序库(TDengine/InfluxDB),MySQL 只存告警和结论。

资金对账 :T+1 拉取三方支付账单与本地订单双向比对,差异入差错表人工处理;卡货率、出货超时率设监控告警。

可观测性 :每笔交易打全链路 traceId,从设备端就开始带入,一次购买的所有日志(支付、扣库存、出货、退款)可串联,定位线上问题效率翻倍。

要不要上分布式事务? ------ 不上。订单和库存同库走本地事务,支付靠回调幂等 + 补偿,这是经典的"本地事务 + 最终一致性",比 Seata 简单可靠得多。

怎么压测? 设备模拟器按真实购买曲线发 MQTT 报文,重点压两个场景:支付回调洪峰 和断电恢复后的补报洪峰,看补偿队列会不会堆积。

分库分表? 按 device_id 分片(查询大多围绕设备),跨设备报表走数仓/ES。

九、技术难点速查表(收藏这一张就够了)

# 难点 解决方案 关键词
1 状态混乱、非法流转 状态模式 / 表驱动状态机,非法迁移 fail-fast 开闭原则
2 并发超卖 CAS / stock>0 条件更新 / Redis Lua 预扣 原子操作
3 支付回调重复 流水号唯一索引 + 状态 CAS + 幂等表 幂等
4 付钱不出货 本地消息表 + MQ + 超时补偿扫描 + 自动退款 最终一致
5 重复出货 唯一 command_id + 设备端 (orderId,seq) 去重 + 传感器复核 指令幂等
6 硬件不可靠(卡货/不回包) MQTT QoS1 + 超时重试 + FAULT 熔断 + 告警人工兜底 软硬件协同
7 断电重启丢状态 WAL 先落盘 + Reconciler 主动查单自愈 可回放
8 单机并发冲突 按 deviceId 细粒度锁 / MQ 顺序消费 串行化
9 找零不足 贪心算法 + 下单前冻结校验硬币余额 预校验
10 弱网/离线售卖 本地库存 + 离线额度 + 上线后对账 边缘自治
11 心跳洪峰 IoT 网关聚合 + 时序库 读写分离
12 资金差错 T+1 三方对账 + 差错表 对账兜底

十、面试收尾:话术与评分阶梯

收尾话术建议背下来:

"总结一下,这个系统我抓了三个核心:状态 ------用状态机管住售货机生命周期,杜绝非法流转;钱和货 ------支付幂等 + 库存原子扣减 + 本地消息表 + 对账,保证资金与实物最终一致;硬件容错------指令幂等 + 传感器确认 + WAL 断电自愈,把'失败'变成可观测、可补偿、可退款的闭环。规模再上一个量级,我会把设备接入层独立成 IoT 网关,业务侧做单元化部署。"

如果面试官追问"管 10 万台机器呢":每台机器作为 IoT 终端经 MQTT 上报库存/故障,云端 Kafka 削峰 + Flink 实时统计热销商品,热门商品 Redis 预扣库存防云端超卖。

最后送你一张得分阶梯自测:

等级 表现
🥉 及格 画出类图,流程能跑通
🥈 良好 主动用状态模式,说出开闭原则、防超卖
🥇 优秀 讲清支付幂等、出货补偿、MQ 顺序消费、硬件防御
🏆 满分 聊到离线额度、WAL 断电自愈、对账体系,并能说清"为什么不上分布式事务"

最后说两句 :场景设计题考的本质不是"写出这台机器",而是你能不能预判系统会在哪里出问题。超卖、掉单、状态错乱、断电丢账------把异常链路讲清楚的人,才是面试官想招的人。建议把上面第九节的速查表收藏起来,面试前过一遍;真动手练的话,优先把"状态机 + 库存扣减 + 支付回调幂等"这三块代码敲一遍,性价比最高。

你在面试里被问过最刁钻的场景设计题是什么?是秒杀、短链还是这种软硬件结合的?评论区聊聊,点赞过 500 我就把这个状态机写成可运行的 Spring Boot 工程骨架(含单测)放出来。

相关推荐
挖掘狂人9 分钟前
飞书群聊已读,是怎么实现的?
java·程序员·架构
不一样的少年_1 小时前
用了这 Skill,前端兄弟都觉得好
前端·后端·ai编程
卷无止境1 小时前
Python 开发中的资源管理:统一生命周期,保留资源差异
后端·python
吴名氏.2 小时前
Java转AI Agent教程(第十五周)政策时效:过期政策不该被召回,也不能被删掉
java·人工智能·python·ai·ai agent
一条Go2 小时前
Kubernetes 多集群接入:kubeconfig 只进不出
后端·架构·github
文丑颜不良啊11 小时前
LeetCode2981~3000题目解析
java·leetcode
怕浪猫12 小时前
全球 3D 网络地球的实时通信节点,来看看这四种交互地球,满足你对物理互联网的所有好奇
面试·架构·github
nice_lcj52013 小时前
【从零理解 Spring AI · 13】RAG 要解决什么:把“闭卷考试“变成“开卷“
java·spring·检索增强·rag·spring ai·ai应用开发