电商微服务架构

单体痛点：
- 代码库 100万+ 行，构建时间 30分钟+
- 小改动需要全量发布
- 库存高峰拖垮整个系统

微服务收益：
- 订单服务独立扩容应对大促
- 商品服务静态化 + CDN 加速
- 库存服务 Redis 抗高并发

✅ 合理拆分：
- user-service（用户）
- product-service（商品）
- order-service（订单）
- payment-service（支付）
- inventory-service（库存）
- promotion-service（促销）

❌ 过度拆分：
- user-profile-service
- user-address-service
- user-coupon-service
（应该合并为 user-service）

// 同步调用 - Feign 客户端
@FeignClient(name = "inventory-service")
public interface InventoryClient {
    @PostMapping("/inventory/deduct")
    Result<Boolean> deduct(@RequestBody DeductRequest request);
}

// 异步消息 - RocketMQ
@RocketMQMessageListener(topic = "order-paid", consumerGroup = "inventory-consumer")
public class InventoryConsumer implements RocketMQListener<OrderPaidEvent> {
    @Override
    public void onMessage(OrderPaidEvent event) {
        // 异步扣减库存
    }
}

核心链路（强一致性）：TCC
- Try：预留库存、预扣余额
- Confirm：确认扣减
- Cancel：释放预留

非核心链路（最终一致）：RocketMQ事务消息
- 订单创建成功发送消息
- 积分服务消费增加积分

@Component
public class InventoryTccAction {
    
    // Try：预留资源
    @Transactional
    public boolean tryDeduct(String xid, Long productId, Integer count) {
        // 1. 检查库存
        // 2. 扣减可售库存
        // 3. 增加冻结库存
        // 4. 记录事务日志
    }
    
    // Confirm：确认执行
    @Transactional
    public boolean confirm(String xid) {
        // 1. 删除事务日志
        // 2. 扣减冻结库存（实际扣减）
    }
    
    // Cancel：取消回滚
    @Transactional
    public boolean cancel(String xid) {
        // 1. 查询事务日志
        // 2. 恢复可售库存
        // 3. 扣减冻结库存
        // 4. 删除事务日志
    }
}

┌─────────────────────────────────────────┐
│  前端层                                  │
│  - 静态页面 CDN                          │
│  - 秒杀按钮置灰/倒计时                    │
│  - 验证码/滑块防刷                        │
└─────────────────────────────────────────┘
                   │
┌─────────────────────────────────────────┐
│  网关层                                  │
│  - Nginx 限流（漏桶算法）                 │
│  - Sentinel 热点参数限流                  │
│  - 黑名单过滤                             │
└─────────────────────────────────────────┘
                   │
┌─────────────────────────────────────────┐
│  应用层                                  │
│  - 令牌桶限流（Redis List）               │
│  - 库存预热（Redis）                      │
│  - Lua 原子扣减                          │
│  - 异步下单（RocketMQ）                   │
└─────────────────────────────────────────┘
                   │
┌─────────────────────────────────────────┐
│  数据层                                  │
│  - 库存分片（多 Redis 节点）              │
│  - 写保护（限流 + 队列）                  │
└─────────────────────────────────────────┘

-- Redis Lua 原子扣减库存
local stock = redis.call('get', KEYS[1])
if tonumber(stock) <= 0 then
    return -1  -- 库存不足
end
redis.call('decr', KEYS[1])
return redis.call('get', KEYS[1])  -- 返回剩余库存

请求 → Caffeine（L1，本地）→ Redis（L2，分布式）→ DB
         ↓                      ↓
      1ms响应                5ms响应
      单机10万QPS            集群10万QPS

@Component
public class ProductCache {
    
    @Cacheable(value = "product", key = "#id", 
               unless = "#result == null")
    public Product getProduct(Long id) {
        return productMapper.selectById(id);
    }
    
    // 布隆过滤器防止穿透
    public Product getProductWithBloomFilter(Long id) {
        if (!bloomFilter.mightContain(id)) {
            return null;  // 一定不存在
        }
        return getProduct(id);
    }
}

# ShardingSphere 配置
sharding:
  tables:
    t_order:
      actualDataNodes: ds${0..1}.t_order_${2024..2025}_${1..12}
      tableStrategy:
        standard:
          shardingColumn: create_time
          preciseAlgorithm: TimeShardingAlgorithm
      databaseStrategy:
        standard:
          shardingColumn: user_id
          preciseAlgorithm: UserIdShardingAlgorithm

