#双十一秒杀架构

// 秒杀网关：五层拦截 + 热点探测
@Service
public class SeckillGateway {

    @Autowired private ActivityService activityService;
    @Autowired private HotspotService hotspotService;
    @Autowired private RateLimiter rateLimiter;

    public SeckillResponse handleSeckill(SeckillRequest request) {
        Long productId = request.getProductId();
        Long userId = request.getUserId();

        // === 第一层：活动有效性检查 ===
        ActivityStatus status = activityService.getStatus(productId);
        if (status == ActivityStatus.NOT_STARTED) {
            return SeckillResponse.notStarted();
        }
        if (status == ActivityStatus.ENDED) {
            return SeckillResponse.ended();
        }

        // === 第二层：热点商品识别 ===
        // 热点商品走独立通道，降低对普通商品的影响
        boolean isHotProduct = hotspotService.isHotProduct(productId);
        if (isHotProduct) {
            // 热点商品：更严格的限流
            if (!rateLimiter.tryAcquire("hot:" + productId, 1000)) {
                return SeckillResponse.rateLimited();
            }
        }

        // === 第三层：用户频率控制 ===
        // 同一用户在当前活动期间最多抢购 N 次
        String userKey = "seckill:user:" + productId + ":" + userId;
        if (redisTemplate.hasKey(userKey)) {
            return SeckillResponse.alreadyPurchased();
        }

        // === 第四层：黑名单过滤 ===
        if (blacklistService.isBlocked(userId, request.getIp())) {
            return SeckillResponse.blocked();
        }

        // === 第五层：库存预扣减 ===
        return stockService.preDeduct(productId, userId);
    }
}

// 库存服务：Lua 脚本保证原子性
@Service
public class StockService {

    private static final String DEDUCT_STOCK_LUA = """
        local stock_key = KEYS[1]
        local user_key = KEYS[2]
        local quantity = tonumber(ARGV[1])

        -- 检查库存
        local stock = tonumber(redis.call('GET', stock_key) or 0)
        if stock < quantity then
            return -1  -- 库存不足
        end

        -- 扣减库存
        redis.call('DECRBY', stock_key, quantity)

        -- 记录用户购买标记（防止重复抢购）
        redis.call('SET', user_key, '1', 'EX', 86400)

        return 1  -- 成功
        """;

    public boolean deductStock(Long productId, Long userId, int quantity) {
        String stockKey = "seckill:stock:" + productId;
        String userKey = "seckill:user:" + productId + ":" + userId;

        RedisScript<Long> script = new RedisScript<>(DEDUCT_STOCK_LUA, Long.class);
        Long result = redisTemplate.execute(script,
            List.of(stockKey, userKey),
            String.valueOf(quantity));

        return Objects.equals(result, 1L);
    }
}

// 订单分库分表：根据 userId 分散到 16 个库，每库 16 张表
@Component
public class OrderShardingRouter {

    public String getShardKey(Long userId) {
        // 取模分散到不同分片
        return String.valueOf(userId % 256);
    }

    public String getTableName(Long orderId) {
        // 按时间分表：t_order_20231111
        LocalDate date = LocalDate.now();
        return String.format("t_order_%tY%tm%td", date, date, date);
    }
}

// 热点探测服务：基于 Redis 滑动窗口统计
@Service
public class HotspotService {

    @Autowired private RedisTemplate<String, String> redisTemplate;

    // 热点阈值：10 秒内访问量超过 10 万次
    private static final int HOT_THRESHOLD = 100_000;
    private static final int WINDOW_SIZE_SECONDS = 10;

    public boolean isHotProduct(Long productId) {
        String key = "hotspot:counter:" + productId;

        // 使用 Redis Sorted Set 实现滑动窗口
        long now = System.currentTimeMillis();
        long windowStart = now - WINDOW_SIZE_SECONDS * 1000;

        // 删除窗口外的旧数据
        redisTemplate.opsForZSet().removeRangeByScore(key, 0, windowStart);

        // 添加当前请求
        redisTemplate.opsForZSet().add(key, String.valueOf(now), now);

        // 统计窗口内的请求数
        Long count = redisTemplate.opsForZSet().zCard(key);

        if (count != null && count > HOT_THRESHOLD) {
            // 标记为热点商品
            redisTemplate.opsForValue().set(
                "hotspot:product:" + productId,
                "true",
                Duration.ofMinutes(5));
            return true;
        }

        return Boolean.parseBoolean(
            redisTemplate.opsForValue().get("hotspot:product:" + productId));
    }
}

// 订单服务：MQ 异步创建订单
@Service
public class OrderService {

    @Autowired private RocketMQTemplate rocketMQTemplate;

    public void sendOrderCreateRequest(SeckillOrderRequest request) {
        // 发送到消息队列，异步处理
        // 峰值时每秒可能发送数万条消息
        rocketMQTemplate.asyncSend("order:create:seckill",
            request,
            new SendCallback() {
                @Override
                public void onSuccess(SendResult sendResult) {
                    // 发送成功，更新本地状态
                    log.info("订单消息发送成功: orderId={}", request.getOrderId());
                }

                @Override
                public void onException(Throwable e) {
                    // 发送失败，触发告警
                    alertService.alert("OrderCreateFailed", request);
                }
            });
    }

    @KafkaListener(topics = "order:create:seckill",
        groupId = "order-consumer-group",
        concurrency = "16")
    public void consumeOrderCreate(Message message) {
        SeckillOrderRequest request = deserialize(message);

        // 创建订单（慢操作，约 50-100ms）
        Order order = orderRepository.save(request.toOrder());

        // 更新用户购买状态
        redisTemplate.opsForValue().set(
            "order:status:" + order.getOrderId(),
            "CREATED",
            Duration.ofHours(24));
    }
}

// 熔断器配置：Sentinel
@Configuration
public class SentinelConfig {

    @Bean
    public SentinelResourceAspect sentinelAspect() {
        return new SentinelResourceAspect();
    }
}

// 熔断注解：秒杀接口
@RestController
@RequestMapping("/seckill")
public class SeckillController {

    @GetMapping("/buy/{productId}")
    @SentinelResource(value = "seckill:buy",
        blockHandler = "seckillBlockHandler",
        fallback = "seckillFallback")
    public SeckillResult buy(
            @PathVariable Long productId,
            @RequestParam Long userId) {
        return seckillService.buy(productId, userId);
    }

    // 限流/熔断时的处理
    public SeckillResult seckillBlockHandler(Long productId, Long userId,
            BlockException ex) {
        if (ex instanceof FlowException) {
            return SeckillResult.rateLimited("访问过于频繁，请稍后重试");
        }
        if (ex instanceof DegradeException) {
            return SeckillResult.degraded("系统繁忙，请稍后重试");
        }
        return SeckillResult.error("系统异常");
    }
}