"来,设计一个自动售货机系统。"
这题我在面人和被面的时候都遇到过,看似送分,实则是场景设计题里的"隐形杀手"------大部分人上来就 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 工程骨架(含单测)放出来。