┌─────────┐    失败率>阈值     ┌─────────┐
│  CLOSED │ ─────────────────→ │  OPEN   │
│ (正常)  │                    │ (熔断)  │
└────┬────┘                    └────┬────┘
     │    ←───────────────────     │
     │      超时后半开               │
     │                             │
     └─────────────────────────────┘
              半开状态(HALF_OPEN)

// 熔断降级规则
DegradeRule rule = new DegradeRule();
rule.setResource("getProduct");
rule.setGrade(CircuitBreakerStrategy.ERROR_RATIO);  // 异常比例
rule.setCount(0.5);  // 50% 异常率触发熔断
rule.setTimeWindow(30);  // 熔断30秒
rule.setMinRequestAmount(10);  // 最小请求数

// 网关层限流 - 基于 IP
GatewayFilterSpec filterSpec = builder.routes()
    .route("order_route", r -> r.path("/order/**")
        .filters(f -> f.requestRateLimiter(config -> {
            config.setRateLimiter(redisRateLimiter());
            config.setKeyResolver(exchange -> 
                Mono.just(exchange.getRequest().getRemoteAddress().getAddress().getHostAddress()));
        }))
        .uri("lb://order-service"));

读多写少场景（商品信息）：
- 最终一致性，多机房同步延迟 < 1s

强一致场景（库存、余额）：
- 单机房写，跨机房读
- 或 Paxos/Raft 分布式共识

用户请求 → Gateway → Order → Payment → Inventory
   │          │        │         │          │
   └──────────┴────────┴─────────┴──────────┘
              TraceID: abc123
              
Span 层级：
- Gateway: 10ms
  - Order: 50ms
    - Payment: 30ms
    - Inventory: 15ms

# Prometheus 告警规则
groups:
  - name: ecommerce-alerts
    rules:
      - alert: HighErrorRate
        expr: rate(http_requests_total{status=~"5.."}[5m]) > 0.01
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "错误率超过 1%"

┌─────────┐    登录     ┌─────────┐    JWT Token    ┌─────────┐
│  客户端  │ ─────────→ │ 用户服务 │ ─────────────→ │  客户端  │
└─────────┘            └─────────┘                 └─────────┘
     │
     │ 携带 JWT
     ▼
┌─────────┐   验签    ┌─────────┐   转发    ┌─────────┐
│  Gateway │ ───────→ │  业务服务 │ ←──────→ │  数据库  │
│ (验Token)│          │ (鉴权限) │          │         │
└─────────┘          └─────────┘          └─────────┘

@PreAuthorize("hasRole('ADMIN') or hasPermission(#orderId, 'ORDER:VIEW')")
public Order getOrder(Long orderId) {
    return orderService.getOrder(orderId);
}

public class AntiReplayFilter {
    public boolean validateRequest(String sign, String timestamp, String nonce) {
        // 1. 时间戳校验（5分钟内有效）
        long now = System.currentTimeMillis();
        if (now - Long.parseLong(timestamp) > 300000) {
            return false;
        }
        
        // 2. nonce 去重（Redis SetNX）
        if (!redis.setnx("nonce:" + nonce, "1", 300, TimeUnit.SECONDS)) {
            return false;
        }
        
        // 3. 签名验证
        String expectedSign = HmacUtils.hmacSha256Hex(key, timestamp + nonce);
        return expectedSign.equals(sign);
    }
}

// 发送延迟消息
rocketMQTemplate.asyncSend("order-delay-topic", 
    MessageBuilder.withPayload(order).build(), 
    new SendCallback() {...}, 
    300000,  // 延迟5分钟
    3        // 延迟级别
);

// 消费超时消息
@RocketMQMessageListener(topic = "order-delay-topic", 
                        consumerGroup = "order-timeout-consumer")
public class OrderTimeoutConsumer implements RocketMQListener<Order> {
    @Override
    public void onMessage(Order order) {
        // 1. 查询订单状态
        // 2. 未支付则取消订单
        // 3. 恢复库存
    }
}

┌─────────┐    下单     ┌─────────┐    支付     ┌─────────┐
│  可用   │ ─────────→ │  冻结   │ ─────────→ │  已扣减 │
│  100    │   扣10     │  90/10  │   确认     │   90    │
└────┬────┘            └────┬────┘            └─────────┘
     │                      │
     │    取消订单           │
     └──────────────────────┘
              回滚