【微服务架构核心】企业级分布式微服务架构设计与落地详解

// 错误示例：用户服务承担了过多职责
UserService {
    用户注册()
    用户登录()
    用户信息管理()
    积分管理()      // 应该独立为积分服务
    优惠券管理()    // 应该独立为营销服务
    收货地址管理()  // 应该独立为地址服务
}

// 正确示例：职责清晰
UserService {
    用户注册()
    用户登录()
    用户信息管理()
}

// 数据库拆分策略
// 阶段一：共享数据库，逻辑隔离（过渡方案）
Database: ecommerce_db
├── user_schema     (用户服务)
├── order_schema    (订单服务)
└── product_schema  (商品服务)

// 阶段二：独立数据库（目标方案）
Database: user_db      (用户服务独占)
Database: order_db     (订单服务独占)
Database: product_db   (商品服务独占)

电商系统业务能力划分：
├── 用户管理能力 → 用户服务
├── 商品管理能力 → 商品服务
├── 订单管理能力 → 订单服务
├── 支付管理能力 → 支付服务
├── 库存管理能力 → 库存服务
├── 物流管理能力 → 物流服务
└── 营销管理能力 → 营销服务

Consumer → Proxy → Cluster → LoadBalance → Directory → Registry
                                                    ↓
Provider ← Netty ← Codec ← Serialization ← Registry

// gRPC服务定义示例
syntax = "proto3";

package order;

service OrderService {
  // 一元RPC
  rpc GetOrder(GetOrderRequest) returns (Order);

  // 服务端流式RPC
  rpc ListOrders(ListOrdersRequest) returns (stream Order);

  // 客户端流式RPC
  rpc CreateOrders(stream CreateOrderRequest) returns (CreateOrdersResponse);

  // 双向流式RPC
  rpc StreamOrders(stream OrderRequest) returns (stream Order);
}

// 事件驱动示例：订单创建事件
public class OrderCreatedEvent {
    private String orderId;
    private String userId;
    private List<OrderItem> items;
    private BigDecimal totalAmount;
    private LocalDateTime createdAt;
}

// 事件发布
@Transactional
public void createOrder(OrderDTO orderDTO) {
    // 1. 创建订单
    Order order = orderRepository.save(orderDTO);

    // 2. 发布事件（事务提交后）
    applicationEventPublisher.publishEvent(
        new OrderCreatedEvent(order.getId(), order.getUserId(), ...)
    );
}

// 事件消费
@EventListener
public void handleOrderCreated(OrderCreatedEvent event) {
    // 扣减库存
    inventoryService.deduct(event.getItems());
    // 发送通知
    notificationService.sendOrderConfirmation(event.getUserId());
}

// 典型分布式事务场景：下单操作
@Transactional
public void placeOrder(OrderDTO orderDTO) {
    // 1. 创建订单（订单服务）
    orderService.createOrder(orderDTO);  // 本地事务

    // 2. 扣减库存（库存服务）
    inventoryService.deductStock(orderDTO.getItems());  // 远程调用

    // 3. 扣减余额（支付服务）
    accountService.deductBalance(orderDTO.getUserId(), orderDTO.getAmount());  // 远程调用

    // 问题：如果步骤3失败，步骤1和2已经提交，如何回滚？
}

协调者                    参与者A                    参与者B
   |                         |                         |
   |---- Prepare ----------->|                         |
   |                         |---- Prepare ----------->|
   |<--- Ready --------------|                         |
   |                         |<--- Ready --------------|
   |                         |                         |
   |---- Commit ------------>|                         |
   |                         |---- Commit ------------>|
   |<--- Ack ----------------|                         |
   |                         |<--- Ack ----------------|

// TCC接口定义
public interface InventoryTccService {
    // Try：预留库存
    @Transactional
    boolean tryDeduct(String orderId, List<OrderItem> items);

    // Confirm：确认扣减
    @Transactional
    boolean confirmDeduct(String orderId);

    // Cancel：取消预留
    @Transactional
    boolean cancelDeduct(String orderId);
}

// TCC实现
public class InventoryTccServiceImpl implements InventoryTccService {

    @Override
    public boolean tryDeduct(String orderId, List<OrderItem> items) {
        // 1. 检查库存是否充足
        // 2. 冻结库存（预扣减）
        for (OrderItem item : items) {
            inventoryMapper.freezeStock(item.getSkuId(), item.getQuantity(), orderId);
        }
        return true;
    }

    @Override
    public boolean confirmDeduct(String orderId) {
        // 真正扣减冻结的库存
        inventoryMapper.confirmFreeze(orderId);
        return true;
    }

    @Override
    public boolean cancelDeduct(String orderId) {
        // 释放冻结的库存
        inventoryMapper.releaseFreeze(orderId);
        return true;
    }
}

