Codex 落地实战：用 AI 智能体攻克高并发接口与算法优化痛点

技术栈：Java SpringBoot2.7 + RedisTemplate + RabbitMQ + MySQL8
业务：商品秒杀库存扣减高并发接口
硬性约束：
1. 使用Redisson分布式锁防止超卖；
2. Redis预存库存做热点缓存，禁止频繁查库；
3. 单用户ID限制只可购买1次；
4. 锁必须设置过期时间，避免死锁；
5. 扣减缓存库存后通过MQ异步同步数据库；
6. 接口入参：商品ID、用户ID；出参：状态码、订单编号、提示信息；
7. 捕获所有Redis、MQ、数据库异常，增加降级返回；
要求输出完整Controller、Service层核心逻辑，注释清晰，可直接导入项目运行

@RestController
@RequestMapping("/seckill")
public class SeckillController {

    @Autowired
    private SeckillService seckillService;

    /**
     * 秒杀下单接口
     * @param productId 商品ID
     * @param userId 用户ID
     * @return 秒杀结果
     */
    @PostMapping("/do")
    public Result<SeckillVO> doSeckill(@RequestParam Long productId,
                                       @RequestParam Long userId) {
        if (productId == null || userId == null) {
            return Result.fail("参数不能为空");
        }
        SeckillVO vo = seckillService.seckillOrder(productId, userId);
        return Result.success(vo);
    }
}

@Service
public class SeckillServiceImpl implements SeckillService {

    @Autowired
    private RedissonClient redissonClient;
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Autowired
    private ProductMapper productMapper;

    private static final String LOCK_PREFIX = "seckill:lock:";
    private static final String STOCK_PREFIX = "seckill:stock:";
    private static final String USER_RECORD = "seckill:user:";
    private static final long LOCK_WAIT_TIME = 3;
    private static final long LOCK_EXPIRE_TIME = 10;

    @Override
    public SeckillVO seckillOrder(Long productId, Long userId) {
        String lockKey = LOCK_PREFIX + productId;
        RLock lock = redissonClient.getLock(lockKey);
        SeckillVO vo = new SeckillVO();
        try {
            boolean acquire = lock.tryLock(LOCK_WAIT_TIME, LOCK_EXPIRE_TIME, TimeUnit.SECONDS);
            if (!acquire) {
                vo.setStatus(0);
                vo.setMsg("当前抢购人数过多，请稍后重试");
                return vo;
            }
            // 判断用户是否已购买
            Boolean hasBuy = redisTemplate.hasKey(USER_RECORD + productId + ":" + userId);
            if (Boolean.TRUE.equals(hasBuy)) {
                vo.setStatus(0);
                vo.setMsg("每位用户限购一件，不可重复抢购");
                return vo;
            }
            // 查询缓存库存
            Integer stock = (Integer) redisTemplate.opsForValue().get(STOCK_PREFIX + productId);
            if (stock == null || stock <= 0) {
                vo.setStatus(0);
                vo.setMsg("商品已抢完");
                return vo;
            }
            // 缓存库存扣减
            redisTemplate.opsForValue().decrement(STOCK_PREFIX + productId);
            // 标记用户已下单
            redisTemplate.opsForValue().set(USER_RECORD + productId + ":" + userId, 1, 24, TimeUnit.HOURS);
            // 发送MQ异步落库
            SeckillMessage message = new SeckillMessage();
            message.setProductId(productId);
            message.setUserId(userId);
            rabbitTemplate.convertAndSend("seckill.exchange", "seckill.order", message);
            vo.setStatus(1);
            vo.setMsg("抢购成功，请等待订单生成");
            vo.setOrderNo(UUID.randomUUID().toString().replace("-",""));
        } catch (Exception e) {
            vo.setStatus(0);
            vo.setMsg("抢购异常，请重试");
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
        return vo;
    }
}

// Lua脚本原子扣减库存，返回扣减后剩余库存
String luaScript = """
local stockKey = KEYS[1]
local userKey = KEYS[2]
local stock = tonumber(redis.call('get', stockKey) or 0)
local hasUser = redis.call('exists', userKey)
if hasUser == 1 then
    return -2 -- 用户已限购
end
if stock <= 0 then
    return -1 -- 无库存
end
local newStock = stock - 1
redis.call('set', stockKey, newStock)
redis.call('set', userKey, 1, 'EX', 86400)
return newStock
""";
List<Object> keys = Arrays.asList(STOCK_PREFIX + productId, USER_RECORD + productId + ":" + userId);
Long result = redisTemplate.execute(new DefaultRedisScript<>(luaScript, Long.class), keys);

// 每次下单成功，ZSet分值+1
public void addHeatScore(Long productId) {
    String heatKey = "seckill:heat:24h";
    redisTemplate.opsForZSet().incrementScore(heatKey, productId, 1);
    // 设置24小时过期，自动淘汰旧数据
    redisTemplate.expire(heatKey, 24, TimeUnit.HOURS);
}

// 查询Top10热门商品
public List<Long> getTopHeatProduct() {
    String heatKey = "seckill:heat:24h";
    Set<Object> topSet = redisTemplate.opsForZSet().reverseRange(heatKey, 0, 9);
    return topSet.stream().map(o -> Long.valueOf(o.toString())).collect(Collectors.toList());
}