微服务架构设计：拆分与通信策略

为什么要微服务？

单体架构痛点

• 代码库庞大，难以维护
• 部署风险高，牵一发而动全身
• 技术栈固化，难以升级
• 团队协同困难

微服务优势

• 独立部署，快速迭代
• 技术栈灵活，按需选择
• 故障隔离，提高可用性
• 团队自治，提高效率

服务拆分原则

1. 单一职责原则

每个服务只负责一个业务领域

2. 高内聚低耦合

相关功能放在一起，减少依赖

3. 基于业务边界

按业务领域（DDD）拆分，而非技术层

┌─────────────────────────────────────┐
│           API Gateway               │
└─────────────────────────────────────┘
         │         │         │
┌────────┴─┐ ┌─────┴───┐ ┌───┴─────┐
│ 用户服务  │ │ 订单服务 │ │ 支付服务 │
│  - 注册  │ │  - 下单  │ │  - 付款  │
│  - 登录  │ │  - 查询  │ │  - 退款  │
│  - 资料  │ │  - 取消  │ │  - 对账  │
└──────────┘ └─────────┘ └─────────┘

服务通信方式

同步通信：HTTP/REST

// 用户服务调用订单服务
@RestController
public class OrderController {
    @Autowired
    private RestTemplate restTemplate;
    
    @GetMapping("/orders/{id}")
    public Order getOrder(@PathVariable Long id) {
        return restTemplate.getForObject(
            "http://order-service/orders/" + id,
            Order.class
        );
    }
}

同步通信：gRPC

// proto 定义
service UserService {
  rpc GetUser(GetUserRequest) returns (User);
}

message GetUserRequest {
  int64 user_id = 1;
}

异步通信：消息队列

// 订单创建后发送消息
@Autowired
private KafkaTemplate<String, OrderEvent> kafkaTemplate;

public void createOrder(Order order) {
    orderRepository.save(order);
    kafkaTemplate.send("order-created", new OrderEvent(order));
}

// 库存服务监听
@KafkaListener(topics = "order-created")
public void handleOrderCreated(OrderEvent event) {
    inventoryService.reserve(event.getItems());
}

服务发现

Client-Side Discovery

// Ribbon + Eureka
@LoadBalanced
@Bean
public RestTemplate restTemplate() {
    return new RestTemplate();
}

// 直接通过服务名调用
restTemplate.getForObject("http://order-service/orders/1", Order.class);

Server-Side Discovery

通过负载均衡器（Nginx、ALB）转发

配置中心

# Spring Cloud Config
spring:
  cloud:
    config:
      uri: http://config-server:8888
      name: order-service
      profile: prod

熔断与降级

@Service
public class OrderService {
    
    @HystrixCommand(fallbackMethod = "getOrderFallback")
    public Order getOrder(Long id) {
        return orderClient.getOrder(id);
    }
    
    public Order getOrderFallback(Long id) {
        // 降级逻辑：返回缓存或默认值
        return new Order(id, "UNKNOWN");
    }
}

分布式事务

Saga 模式

// 编排式 Saga
public class OrderSaga {
    public void createOrder(Order order) {
        try {
            orderService.create(order);
            inventoryService.reserve(order.getItems());
            paymentService.charge(order.getAmount());
        } catch (Exception e) {
            // 补偿事务
            paymentService.refund(order.getAmount());
            inventoryService.cancel(order.getItems());
            orderService.cancel(order.getId());
        }
    }
}

最佳实践

1. API 版本控制 - /api/v1/users
2. 统一错误处理 - 标准化错误响应
3. 链路追踪 - Zipkin、Jaeger
4. 限流降级 - Sentinel、Hystrix
5. 健康检查 - /health 端点

微服务架构需要权衡复杂度与收益，适合中大型系统！