-- 本地消息表
CREATE TABLE local_message (
    id BIGINT PRIMARY KEY,
    message_id VARCHAR(64) UNIQUE,
    topic VARCHAR(64),
    message_body TEXT,
    status TINYINT,  -- 0:待发送 1:已发送 2:发送失败
    retry_count INT DEFAULT 0,
    create_time DATETIME,
    update_time DATETIME
);

// 本地消息表实现
@Transactional
public void placeOrder(OrderDTO orderDTO) {
    // 1. 创建订单
    Order order = orderRepository.save(orderDTO);

    // 2. 保存消息到本地消息表（同一事务）
    LocalMessage message = new LocalMessage();
    message.setMessageId(UUID.randomUUID().toString());
    message.setTopic("order-created");
    message.setMessageBody(JSON.toJSONString(order));
    message.setStatus(0);
    localMessageRepository.save(message);
}

// 定时任务扫描并发送消息
@Scheduled(fixedDelay = 1000)
public void sendPendingMessages() {
    List<LocalMessage> messages = localMessageRepository.findByStatus(0);
    for (LocalMessage message : messages) {
        try {
            mqProducer.send(message.getTopic(), message.getMessageBody());
            message.setStatus(1);
            localMessageRepository.update(message);
        } catch (Exception e) {
            message.setRetryCount(message.getRetryCount() + 1);
            if (message.getRetryCount() > MAX_RETRY) {
                message.setStatus(2);
            }
            localMessageRepository.update(message);
        }
    }
}

// 事务消息发送
public void placeOrder(OrderDTO orderDTO) {
    // 1. 发送半消息
    Message message = new Message("order-created", JSON.toJSONString(orderDTO).getBytes());
    TransactionSendResult result = producer.sendMessageInTransaction(message, orderDTO);

    // 2. 执行本地事务（在TransactionListener中）
    // 3. 根据本地事务结果提交或回滚消息
}

// 事务监听器
public class OrderTransactionListener implements TransactionListener {

    @Override
    public LocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        try {
            OrderDTO orderDTO = JSON.parseObject(new String(msg.getBody()), OrderDTO.class);
            // 执行本地事务
            orderService.createOrder(orderDTO);
            return LocalTransactionState.COMMIT_MESSAGE;
        } catch (Exception e) {
            return LocalTransactionState.ROLLBACK_MESSAGE;
        }
    }

    @Override
    public LocalTransactionState checkLocalTransaction(MessageExt msg) {
        // 回查本地事务状态
        OrderDTO orderDTO = JSON.parseObject(new String(msg.getBody()), OrderDTO.class);
        Order order = orderService.getByOrderId(orderDTO.getOrderId());
        return order != null ? LocalTransactionState.COMMIT_MESSAGE : LocalTransactionState.ROLLBACK_MESSAGE;
    }
}

// 编排式Saga示例
public class OrderSaga {

    private List<SagaStep> steps = new ArrayList<>();

    public OrderSaga createOrder(OrderDTO orderDTO) {
        steps.add(new SagaStep(
            () -> orderService.createOrder(orderDTO),
            () -> orderService.cancelOrder(orderDTO.getOrderId())
        ));
        return this;
    }

    public OrderSaga deductInventory(List<OrderItem> items) {
        steps.add(new SagaStep(
            () -> inventoryService.deduct(items),
            () -> inventoryService.restore(items)
        ));
        return this;
    }

    public OrderSaga deductBalance(String userId, BigDecimal amount) {
        steps.add(new SagaStep(
            () -> accountService.deduct(userId, amount),
            () -> accountService.refund(userId, amount)
        ));
        return this;
    }

    public void execute() {
        int currentStep = 0;
        try {
            for (; currentStep < steps.size(); currentStep++) {
                steps.get(currentStep).execute();
            }
        } catch (Exception e) {
            // 补偿已执行的步骤
            for (int i = currentStep - 1; i >= 0; i--) {
                steps.get(i).compensate();
            }
            throw e;
        }
    }
}

// 一致性哈希实现
public class ConsistentHashLoadBalancer {

    // 虚拟节点数，解决数据倾斜问题
    private static final int VIRTUAL_NODES = 150;

    // 哈希环
    private TreeMap<Integer, ServiceInstance> hashRing = new TreeMap<>();

    public void addInstance(ServiceInstance instance) {
        for (int i = 0; i < VIRTUAL_NODES; i++) {
            String virtualNode = instance.getAddress() + "#" + i;
            int hash = hash(virtualNode);
            hashRing.put(hash, instance);
        }
    }

    public ServiceInstance select(String key) {
        int hash = hash(key);
        // 找到第一个大于等于该哈希值的节点
        Map.Entry<Integer, ServiceInstance> entry = hashRing.ceilingEntry(hash);
        if (entry == null) {
            // 环形结构，回到第一个节点
            entry = hashRing.firstEntry();
        }
        return entry.getValue();
    }

