176｜微服务拆分原则：业务边界、团队边界、数据边界和演进式拆分

// 订单上下文中的"商品"
class Product {
    Long productId;
    String name;
    Money price;        // 关心价格
    String imageUrl;    // 关心图片
}

// 库存上下文中的"商品"
class Product {
    Long productId;
    String skuCode;
    Integer quantity;   // 关心数量
    String warehouseId; // 关心仓库
}

// ❌ 错误：订单服务直接查支付表
@Repository
public class OrderDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public PaymentInfo getPayment(Long orderId) {
        // 直接跨库查支付服务的表
        return jdbcTemplate.queryForObject(
            "SELECT * FROM payment_db.t_payment WHERE order_id = ?",
            PaymentInfo.class, orderId);
    }
}

// ✅ 正确：订单服务通过 API 获取支付信息
@Service
public class OrderService {
    @Autowired
    private PaymentClient paymentClient;  // Feign/Dubbo 调用

    public OrderDetail getOrderDetail(Long orderId) {
        Order order = orderDao.findById(orderId);
        // 通过 API 获取，而不是直接查表
        PaymentInfo payment = paymentClient.getPaymentByOrderId(orderId);
        return OrderDetail.of(order, payment);
    }
}

// 订单服务：创建订单 + 写入本地消息表（同一个本地事务）
@Transactional
public void createOrder(CreateOrderRequest req) {
    // 1. 保存订单
    orderDao.save(order);
    // 2. 写入本地消息表（同一个数据库，ACID 保证）
    eventPublisher.publish("order.created", order);
    // 3. 定时任务扫描消息表，发送到 MQ
}

// 定时任务：扫描未发送消息
@Scheduled(fixedDelay = 1000)
public void sendPendingMessages() {
    List<EventMessage> messages = eventDao.findPendingMessages();
    for (EventMessage msg : messages) {
        try {
            mqProducer.send(msg);
            eventDao.markAsSent(msg.getId());
        } catch (Exception e) {
            log.error("发送失败，等待重试", e);
        }
    }
}

// 使用 RocketMQ 事务消息实现分布式事务
public void createOrder(Order order) {
    // 1. 发送半消息
    TransactionSendResult result = rocketMQTemplate.sendMessageInTransaction(
        "order-topic",
        MessageBuilder.withPayload(order).build(),
        order
    );
}

// 2. 执行本地事务
@RocketMQTransactionListener
public class OrderTransactionListener implements RocketMQLocalTransactionListener {
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        try {
            orderDao.save((Order) arg);
            return RocketMQLocalTransactionState.COMMIT;  // 本地事务成功，提交消息
        } catch (Exception e) {
            return RocketMQLocalTransactionState.ROLLBACK; // 本地事务失败，回滚消息
        }
    }

    // 3. 回查（MQ 未收到确认时）
    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
        Order order = (Order) msg.getPayload();
        if (orderDao.existsById(order.getId())) {
            return RocketMQLocalTransactionState.COMMIT;
        }
        return RocketMQLocalTransactionState.ROLLBACK;
    }
}

正向流程：创建订单 → 扣减库存 → 扣款
补偿流程：退款 → 恢复库存 → 取消订单

// Saga 编排示例
public class CreateOrderSaga {
    public void execute(CreateOrderRequest req) {
        SagaContext ctx = new SagaContext();
        try {
            // Step 1: 创建订单
            ctx.orderId = orderService.createOrder(req);
            // Step 2: 扣减库存
            inventoryService.deduct(req.products);
            // Step 3: 扣款
            paymentService.charge(req.paymentInfo);
        } catch (Exception e) {
            // 补偿：反向执行
            if (ctx.orderId != null) {
                paymentService.refund(ctx.paymentId);         // 退款
                inventoryService.restore(req.products);       // 恢复库存
                orderService.cancel(ctx.orderId);             // 取消订单
            }
        }
    }
}

Stage 1: 单体应用
  ┌──────────────────────────────────┐
  │  Monolith (Order + Pay + Prod)  │
  └──────────────────────────────────┘

Stage 2: 路由层引入，新服务逐步建设
  ┌──────────────┐    ┌──────────┐
  │   路由层      │───▶│ 单体     │
  │ (API Gateway) │    └──────────┘
  │              │    ┌──────────┐
  │              │───▶│ 支付服务  │  ← 新拆出来的
  └──────────────┘    └──────────┘

