实战③：核心业务实现（事务、库存与幂等）

package com.beeorder.order.controller;@RestController@RequestMapping("/api/v1/orders")public class OrderController {    private final OrderService orderService;    public OrderController(OrderService orderService) {        this.orderService = orderService;          // 构造器注入，依赖不可变    }    @PostMapping    public Result<OrderVO> create(@RequestHeader("X-Idempotency-Key") String idempotentKey,                                  @Valid @RequestBody CreateOrderRequest req) {        Long userId = JwtUtil.currentUserId();     // 从 JWT 取，绝不信任前端传入的 userId        req.setIdempotentKey(idempotentKey);       // 幂等键统一由 Header 提供        return Result.ok(orderService.create(userId, req));    }}

package com.beeorder.order.service;@Servicepublic class OrderService {    private final OrderMapper orderMapper;    private final OrderItemMapper orderItemMapper;    private final ProductMapper productMapper;    private final InventoryService inventoryService;    public OrderService(OrderMapper orderMapper, OrderItemMapper orderItemMapper,                        ProductMapper productMapper, InventoryService inventoryService) {        this.orderMapper = orderMapper;        this.orderItemMapper = orderItemMapper;        this.productMapper = productMapper;        this.inventoryService = inventoryService;    }    @Transactional(rollbackFor = Exception.class)      // 见第三节：任何异常都要回滚    public OrderVO create(Long userId, CreateOrderRequest req) {        // 1) 幂等前置检查：快路径，命中直接返回首次结果        Order exist = orderMapper.selectByUserIdAndIdemKey(userId, req.getIdempotentKey());        if (exist != null) {            return assembleVO(exist);        }        // 2) 校验商品 + 计算金额（BigDecimal，逐项累加）        BigDecimal total = BigDecimal.ZERO;        List<OrderItem> items = new ArrayList<>();        for (CreateOrderRequest.Item i : req.getItems()) {            Product p = productMapper.selectOnShelf(i.getProductId());            if (p == null) {                throw new BizException(ErrorCode.ORDER_STATUS_ILLEGAL, "商品不存在或已下架");            }            BigDecimal amount = p.getPrice().multiply(BigDecimal.valueOf(i.getQuantity()));            total = total.add(amount);            items.add(OrderItem.snapshotOf(p, i.getQuantity(), amount));   // 价格快照        }        // 3) 落库订单（状态 CREATED）+ 订单项        Order order = Order.created(userId, req, total);        orderMapper.insert(order);                    // 唯一键 uk_order_idem 兜底防重        items.forEach(it -> it.setOrderId(order.getId()));        orderItemMapper.batchInsert(items);        // 4) 扣减库存（同事务内，条件更新防超卖）+ 写流水        for (OrderItem it : items) {            inventoryService.lock(it.getProductId(), it.getQuantity(), order.getId());        }        return assembleVO(order);    }}

@Transactional(        rollbackFor = Exception.class,   // ② 连受检异常也回滚        timeout = 3,                     // ③ 超时 3 秒，防止慢查询长时间持锁        isolation = Isolation.READ_COMMITTED)public OrderVO create(Long userId, CreateOrderRequest req) { ... }

-- 必须在事务内，FOR UPDATE 会持有行锁直到事务结束SELECT available, locked FROM inventory WHERE product_id = #{productId} FOR UPDATE;-- 应用层判断 available >= n，再执行 UPDATEUPDATE inventory SET available = available - #{n}, locked = locked + #{n} WHERE product_id = #{productId};

<update id="lockStock">  UPDATE inventory     SET available   = available - #{quantity},   <!-- 可售减少 -->         locked      = locked    + #{quantity},   <!-- 锁定增加 -->         version     = version   + 1,         update_time = NOW(3)   WHERE product_id = #{productId}     AND available  >= #{quantity}                <!-- 防超卖的关键条件 --></update>

Long productId, int quantity; // 调用方传入int rows = inventoryMapper.lockStock(productId, quantity);if (rows == 0) {                                  // 影响行数为 0 = 条件未命中    throw new BizException(ErrorCode.STOCK_NOT_ENOUGH);   // 1001 库存不足}

-- KEYS[1] = stock:{productId}，ARGV[1] = 购买数量local stock = tonumber(redis.call('GET', KEYS[1]))if stock == nil or stock < tonumber(ARGV[1]) then  return -1                       -- 库存不足endredis.call('DECRBY', KEYS[1], tonumber(ARGV[1]))return stock - tonumber(ARGV[1])  -- 返回剩余库存

try {    orderMapper.insert(order);} catch (DuplicateKeyException e) {    // 唯一键冲突 = 并发重复提交：查出首次结果返回，不再继续扣库存    Order exist = orderMapper.selectByUserIdAndIdemKey(userId, req.getIdempotentKey());    log.info("重复下单，返回首次结果 orderNo={}", exist.getOrderNo());    return assembleVO(exist);}

package com.beeorder.payment.controller;@RestController@RequestMapping("/api/v1/payments")public class PaymentController {    private final PaymentService paymentService;    public PaymentController(PaymentService paymentService) {        this.paymentService = paymentService;    }    /** 网关异步回调：不验 JWT，但要验签 + 幂等 */    @PostMapping("/callback")    public Result<Void> callback(@RequestBody PayCallbackDTO dto) {        paymentService.verifySign(dto);        // ① 验签：签名或金额不符直接抛 2002        paymentService.handleCallback(dto);    // ② 幂等 + 状态机        return Result.ok(null);                // ③ 固定成功应答，让网关别再重发    }}

@Transactional(rollbackFor = Exception.class)public void handleCallback(PayCallbackDTO dto) {    Payment pay = paymentMapper.selectByTradeNo(dto.getTradeNo());    if (pay != null && PayStatus.SUCCESS.name().equals(pay.getStatus())) {        log.info("重复支付回调，已忽略 tradeNo={}", dto.getTradeNo());        return;                                        // 第一道：已成功，幂等返回    }    // 第二道：条件更新，只有 CREATED 才能转 PAID    int rows = orderMapper.updateStatus(dto.getOrderId(), OrderStatus.CREATED, OrderStatus.PAID);    if (rows == 0) {        log.warn("订单状态不允许支付，忽略 orderId={}", dto.getOrderId());        return;                                        // 已关闭或已支付，忽略    }    paymentMapper.markSuccess(dto.getTradeNo());       // trade_no 唯一键兜底    inventoryService.commitLocked(dto.getOrderId());   // 锁定库存转实扣}

@Componentpublic class OrderCloseJob {    @Scheduled(fixedDelay = 60_000)                    // 每分钟扫一次    public void closeExpired() {        if (!redisLock.tryLock("beeorder:job:close-order", 55, TimeUnit.SECONDS)) {            return;                                    // 多实例只有一个抢到锁        }        try {            // 扫描状态为 CREATED 且已过 expire_time 的订单（走 idx_order_status_expire）            List<Long> ids = orderMapper.selectExpiredIds(                    OrderStatus.CREATED, LocalDateTime.now(ZoneOffset.UTC), 200);            ids.forEach(orderService::close);        } finally {            redisLock.unlock("beeorder:job:close-order");        }    }}

@Transactional(rollbackFor = Exception.class)public void close(Long orderId) {    // 条件更新：只有 CREATED 才能关单，天然防止与支付回调并发重复处理    int rows = orderMapper.updateStatus(orderId, OrderStatus.CREATED, OrderStatus.CLOSED);    if (rows == 0) {        return;                                        // 已被支付或已关闭，跳过    }    for (OrderItem it : orderItemMapper.selectByOrderId(orderId)) {        inventoryService.release(it.getProductId(), it.getQuantity(), orderId);  // 锁定 → 可售    }}

@Servicepublic class ProductService {    /** 商品详情：读多写少，缓存 10 分钟；缓存的是 VO，不是 Entity */    @Cacheable(cacheNames = "product:detail", key = "#id", sync = true)    public ProductVO detail(Long id) {        Product p = productMapper.selectOnShelf(id);        return p == null ? null : ProductConverter.toVO(p);    }    /** 商品编辑：先写库，再主动删缓存，避免脏读 */    @CacheEvict(cacheNames = "product:detail", key = "#id")    public void update(Long id, ProductUpdateDTO dto) {        productMapper.update(id, dto);    }}

docker run -d --name bee-mysql -p 3306:3306 \  -e MYSQL_ROOT_PASSWORD=bee -e MYSQL_DATABASE=beeorder mysql:8.0

CREATE TABLE inventory (  product_id BIGINT       NOT NULL PRIMARY KEY,  available  INT UNSIGNED NOT NULL,           -- UNSIGNED 让负数成为第二道保险  version    INT          NOT NULL DEFAULT 0);INSERT INTO inventory (product_id, available) VALUES (2001, 3);

package com.example.stock;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.jdbc.core.JdbcTemplate;import java.util.concurrent.*;import java.util.concurrent.atomic.AtomicInteger;@SpringBootApplicationpublic class StockApp {    public static void main(String[] args) throws Exception {        var ctx = SpringApplication.run(StockApp.class, args);        JdbcTemplate jdbc = ctx.getBean(JdbcTemplate.class);        int threads = 10;                       // 10 个并发请求抢 3 件货        var ready = new CountDownLatch(threads);        var gun = new CountDownLatch(1);        // 发令枪：真正把并发压到同一瞬间        var ok = new AtomicInteger();        var pool = Executors.newFixedThreadPool(threads);        for (int i = 0; i < threads; i++) {            pool.submit(() -> {                try {                    ready.countDown();                    gun.await();                    // 关键：判断与扣减写在同一条 SQL 里                    int rows = jdbc.update(                        "UPDATE inventory SET available = available - 1, version = version + 1 " +                        " WHERE product_id = 2001 AND available >= 1");                    if (rows == 1) ok.incrementAndGet();     // 抢到了                    else System.out.println("库存不足，拒绝下单");                } catch (InterruptedException e) {                    Thread.currentThread().interrupt();                }            });        }        ready.await();        gun.countDown();        pool.shutdown();        pool.awaitTermination(10, TimeUnit.SECONDS);        Integer remain = jdbc.queryForObject(            "SELECT available FROM inventory WHERE product_id = 2001", Integer.class);        System.out.println("成功=" + ok.get() + " 剩余库存=" + remain);        ctx.close();    }}

mvn -q compile exec:java -Dexec.mainClass=com.example.stock.StockApp

库存不足，拒绝下单库存不足，拒绝下单库存不足，拒绝下单库存不足，拒绝下单库存不足，拒绝下单库存不足，拒绝下单库存不足，拒绝下单成功=3 剩余库存=0