    private int hash(String key) {
        return MD5Hash.md5HashingAlgorithm(key);
    }
}

          失败率超过阈值
    ┌───────────────────────┐
    │                       │
    ▼                       │
┌────────┐   成功率恢复   ┌────────┐
│  关闭  │◄──────────────│  半开  │
└────────┘               └────────┘
    │                       ▲
    │ 失败率超过阈值         │
    ▼                       │
┌────────┐   超时后尝试   │
│  打开  │───────────────┘
└────────┘

// 熔断器实现
public class CircuitBreaker {

    private CircuitBreakerState state = CircuitBreakerState.CLOSED;
    private int failureCount = 0;
    private int successCount = 0;
    private long lastFailureTime = 0;

    // 配置参数
    private int failureThreshold = 10;      // 失败阈值
    private int successThreshold = 5;       // 成功阈值（半开状态）
    private long timeout = 30000;           // 熔断超时时间

    public <T> T execute(Supplier<T> supplier) {
        if (state == CircuitBreakerState.OPEN) {
            if (System.currentTimeMillis() - lastFailureTime > timeout) {
                state = CircuitBreakerState.HALF_OPEN;
                successCount = 0;
            } else {
                throw new CircuitBreakerException("Circuit breaker is open");
            }
        }

        try {
            T result = supplier.get();
            onSuccess();
            return result;
        } catch (Exception e) {
            onFailure();
            throw e;
        }
    }

    private void onSuccess() {
        if (state == CircuitBreakerState.HALF_OPEN) {
            successCount++;
            if (successCount >= successThreshold) {
                state = CircuitBreakerState.CLOSED;
                failureCount = 0;
            }
        } else {
            failureCount = 0;
        }
    }

    private void onFailure() {
        failureCount++;
        lastFailureTime = System.currentTimeMillis();

        if (state == CircuitBreakerState.HALF_OPEN) {
            state = CircuitBreakerState.OPEN;
        } else if (failureCount >= failureThreshold) {
            state = CircuitBreakerState.OPEN;
        }
    }
}

public class FixedWindowRateLimiter {

    private long windowSize = 1000;  // 窗口大小：1秒
    private int limit = 100;          // 限制：100次/秒
    private long windowStart = System.currentTimeMillis();
    private int count = 0;

    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        if (now - windowStart >= windowSize) {
            windowStart = now;
            count = 0;
        }

        if (count < limit) {
            count++;
            return true;
        }
        return false;
    }
}

public class SlidingWindowRateLimiter {

    private long windowSize = 1000;   // 窗口大小：1秒
    private int subWindowCount = 10;  // 子窗口数量
    private int limit = 100;          // 限制：100次/秒

    private long[] subWindowCounts = new long[subWindowCount];
    private long windowStart = System.currentTimeMillis();

    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        long elapsed = now - windowStart;

        // 计算需要滑动的子窗口数量
        int slideCount = (int) (elapsed / (windowSize / subWindowCount));
        if (slideCount > 0) {
            // 滑动窗口
            for (int i = 0; i < slideCount && i < subWindowCount; i++) {
                subWindowCounts[i] = 0;
            }
            windowStart += slideCount * (windowSize / subWindowCount);
        }

        // 计算当前总请求数
        long totalCount = Arrays.stream(subWindowCounts).sum();

        if (totalCount < limit) {
            int currentIndex = (int) ((now - windowStart) / (windowSize / subWindowCount));
            subWindowCounts[currentIndex]++;
            return true;
        }
        return false;
    }
}

public class LeakyBucketRateLimiter {

    private long capacity = 100;      // 桶容量
    private long rate = 10;           // 流出速率：10个/秒
    private long water = 0;           // 当前水量
    private long lastTime = System.currentTimeMillis();

    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();

        // 计算流出的水量
        long elapsed = now - lastTime;
        long outflow = elapsed * rate / 1000;
        water = Math.max(0, water - outflow);
        lastTime = now;

        if (water < capacity) {
            water++;
            return true;
        }
        return false;
    }
}

public class TokenBucketRateLimiter {

    private long capacity = 100;      // 桶容量
    private long rate = 10;           // 生成速率：10个/秒
    private long tokens = capacity;   // 当前令牌数
    private long lastTime = System.currentTimeMillis();

    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();

        // 计算生成的令牌数
        long elapsed = now - lastTime;
        long generated = elapsed * rate / 1000;
        tokens = Math.min(capacity, tokens + generated);
        lastTime = now;

        if (tokens > 0) {
            tokens--;
            return true;
        }
        return false;
    }
}

