分布式锁与接口幂等：同一笔扣款 200 毫秒内到了三次

请求一 → 实例 A：拿到 A 的 JVM 锁 → 查余额 1000，通过，扣款
请求二 → 实例 B：拿到 B 的 JVM 锁 → 查余额 1000，也通过，扣款
两台机器各扣一次：synchronized 是进程内的锁，锁不住别人的进程

docker run -d --name redis -p 6379:6379 redis:7

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>  <!-- 3.x，版本以官方仓库为准 -->
</dependency>

UPDATE orders SET status = 'PAID' WHERE id = 1001 AND status = 'UNPAID';
-- Query OK, 1 row affected      ← 第一次：待支付 → 已支付
UPDATE orders SET status = 'PAID' WHERE id = 1001 AND status = 'UNPAID';
-- Query OK, 0 rows affected     ← 第二次：前置状态不满足，空操作

CREATE TABLE payment_record (
  id         BIGINT PRIMARY KEY AUTO_INCREMENT,
  biz_no     VARCHAR(64)   NOT NULL COMMENT '业务号：请求号或业务自然键',
  user_id    BIGINT        NOT NULL,
  amount     DECIMAL(10,2) NOT NULL,
  status     TINYINT       NOT NULL COMMENT '0 处理中 1 成功 2 失败',
  created_at DATETIME      NOT NULL,
  UNIQUE KEY uk_biz_no (biz_no)
) COMMENT = '扣款流水：唯一索引即去重裁判';

@Transactional
public PayResult pay(PayRequest req) {
    try {
        paymentMapper.insert(PendingRecord.of(req.getBizNo(), req));   // 先抢号
    } catch (DuplicateKeyException e) {
        return paymentMapper.findByBizNo(req.getBizNo()).toResult();   // 重复：返回上次结果
    }
    return doDeduct(req);                                              // 新请求：真扣款
}

Boolean ok = redis.opsForValue().setIfAbsent(key, "1");   // 第一步：占锁
if (Boolean.TRUE.equals(ok)) {
    redis.expire(key, Duration.ofSeconds(30));            // 第二步：设过期
    // 若两步之间进程宕机：锁已占上且永不过期，所有竞争者永久等待
}

SET order:lock:1001 8f3a9c2b NX EX 30

private static final String UNLOCK_LUA = """
    if redis.call('GET', KEYS[1]) == ARGV[1] then
        return redis.call('DEL', KEYS[1])
    else
        return 0
    end""";

public void unlock(String key, String holder) {
    redis.execute(new DefaultRedisScript<>(UNLOCK_LUA, Long.class), List.of(key), holder);
}

RLock lock = redissonClient.getLock("order:lock:1001");
lock.lock();                              // 阻塞直到拿到；不指定 leaseTime，看门狗生效
try {
    doBusiness();
} finally {
    if (lock.isHeldByCurrentThread()) {
        lock.unlock();                    // 只解自己持有的锁，与坑二同源
    }
}

boolean acquired = lock.tryLock(3, 30, TimeUnit.SECONDS);
//                       |   |
//                       |   └─ leaseTime：持锁 30 秒后自动释放，看门狗关闭
//                       └─ waitTime：最多等 3 秒，拿不到立即返回 false
if (!acquired) {
    throw new BizException("当前下单人数过多，请稍后再试");
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Idempotent {
    String key();                       // spEL 表达式：怎么取业务键
    long ttlSeconds() default 600;      // 判重窗口
}

@Aspect
@Component
public class IdempotentAspect {

    private final StringRedisTemplate redis;
    private final SpelExpressionParser parser = new SpelExpressionParser();
    private final DefaultParameterNameDiscoverer discoverer = new DefaultParameterNameDiscoverer();

    public IdempotentAspect(StringRedisTemplate redis) {
        this.redis = redis;
    }

    @Around("@annotation(idempotent)")
    public Object around(ProceedingJoinPoint pjp, Idempotent idempotent) throws Throwable {
        String bizKey = "idem:" + resolveKey(pjp, idempotent.key());
        Boolean first = redis.opsForValue()
                .setIfAbsent(bizKey, "1", Duration.ofSeconds(idempotent.ttlSeconds()));
        if (Boolean.FALSE.equals(first)) {
            throw new BizException("请勿重复提交");        // 重复请求拦在业务之前
        }
        return pjp.proceed();
    }

    private String resolveKey(ProceedingJoinPoint pjp, String spel) throws IllegalAccessException {
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        String[] names = discoverer.getParameterNames(signature.getMethod());
        EvaluationContext context = new StandardEvaluationContext();
        Object[] args = pjp.getArgs();
        for (int i = 0; i < args.length; i++) {
            context.setVariable(names[i], args[i]);        // 参数名映射为 spEL 变量
        }
        return parser.parseExpression(spel).getValue(context, String.class);
    }
}

@PostMapping("/pay")
@Idempotent(key = "#req.requestId")
public PayResult pay(@RequestBody PayRequest req) {
    return paymentService.pay(req);
}

curl -s http://localhost:8081/lock-demo & curl -s http://localhost:8082/lock-demo &

{"instance":8081,"msg":"拿到锁，干活中"}      ← 一边立刻返回
（等待约 5 秒）
{"instance":8082,"msg":"拿到锁，干活中"}      ← 另一边等锁释放后才拿到

curl -s -X POST localhost:8081/pay -H "Content-Type: application/json" \
     -d '{"requestId":"R-1","amount":100}'
curl -s -X POST localhost:8081/pay -H "Content-Type: application/json" \
     -d '{"requestId":"R-1","amount":100}'

{"orderNo":"20261003001","status":"SUCCESS"}
{"code":409,"message":"请勿重复提交"}          ← 第二发被 AOP 拦下