Stage 3: 持续提取，单体逐步萎缩
  ┌──────────────┐    ┌──────────┐
  │   路由层      │    │ 单体     │  ← 越来越小
  │              │    └──────────┘
  │              │    ┌──────────┐
  │              │───▶│ 支付服务  │
  │              │    └──────────┘
  │              │    ┌──────────┐
  │              │───▶│ 订单服务  │  ← 新拆出来的
  └──────────────┘    └──────────┘

Stage 4: 单体完全被替代
  ┌──────────────┐    ┌──────────┐
  │   路由层      │───▶│ 支付服务  │
  │              │    └──────────┘
  │              │    ┌──────────┐
  │              │───▶│ 订单服务  │
  │              │    └──────────┘
  │              │    ┌──────────┐
  │              │───▶│ 商品服务  │
  └──────────────┘    └──────────┘

// Step 1: 定义抽象接口
public interface InventoryService {
    boolean deduct(Long productId, int quantity);
    void restore(Long productId, int quantity);
}

// Step 2: 单体中的实现（直接操作本地数据库）
@Primary
@Service("localInventoryService")
public class LocalInventoryService implements InventoryService {
    @Override
    public boolean deduct(Long productId, int quantity) {
        // 直接操作本地数据库
        return inventoryDao.deduct(productId, quantity) > 0;
    }
}

// Step 3: 远程实现（调用微服务）
@Service("remoteInventoryService")
public class RemoteInventoryService implements InventoryService {
    @Autowired
    private InventoryClient inventoryClient;

    @Override
    public boolean deduct(Long productId, int quantity) {
        // 调用远程微服务
        return inventoryClient.deduct(productId, quantity);
    }
}

// Step 4: 通过配置开关切换
// application.yml
// feature.toggles.inventory-remote: false  → 先关掉
// feature.toggles.inventory-remote: true   → 灰度验证通过后打开

// 一个下单流程跨 7 个服务
public class OrderFlow {
    void placeOrder() {
        userService.validate();         // 1. 用户校验
        productService.checkStock();    // 2. 库存检查
        couponService.verifyCoupon();   // 3. 优惠券校验
        priceService.calculatePrice();  // 4. 价格计算
        orderService.createOrder();     // 5. 创建订单
        paymentService.pay();           // 6. 支付
        notificationService.notify();   // 7. 通知
    }
}

// 查询：同步调用（需要即时结果）
@GetMapping("/order/{id}")
public OrderDetail getOrder(@PathVariable Long id) {
    Order order = orderService.getById(id);
    // 用户需要看到完整的订单详情，这是实时查询
    UserInfo user = userClient.getUser(order.getUserId());  // 同步
    return OrderDetail.of(order, user);
}

// 命令：异步事件（不需要即时结果）
@PostMapping("/order")
public void createOrder(@RequestBody CreateOrderRequest req) {
    orderService.create(req);
    // 订单创建后，通知其他系统——不需要等待结果
    eventBus.publish(new OrderCreatedEvent(order));  // 异步
    // 库存扣减、积分发放、通知发送等下游服务异步消费
}

移动端 ──┐
Web端  ──┼──▶ API Gateway ──▶ 订单服务
第三方 ──┘       │            ──▶ 支付服务
                 │            ──▶ 商品服务
                 ├── 认证鉴权
                 ├── 限流熔断
                 ├── 日志监控
                 ├── 协议转换
                 └── 路由转发

// Spring Cloud + Nacos 服务发现
@Bean
@LoadBalanced  // 开启客户端负载均衡
public RestTemplate restTemplate() {
    return new RestTemplate();
}

// 使用服务名调用，由 Nacos 解析到具体实例
@Autowired
private RestTemplate restTemplate;

public Order callOrderService() {
    // "order-service" 是服务名，不是 IP
    return restTemplate.getForObject(
        "http://order-service/api/orders/123",
        Order.class);
}

原因：无状态、独立业务、不影响核心交易链路
收益：验证了 CI/CD 流程、服务化基础设施、团队获得微服务经验

原因：读多写少、数据可通过 CDC 同步、不影响写入链路
技术方案：Canal 监听 MySQL binlog → 同步到 ES → 查询服务读取 ES

原因：核心链路，需要最谨慎
策略：绞杀者模式，先在灰度环境验证，逐步切流
关键：TCC 分布式事务解决下单、支付、库存的一致性

订单服务 ──▶ 配置服务（行政区划）◀── 物流服务
                │
                └── 数据库：config_db.t_district