# Spring Cloud Gateway路由配置
spring:
  cloud:
    gateway:
      routes:
        - id: user-service-v1
          uri: lb://user-service
          predicates:
            - Path=/api/user/**
            - Header=X-Version, v1
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10
                redis-rate-limiter.burstCapacity: 20

        - id: user-service-v2
          uri: lb://user-service-v2
          predicates:
            - Path=/api/user/**
            - Header=X-Version, v2

┌─────────────────────────────────────────────────────────────────┐
│                         客户端层                                  │
│   ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐           │
│   │  App    │  │  H5     │  │ 小程序   │  │  PC     │           │
│   └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘           │
└────────┼────────────┼────────────┼────────────┼─────────────────┘
         │            │            │            │
         └────────────┴────────────┴────────────┘
                              │
┌─────────────────────────────┼───────────────────────────────────┐
│                      接入层                                      │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │                    CDN + WAF                             │   │
│   └─────────────────────────────────────────────────────────┘   │
│   ┌─────────────────────────────────────────────────────────┐   │
│   │                    API Gateway                           │   │
│   │         (认证/限流/路由/熔断/日志)                         │   │
│   └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────┬───────────────────────────────────┘
                              │
┌─────────────────────────────┼───────────────────────────────────┐
│                      服务层                                      │
│   ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐          │
│   │用户服务   │ │商品服务   │ │订单服务   │ │支付服务   │          │
│   └──────────┘ └──────────┘ └──────────┘ └──────────┘          │
│   ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐          │
│   │库存服务   │ │营销服务   │ │物流服务   │ │搜索服务   │          │
│   └──────────┘ └──────────┘ └──────────┘ └──────────┘          │
└─────────────────────────────┬───────────────────────────────────┘
                              │
┌─────────────────────────────┼───────────────────────────────────┐
│                      数据层                                      │
│   ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐          │
│   │ MySQL    │ │ Redis    │ │ ES       │ │ MQ       │          │
│   │ (主业务) │ │ (缓存)   │ │ (搜索)   │ │ (异步)   │          │
│   └──────────┘ └──────────┘ └──────────┘ └──────────┘          │
└─────────────────────────────────────────────────────────────────┘

// 订单服务核心接口
public interface OrderService {
    // 创建订单（TCC分布式事务）
    OrderResult createOrder(OrderDTO orderDTO);

    // 取消订单
    void cancelOrder(String orderId);

    // 支付成功回调
    void paySuccess(String orderId);

    // 发货回调
    void deliverSuccess(String orderId);
}

// 订单创建TCC实现
@Service
public class OrderTccServiceImpl {

    @Resource
    private InventoryTccService inventoryTccService;

    @Resource
    private AccountTccService accountTccService;

    @Resource
    private CouponTccService couponTccService;

    @Transactional
    public OrderResult createOrder(OrderDTO orderDTO) {
        // 1. Try阶段：预留资源
        String txId = UUID.randomUUID().toString();

        // 1.1 预留库存
        boolean inventoryResult = inventoryTccService.tryDeduct(
            txId, orderDTO.getItems()
        );
        if (!inventoryResult) {
            throw new BusinessException("库存不足");
        }

        // 1.2 预留余额
        boolean accountResult = accountTccService.tryDeduct(
            txId, orderDTO.getUserId(), orderDTO.getTotalAmount()
        );
        if (!accountResult) {
            inventoryTccService.cancelDeduct(txId);
            throw new BusinessException("余额不足");
        }

        // 1.3 预留优惠券
        if (orderDTO.getCouponId() != null) {
            boolean couponResult = couponTccService.tryUse(
                txId, orderDTO.getUserId(), orderDTO.getCouponId()
            );
            if (!couponResult) {
                inventoryTccService.cancelDeduct(txId);
                accountTccService.cancelDeduct(txId);
                throw new BusinessException("优惠券不可用");
            }
        }

        // 2. 创建订单（本地事务）
        Order order = createOrderRecord(orderDTO, txId);

        // 3. Confirm阶段：提交事务
        inventoryTccService.confirmDeduct(txId);
        accountTccService.confirmDeduct(txId);
        if (orderDTO.getCouponId() != null) {
            couponTccService.confirmUse(txId);
        }

        return OrderResult.success(order);
    }
}

// 库存扣减（Redis + Lua脚本保证原子性）
@Service
public class InventoryService {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    // Lua脚本：原子性扣减库存
    private static final String DEDUCT_SCRIPT = 
        "local key = KEYS[1]\n" +
        "local quantity = tonumber(ARGV[1])\n" +
        "local stock = tonumber(redis.call('GET', key) or '0')\n" +
        "if stock >= quantity then\n" +
        "    redis.call('DECRBY', key, quantity)\n" +
        "    return 1\n" +
        "else\n" +
        "    return 0\n" +
        "end";

    public boolean deduct(String skuId, int quantity) {
        String key = "stock:" + skuId;
        DefaultRedisScript<Long> script = new DefaultRedisScript<>(DEDUCT_SCRIPT, Long.class);
        Long result = redisTemplate.execute(script, 
            Collections.singletonList(key), 
            String.valueOf(quantity)
        );
        return result != null && result == 1;
    }

    // 库存预热：大促前将库存加载到Redis
    public void warmUp() {
        List<Inventory> inventories = inventoryMapper.selectAll();
        for (Inventory inventory : inventories) {
            String key = "stock:" + inventory.getSkuId();
            redisTemplate.opsForValue().set(key, inventory.getQuantity());
        }
    }
}

// 秒杀服务设计
@Service
public class SeckillService {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Resource
    private RocketMQTemplate rocketMQTemplate;

    // 秒杀令牌：防止重复下单
    public String generateToken(String userId, String seckillId) {
        String token = UUID.randomUUID().toString();
        String key = "seckill:token:" + seckillId + ":" + userId;
        redisTemplate.opsForValue().set(key, token, 30, TimeUnit.MINUTES);
        return token;
    }

    // 秒杀下单：Redis原子扣减 + MQ异步处理
    public SeckillResult seckill(String userId, String seckillId, String token) {
        // 1. 校验令牌
        String key = "seckill:token:" + seckillId + ":" + userId;
        String storedToken = (String) redisTemplate.opsForValue().get(key);
        if (!token.equals(storedToken)) {
            return SeckillResult.fail("令牌无效");
        }

        // 2. 原子扣减库存
        String stockKey = "seckill:stock:" + seckillId;
        Long stock = redisTemplate.opsForValue().decrement(stockKey);
        if (stock < 0) {
            redisTemplate.opsForValue().increment(stockKey);
            return SeckillResult.fail("库存不足");
        }

        // 3. 发送MQ消息，异步创建订单
        SeckillOrderMessage message = new SeckillOrderMessage();
        message.setUserId(userId);
        message.setSeckillId(seckillId);
        message.setToken(token);
        rocketMQTemplate.asyncSend("seckill-order-topic", message, new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                log.info("秒杀订单消息发送成功: {}", message);
            }

            @Override
            public void onException(Throwable e) {
                log.error("秒杀订单消息发送失败", e);
                // 回滚库存
                redisTemplate.opsForValue().increment(stockKey);
            }
        });

        return SeckillResult.success("排队中，请稍后查询结果");
    }
}

请求 → 本地缓存(Caffeine) → 分布式缓存(Redis) → 数据库(MySQL)
         ↓ 100ns              ↓ 1ms              ↓ 10ms

写请求 → 主库
读请求 → 从库(多个) + 路由策略

同步链路：用户 → 网关 → 订单服务 → 库存服务 → 支付服务
异步链路：订单创建 → MQ → 库存扣减 → MQ → 积分发放 → MQ → 消息通知

// 账户服务：采用TCC保证资金安全
@Service
public class AccountService {

    @Resource
    private AccountMapper accountMapper;

    @Resource
    private FreezeRecordMapper freezeRecordMapper;

    // Try：冻结资金
    @Transactional
    public boolean tryFreeze(String txId, String accountId, BigDecimal amount) {
        // 1. 查询账户余额
        Account account = accountMapper.selectForUpdate(accountId);
        if (account.getBalance().compareTo(amount) < 0) {
            return false;
        }

        // 2. 冻结资金
        accountMapper.freeze(accountId, amount);

        // 3. 记录冻结流水
        FreezeRecord record = new FreezeRecord();
        record.setTxId(txId);
        record.setAccountId(accountId);
        record.setAmount(amount);
        record.setStatus(FreezeStatus.FREEZING);
        freezeRecordMapper.insert(record);

        return true;
    }

    // Confirm：确认扣款
    @Transactional
    public boolean confirmDeduct(String txId) {
        FreezeRecord record = freezeRecordMapper.selectByTxId(txId);
        if (record == null || record.getStatus() == FreezeStatus.DEDUCTED) {
            return true; // 幂等处理
        }

        // 1. 扣减冻结金额
        accountMapper.deductFreeze(record.getAccountId(), record.getAmount());

        // 2. 更新冻结记录状态
        freezeRecordMapper.updateStatus(txId, FreezeStatus.DEDUCTED);

        return true;
    }

    // Cancel：解冻资金
    @Transactional
    public boolean cancelFreeze(String txId) {
        FreezeRecord record = freezeRecordMapper.selectByTxId(txId);
        if (record == null || record.getStatus() == FreezeStatus.CANCELLED) {
            return true; // 幂等处理
        }

        // 1. 解冻资金
        accountMapper.unfreeze(record.getAccountId(), record.getAmount());

        // 2. 更新冻结记录状态
        freezeRecordMapper.updateStatus(txId, FreezeStatus.CANCELLED);

        return true;
    }
}

// 交易服务：幂等设计 + 状态机
@Service
public class TransactionService {

    @Resource
    private TransactionMapper transactionMapper;

    @Resource
    private IdGenerator idGenerator;

    // 交易状态机
    private enum TransactionState {
        INIT,           // 初始化
        PROCESSING,     // 处理中
        SUCCESS,        // 成功
        FAILED,         // 失败
        REFUNDED        // 已退款
    }

    // 状态转移规则
    private static final Map<TransactionState, Set<TransactionState>> STATE_TRANSITIONS = 
        Map.of(
            TransactionState.INIT, Set.of(TransactionState.PROCESSING),
            TransactionState.PROCESSING, Set.of(TransactionState.SUCCESS, TransactionState.FAILED),
            TransactionState.SUCCESS, Set.of(TransactionState.REFUNDED)
        );

    // 创建交易（幂等）
    @Transactional
    public Transaction createTransaction(TransactionDTO dto) {
        // 1. 幂等检查
        Transaction existing = transactionMapper.selectByBizNo(dto.getBizNo());
        if (existing != null) {
            return existing;
        }

        // 2. 创建交易记录
        Transaction transaction = new Transaction();
        transaction.setTxId(idGenerator.nextId());
        transaction.setBizNo(dto.getBizNo());
        transaction.setPayerAccount(dto.getPayerAccount());
        transaction.setPayeeAccount(dto.getPayeeAccount());
        transaction.setAmount(dto.getAmount());
        transaction.setState(TransactionState.INIT);
        transactionMapper.insert(transaction);

        return transaction;
    }

    // 执行交易
    @Transactional
    public void executeTransaction(String txId) {
        Transaction transaction = transactionMapper.selectForUpdate(txId);

        // 状态检查
        if (transaction.getState() != TransactionState.INIT) {
            throw new BusinessException("交易状态不正确");
        }

        // 更新状态为处理中
        transactionMapper.updateState(txId, TransactionState.PROCESSING);

        try {
            // 执行转账逻辑...

            // 更新状态为成功
            transactionMapper.updateState(txId, TransactionState.SUCCESS);
        } catch (Exception e) {
            // 更新状态为失败
            transactionMapper.updateState(txId, TransactionState.FAILED);
            throw e;
        }
    }
}

// 敏感数据加密存储
@Service
public class SensitiveDataService {

    @Resource
    private CipherService cipherService;

    // 卡号加密存储
    public void saveCardInfo(CardInfo cardInfo) {
        // 1. 卡号加密
        String encryptedCardNo = cipherService.encrypt(cardInfo.getCardNo());
        cardInfo.setCardNo(encryptedCardNo);

        // 2. CVV不存储（PCI-DSS要求）
        cardInfo.setCvv(null);

        // 3. 存储卡号哈希（用于查询）
        String cardNoHash = DigestUtils.sha256Hex(cardInfo.getCardNo());
        cardInfo.setCardNoHash(cardNoHash);

        cardInfoMapper.insert(cardInfo);
    }

    // 卡号脱敏展示
    public String maskCardNo(String cardNo) {
        if (cardNo == null || cardNo.length() < 8) {
            return cardNo;
        }
        return cardNo.substring(0, 4) + "****" + cardNo.substring(cardNo.length() - 4);
    }
}

// API签名验证
@Component
public class SignatureInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // 1. 获取签名参数
        String appId = request.getHeader("X-App-Id");
        String timestamp = request.getHeader("X-Timestamp");
        String nonce = request.getHeader("X-Nonce");
        String signature = request.getHeader("X-Signature");

        // 2. 时间戳校验（防重放）
        long now = System.currentTimeMillis();
        if (Math.abs(now - Long.parseLong(timestamp)) > 5 * 60 * 1000) {
            throw new SecurityException("请求已过期");
        }

        // 3. nonce校验（防重放）
        String nonceKey = "nonce:" + appId + ":" + nonce;
        if (redisTemplate.hasKey(nonceKey)) {
            throw new SecurityException("重复请求");
        }
        redisTemplate.opsForValue().set(nonceKey, "1", 10, TimeUnit.MINUTES);

        // 4. 签名校验
        String appSecret = getAppSecret(appId);
        String computedSignature = computeSignature(request, appSecret);
        if (!signature.equals(computedSignature)) {
            throw new SecurityException("签名验证失败");
        }

        return true;
    }

    private String computeSignature(HttpServletRequest request, String appSecret) {
        StringBuilder sb = new StringBuilder();
        sb.append(request.getMethod()).append("\n");
        sb.append(request.getRequestURI()).append("\n");
        sb.append(request.getHeader("X-Timestamp")).append("\n");
        sb.append(request.getHeader("X-Nonce")).append("\n");
        sb.append(getRequestBody(request));

        return HmacUtils.hmacSha256Hex(appSecret, sb.toString());
    }
}

┌─────────────────────────────────────┐
│            单体应用                  │
│  ┌─────────┐ ┌─────────┐ ┌────────┐ │
│  │用户模块  │ │消息模块  │ │社交模块│ │
│  └─────────┘ └─────────┘ └────────┘ │
│  ┌─────────────────────────────────┐│
│  │           MySQL                  ││
│  └─────────────────────────────────┘│
└─────────────────────────────────────┘

┌─────────────────────────────────────┐
│          模块化单体应用              │
│  ┌─────────┐ ┌─────────┐ ┌────────┐ │
│  │用户服务  │ │消息服务  │ │社交服务│ │
│  │(独立模块)│ │(独立模块)│ │(独立模块│ │
│  └────┬────┘ └────┬────┘ └───┬────┘ │
│       │           │           │      │
│  ┌────┴───────────┴───────────┴────┐│
│  │         MySQL (分Schema)         ││
│  └─────────────────────────────────┘│
└─────────────────────────────────────┘

┌─────────────────────────────────────────────────────────┐
│                    微服务架构                            │
│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐   │
│  │用户服务   │ │消息服务   │ │动态服务   │ │关系服务   │   │
│  │(独立部署) │ │(独立部署) │ │(独立部署) │ │(独立部署) │   │
│  └─────┬────┘ └─────┬────┘ └─────┬────┘ └─────┬────┘   │
│        │            │            │            │         │
│  ┌─────┴────┐ ┌─────┴────┐ ┌─────┴────┐ ┌─────┴────┐   │
│  │ user_db  │ │ msg_db   │ │ feed_db  │ │ rel_db   │   │
│  └──────────┘ └──────────┘ └──────────┘ └──────────┘   │
└─────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────┐
│                   云原生微服务架构                       │
│  ┌────────────────────────────────────────────────────┐ │
│  │                    Service Mesh                     │ │
│  │  ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐    │ │
│  │  │用户   │ │消息   │ │动态   │ │关系   │ │推荐   │    │ │
│  │  │服务   │ │服务   │ │服务   │ │服务   │ │服务   │    │ │
│  │  └──┬───┘ └──┬───┘ └──┬───┘ └──┬───┘ └──┬───┘    │ │
│  │     │        │        │        │        │         │ │
│  │  ┌──┴───┐ ┌──┴───┐ ┌──┴───┐ ┌──┴───┐ ┌──┴───┐    │ │
│  │  │MySQL │ │TiDB  │ │Redis │ │MySQL │ │ClickHouse│ │
│  │  │集群  │ │集群  │ │集群  │ │集群  │ │集群    │ │ │
│  │  └──────┘ └──────┘ └──────┘ └──────┘ └────────┘  │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘

消息服务
├── 消息存储服务（Message Storage Service）
│   ├── 消息写入
│   ├── 消息查询
│   └── 消息索引
├── 消息推送服务（Message Push Service）
│   ├── 在线推送
│   ├── 离线推送
│   └── 多端同步
├── 会话服务（Conversation Service）
│   ├── 会话列表
│   ├── 会话状态
│   └── 未读计数
└── 消息搜索服务（Message Search Service）
    ├── 全文检索
    └── 消息归档

消息写入流程：
客户端 → API网关 → 消息接入服务 → 消息队列 → 消息存储服务 → 数据库
                                        ↓
                                   消息推送服务 → 推送网关 → 客户端

消息存储策略：
- 热数据：Redis（最近7天消息）
- 温数据：MySQL（最近3个月消息）
- 冷数据：HBase（历史消息归档）

// 紧急熔断配置
@HystrixCommand(
    fallbackMethod = "fallback",
    commandProperties = {
        @HystrixProperty(name = "circuitBreaker.enabled", value = "true"),
        @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),
        @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "50"),
        @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "5000")
    }
)
public Result callService() {
    // 服务调用
}

// 紧急限流配置
@RestController
public class EmergencyController {

    @RateLimiter(value = 100) // 限制QPS为100
    @GetMapping("/api/service")
    public Result service() {
        // 正常逻辑
    }

    // 降级接口
    @GetMapping("/api/service/fallback")
    public Result fallback() {
        return Result.fail("服务繁忙，请稍后重试");
    }
}

# Kubernetes紧急扩容
kubectl scale deployment user-service --replicas=20

# 或者使用HPA自动扩容
kubectl autoscale deployment user-service --min=5 --max=50 --cpu-percent=80

// 完整的熔断降级配置
@Configuration
public class CircuitBreakerConfig {

    @Bean
    public Customizer<Resilience4JCircuitBreakerFactory> defaultCustomizer() {
        return factory -> factory.configureDefault(id -> new Resilience4JConfigBuilder(id)
            .circuitBreakerConfig(CircuitBreakerConfig.custom()
                .failureRateThreshold(50)                    // 失败率阈值50%
                .waitDurationInOpenState(Duration.ofSeconds(30))  // 熔断持续时间
                .permittedNumberOfCallsInHalfOpenState(10)   // 半开状态请求数
                .slidingWindowSize(100)                      // 滑动窗口大小
                .slidingWindowType(SlidingWindowType.COUNT_BASED)
                .build())
            .timeLimiterConfig(TimeLimiterConfig.custom()
                .timeoutDuration(Duration.ofSeconds(3))      // 超时时间
                .build())
            .build());
    }
}

// 同步调用改造为异步
@Service
public class OrderService {

    @Resource
    private InventoryService inventoryService;

    @Resource
    private ThreadPoolExecutor asyncExecutor;

    // 改造前：同步调用
    public OrderResult createOrderSync(OrderDTO dto) {
        inventoryService.deduct(dto.getItems());  // 同步阻塞
        // ...
    }

    // 改造后：异步调用
    public CompletableFuture<OrderResult> createOrderAsync(OrderDTO dto) {
        return CompletableFuture.supplyAsync(() -> {
            inventoryService.deduct(dto.getItems());
            // ...
        }, asyncExecutor).orTimeout(3, TimeUnit.SECONDS)
          .exceptionally(ex -> OrderResult.fail("系统繁忙"));
    }
}

// 线程池隔离配置
@Configuration
public class ThreadPoolConfig {

    // 核心服务独立线程池
    @Bean("orderThreadPool")
    public ThreadPoolExecutor orderThreadPool() {
        return new ThreadPoolExecutor(
            50, 100, 60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1000),
            new ThreadFactoryBuilder().setNameFormat("order-%d").build(),
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
    }

    @Bean("inventoryThreadPool")
    public ThreadPoolExecutor inventoryThreadPool() {
        return new ThreadPoolExecutor(
            30, 60, 60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(500),
            new ThreadFactoryBuilder().setNameFormat("inventory-%d").build(),
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
    }
}

// TraceID生成与传递
public class TraceContext {

    private static final ThreadLocal<String> TRACE_ID = new ThreadLocal<>();

    public static void setTraceId(String traceId) {
        TRACE_ID.set(traceId);
    }

    public static String getTraceId() {
        return TRACE_ID.get();
    }

    public static void clear() {
        TRACE_ID.remove();
    }

    public static String generateTraceId() {
        return UUID.randomUUID().toString().replace("-", "");
    }
}

// HTTP拦截器传递TraceID
@Component
public class TraceInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        String traceId = request.getHeader("X-Trace-Id");
        if (StringUtils.isEmpty(traceId)) {
            traceId = TraceContext.generateTraceId();
        }
        TraceContext.setTraceId(traceId);
        response.setHeader("X-Trace-Id", traceId);
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, 
                                Object handler, Exception ex) {
        TraceContext.clear();
    }
}

// Feign拦截器传递TraceID
@Configuration
public class FeignConfig {

    @Bean
    public RequestInterceptor feignTraceInterceptor() {
        return template -> {
            String traceId = TraceContext.getTraceId();
            if (StringUtils.isNotEmpty(traceId)) {
                template.header("X-Trace-Id", traceId);
            }
        };
    }
}

<!-- Logback配置 -->
<appender name="JSON" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/application.json</file>
    <encoder class="net.logstash.logback.encoder.LogstashEncoder">
        <customFields>{"app_name":"user-service"}</customFields>
        <includeMdcKeyName>traceId</includeMdcKeyName>
        <includeMdcKeyName>spanId</includeMdcKeyName>
    </encoder>
</appender>

# SkyWalking Agent配置
agent.service_name=user-service
agent.sample_n_per_3_secs=3
collector.backend_service=skywalking-oap:11800

一致性要求        推荐方案
强一致性     →  2PC/TCC（性能要求高选TCC）
最终一致性   →  本地消息表/事务消息/Saga
弱一致性     →  异步消息

// 幂等性设计
@Service
public class IdempotentService {

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    // 幂等性校验
    public boolean checkIdempotent(String bizId, String operation) {
        String key = "idempotent:" + operation + ":" + bizId;
        Boolean success = redisTemplate.opsForValue().setIfAbsent(
            key, "1", 24, TimeUnit.HOURS
        );
        return Boolean.TRUE.equals(success);
    }

    // 幂等性接口
    @Transactional
    public Result processOrder(OrderDTO dto) {
        String bizId = dto.getBizId();

        // 幂等性检查
        if (!checkIdempotent(bizId, "create_order")) {
            return Result.success("订单已存在");
        }

        // 业务处理
        // ...

        return Result.success();
    }
}