订单服务 ── 本地表：order_db.t_district（通过 CDC 同步）
物流服务 ── 本地表：logistics_db.t_district（通过 CDC 同步）

// 补偿操作自带重试
@Retryable(maxAttempts = 3, backoff = @Backoff(delay = 2000))
public void refundCompensation(Long paymentId) {
    paymentService.refund(paymentId);
}

// 补偿失败后写入补偿任务表
@Recover
public void recoverRefund(Exception e, Long paymentId) {
    compensationTaskDao.save(new CompensationTask(
        "refund", paymentId, "PENDING"
    ));
}

// 定时任务扫描未完成的补偿
@Scheduled(fixedDelay = 60000)
public void processPendingCompensations() {
    List<CompensationTask> tasks = compensationTaskDao.findPending();
    for (CompensationTask task : tasks) {
        try {
            executeCompensation(task);
            compensationTaskDao.markAsCompleted(task.getId());
        } catch (Exception e) {
            compensationTaskDao.incrementRetryCount(task.getId());
            if (task.getRetryCount() >= MAX_RETRY) {
                // 第三层：人工介入
                alertService.sendAlert("补偿失败，需人工处理", task);
            }
        }
    }
}

com.example
├── order          // 订单模块（包级别隔离）
│   ├── domain
│   ├── application
│   └── infrastructure
├── payment        // 支付模块（包级别隔离）
│   ├── domain
│   ├── application
│   └── infrastructure
└── shared         // 共享内核

// 新服务上线，但不接流量，只做数据同步验证
@PostMapping("/order")
public void createOrder(@RequestBody Order order) {
    // 1. 写单体数据库（正常流程，不变）
    monolithDb.save(order);
    
    // 2. 异步写新服务数据库（影子模式）
    newOrderClient.createOrderShadow(order);
    
    // 3. 对账：比较两个数据库的数据是否一致
    reconciliationService.compare(order.getId());
}

// 新服务开始接流量，但单体仍然全量写入
@PostMapping("/order")
public void createOrder(@RequestBody Order order) {
    // 同时写两个数据库
    monolithDb.save(order);       // 旧库
    newOrderClient.createOrder(order);  // 新库
    
    // 如果新库写入失败，记录到补偿表
    if (!newWriteSuccess) {
        compensationTaskDao.save(order);
    }
}

// 根据用户 ID 哈希，逐步将读流量切到新服务
public Order getOrder(Long orderId) {
    Long userId = getUserIdByOrderId(orderId);
    if (userId % 100 < grayPercent) {
        return newOrderClient.getOrder(orderId);  // 新服务
    }
    return monolithDb.getOrder(orderId);  // 旧服务
}

// 串行：350ms
UserInfo user = userClient.getUser(userId);           // 50ms
Product product = productClient.getProduct(productId); // 50ms
Inventory inv = inventoryClient.checkStock(productId); // 50ms
Coupon coupon = couponClient.verifyCoupon(couponId);   // 50ms
Price price = priceClient.calculatePrice(items);        // 50ms
// ... 总共 350ms+

// 并行化：≈ 50ms（取最慢的那个）
CompletableFuture<UserInfo> userFuture = 
    CompletableFuture.supplyAsync(() -> userClient.getUser(userId));
CompletableFuture<Product> productFuture = 
    CompletableFuture.supplyAsync(() -> productClient.getProduct(productId));
CompletableFuture<Inventory> invFuture = 
    CompletableFuture.supplyAsync(() -> inventoryClient.checkStock(productId));
CompletableFuture<Coupon> couponFuture = 
    CompletableFuture.supplyAsync(() -> couponClient.verifyCoupon(couponId));

CompletableFuture.allOf(userFuture, productFuture, invFuture, couponFuture).join();

// 订单服务本地冗余商品信息
public class OrderService {
    public void createOrder(CreateOrderRequest req) {
        // 不需要调商品服务，直接用发布时的商品快照
        ProductSnapshot snapshot = productSnapshotCache.get(req.getProductId());
        // 如果缓存未命中，降级调商品服务，但这是少数情况
    }
}

// 不要这样：每个商品调一次库存服务
for (CartItem item : cart.getItems()) {
    inventoryClient.checkStock(item.getProductId());  // N 次调用
}

// 应该这样：一次批量查询
inventoryClient.batchCheckStock(cart.getItemIds());  // 1 次调用