📚 第1章 微服务架构概述

1.1 微服务架构简介

什么是微服务架构

微服务架构（Microservices Architecture）是一种将单一应用程序开发为一组小型服务的方法，每个服务运行在自己的进程中，并使用轻量级机制（通常是HTTP RESTful API）进行通信。这些服务围绕业务功能构建，并且可以由全自动部署机制独立部署。

微服务架构的核心特征

1. 服务组件化

   • 将应用拆分为多个独立的服务
   • 每个服务可以独立开发、部署和扩展
   • 服务间通过明确定义的API进行通信

2. 按业务能力组织

   • 服务围绕业务功能构建
   • 团队负责服务的整个生命周期
   • 跨功能团队（开发、测试、运维）

3. 去中心化治理

   • 每个服务可以选择最适合的技术栈
   • 数据管理去中心化
   • 服务自治性强

4. 基础设施自动化

   • 自动化测试
   • 自动化部署
   • 基础设施即代码

5. 容错设计

   • 服务故障隔离
   • 优雅降级
   • 熔断机制

1.2 微服务 vs 单体架构

单体架构（Monolithic Architecture）

┌─────────────────────────────────────┐
│           单体应用                    │
├─────────────────────────────────────┤
│  用户界面层                          │
├─────────────────────────────────────┤
│  业务逻辑层                          │
│  ├─ 用户管理                         │
│  ├─ 订单处理                         │
│  ├─ 库存管理                         │
│  └─ 支付处理                         │
├─────────────────────────────────────┤
│  数据访问层                          │
├─────────────────────────────────────┤
│  数据库                              │
└─────────────────────────────────────┘

单体架构优点： - 开发简单，易于测试 - 部署简单 - 性能好（内存调用） - 事务处理简单

单体架构缺点： - 技术栈固定 - 扩展困难 - 部署风险大 - 团队协作困难

微服务架构（Microservices Architecture）

┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│  用户服务    │  │  订单服务    │  │  库存服务    │
│             │  │             │  │             │
│ ┌─────────┐ │  │ ┌─────────┐ │  │ ┌─────────┐ │
│ │ API     │ │  │ │ API     │ │  │ │ API     │ │
│ ├─────────┤ │  │ ├─────────┤ │  │ ├─────────┤ │
│ │ 业务逻辑 │ │  │ │ 业务逻辑 │ │  │ │ 业务逻辑 │ │
│ ├─────────┤ │  │ ├─────────┤ │  │ ├─────────┤ │
│ │ 数据层   │ │  │ │ 数据层   │ │  │ │ 数据层   │ │
│ └─────────┘ │  │ └─────────┘ │  │ └─────────┘ │
└─────────────┘  └─────────────┘  └─────────────┘
       │                 │                 │
       ▼                 ▼                 ▼
┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│  用户数据库  │  │  订单数据库  │  │  库存数据库  │
└─────────────┘  └─────────────┘  └─────────────┘

微服务架构优点： - 技术多样性 - 独立部署 - 故障隔离 - 团队自治 - 可扩展性强

微服务架构缺点： - 分布式系统复杂性 - 网络延迟 - 数据一致性 - 运维复杂度高

1.3 Spring Cloud 生态系统

Spring Cloud 简介

Spring Cloud是一系列框架的有序集合，它利用Spring Boot的开发便利性简化了分布式系统的开发，如服务发现、配置管理、消息总线、负载均衡、断路器、数据监控等。

Spring Cloud 核心组件

1. 服务注册与发现

• Eureka：Netflix开源的服务发现组件
• Consul：HashiCorp开源的服务发现和配置管理工具
• Zookeeper：Apache开源的分布式协调服务
• Nacos：阿里巴巴开源的动态服务发现、配置管理平台

2. 服务调用

• Ribbon：客户端负载均衡器
• OpenFeign：声明式服务调用
• LoadBalancer：Spring Cloud自带的负载均衡器

3. 服务熔断

• Hystrix：Netflix开源的熔断器（已停止维护）
• Resilience4j：轻量级的容错库
• Sentinel：阿里巴巴开源的流量控制组件

4. 服务网关

• Zuul：Netflix开源的API网关（已停止维护）
• Gateway：Spring Cloud自研的新一代网关

5. 配置管理

• Config：集中化配置管理
• Nacos Config：动态配置管理

6. 消息总线

• Bus：消息总线，用于配置刷新
• Stream：消息驱动微服务

7. 链路追踪

• Sleuth：分布式链路追踪
• Zipkin：链路追踪数据收集和展示

8. 安全认证

• Security：安全框架
• OAuth2：授权框架

Spring Cloud 版本关系

Spring Cloud Version	Spring Boot Version
2023.0.x (Leyton)	3.2.x
2022.0.x (Kilburn)	3.0.x, 3.1.x
2021.0.x (Jubilee)	2.6.x, 2.7.x
2020.0.x (Ilford)	2.4.x, 2.5.x
Hoxton	2.2.x, 2.3.x
Greenwich	2.1.x
Finchley	2.0.x

1.4 微服务架构设计原则

1. 单一职责原则

每个微服务应该只负责一个业务功能，具有高内聚、低耦合的特点。

// 好的设计：用户服务只负责用户相关功能
@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.findById(id);
    }
    
    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.save(user);
    }
}

2. 服务自治原则

每个服务应该拥有自己的数据存储，避免共享数据库。

# 用户服务配置
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/user_db
    username: user_service
    password: password

---
# 订单服务配置
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/order_db
    username: order_service
    password: password

3. 去中心化原则

避免单点故障，每个服务都应该是独立的。

// 服务间通过API调用，而不是直接访问数据库
@Service
public class OrderService {
    
    @Autowired
    private UserServiceClient userServiceClient;
    
    public Order createOrder(CreateOrderRequest request) {
        // 通过API调用获取用户信息
        User user = userServiceClient.getUserById(request.getUserId());
        
        // 创建订单逻辑
        Order order = new Order();
        order.setUserId(user.getId());
        order.setUserName(user.getName());
        
        return orderRepository.save(order);
    }
}

4. 故障隔离原则

一个服务的故障不应该影响其他服务的正常运行。

// 使用熔断器模式
@Component
public class UserServiceClient {
    
    @Autowired
    private RestTemplate restTemplate;
    
    @HystrixCommand(fallbackMethod = "getUserFallback")
    public User getUserById(Long id) {
        return restTemplate.getForObject(
            "http://user-service/api/users/" + id, 
            User.class
        );
    }
    
    // 降级方法
    public User getUserFallback(Long id) {
        User fallbackUser = new User();
        fallbackUser.setId(id);
        fallbackUser.setName("Unknown User");
        return fallbackUser;
    }
}

1.5 微服务架构挑战

1. 分布式系统复杂性

挑战： - 网络延迟和不可靠性 - 分布式事务处理 - 数据一致性问题

解决方案：

// 使用Saga模式处理分布式事务
@Service
public class OrderSagaService {
    
    @SagaOrchestrationStart
    public void processOrder(OrderCreatedEvent event) {
        // 1. 扣减库存
        sagaManager.choreography()
            .step("inventory-service")
            .action("reduceInventory")
            .compensate("restoreInventory")
            
            // 2. 处理支付
            .step("payment-service")
            .action("processPayment")
            .compensate("refundPayment")
            
            // 3. 发货
            .step("shipping-service")
            .action("shipOrder")
            .compensate("cancelShipping")
            
            .execute(event);
    }
}

2. 服务间通信

挑战： - 服务发现 - 负载均衡 - 服务调用失败处理

解决方案：

// 使用Feign进行服务间调用
@FeignClient(name = "user-service", fallback = UserServiceFallback.class)
public interface UserServiceClient {
    
    @GetMapping("/api/users/{id}")
    User getUserById(@PathVariable("id") Long id);
    
    @PostMapping("/api/users")
    User createUser(@RequestBody User user);
}

@Component
public class UserServiceFallback implements UserServiceClient {
    
    @Override
    public User getUserById(Long id) {
        return User.builder()
            .id(id)
            .name("Unknown")
            .email("unknown@example.com")
            .build();
    }
    
    @Override
    public User createUser(User user) {
        throw new ServiceUnavailableException("User service is currently unavailable");
    }
}

3. 数据管理

挑战： - 数据一致性 - 分布式事务 - 数据同步

解决方案：

// 使用事件驱动架构
@EventHandler
public class OrderEventHandler {
    
    @Autowired
    private InventoryService inventoryService;
    
    @Autowired
    private NotificationService notificationService;
    
    // 处理订单创建事件
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 异步处理库存扣减
        inventoryService.reserveInventory(event.getOrderId(), event.getItems());
        
        // 发送通知
        notificationService.sendOrderConfirmation(event.getUserId(), event.getOrderId());
    }
    
    // 处理支付成功事件
    @EventListener
    public void handlePaymentCompleted(PaymentCompletedEvent event) {
        // 确认库存扣减
        inventoryService.confirmInventoryReservation(event.getOrderId());
        
        // 触发发货流程
        shippingService.initiateShipping(event.getOrderId());
    }
}

4. 运维复杂度

挑战： - 服务部署和管理 - 监控和日志 - 故障排查

解决方案：

# Docker Compose 部署配置
version: '3.8'
services:
  eureka-server:
    image: eureka-server:latest
    ports:
      - "8761:8761"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
  
  user-service:
    image: user-service:latest
    ports:
      - "8081:8080"
    environment:
      - EUREKA_CLIENT_SERVICE_URL_DEFAULTZONE=http://eureka-server:8761/eureka
    depends_on:
      - eureka-server
      - mysql-user
  
  order-service:
    image: order-service:latest
    ports:
      - "8082:8080"
    environment:
      - EUREKA_CLIENT_SERVICE_URL_DEFAULTZONE=http://eureka-server:8761/eureka
    depends_on:
      - eureka-server
      - mysql-order

1.6 微服务架构最佳实践

1. 服务拆分策略

按业务能力拆分：

电商系统服务拆分示例：
├── 用户服务 (User Service)
│   ├── 用户注册/登录
│   ├── 用户信息管理
│   └── 用户权限管理
├── 商品服务 (Product Service)
│   ├── 商品信息管理
│   ├── 商品分类管理
│   └── 商品搜索
├── 订单服务 (Order Service)
│   ├── 订单创建
│   ├── 订单状态管理
│   └── 订单查询
├── 库存服务 (Inventory Service)
│   ├── 库存管理
│   ├── 库存预留
│   └── 库存同步
├── 支付服务 (Payment Service)
│   ├── 支付处理
│   ├── 退款处理
│   └── 支付状态查询
└── 通知服务 (Notification Service)
    ├── 邮件通知
    ├── 短信通知
    └── 推送通知

2. API设计原则

// RESTful API设计
@RestController
@RequestMapping("/api/v1/orders")
public class OrderController {
    
    // 获取订单列表
    @GetMapping
    public ResponseEntity<PagedResponse<OrderDTO>> getOrders(
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "10") int size,
            @RequestParam(required = false) String status) {
        
        PagedResponse<OrderDTO> orders = orderService.getOrders(page, size, status);
        return ResponseEntity.ok(orders);
    }
    
    // 获取单个订单
    @GetMapping("/{orderId}")
    public ResponseEntity<OrderDTO> getOrder(@PathVariable Long orderId) {
        OrderDTO order = orderService.getOrderById(orderId);
        return ResponseEntity.ok(order);
    }
    
    // 创建订单
    @PostMapping
    public ResponseEntity<OrderDTO> createOrder(@Valid @RequestBody CreateOrderRequest request) {
        OrderDTO order = orderService.createOrder(request);
        return ResponseEntity.status(HttpStatus.CREATED).body(order);
    }
    
    // 更新订单状态
    @PatchMapping("/{orderId}/status")
    public ResponseEntity<OrderDTO> updateOrderStatus(
            @PathVariable Long orderId,
            @Valid @RequestBody UpdateOrderStatusRequest request) {
        
        OrderDTO order = orderService.updateOrderStatus(orderId, request.getStatus());
        return ResponseEntity.ok(order);
    }
}

3. 配置管理

# 配置中心配置
spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/company/config-repo
          search-paths: '{application}'
          default-label: main
      discovery:
        enabled: true
        service-id: config-server

# 应用配置
spring:
  application:
    name: order-service
  cloud:
    config:
      discovery:
        enabled: true
        service-id: config-server
      profile: dev
      label: main

4. 监控和日志

// 自定义监控指标
@Component
public class OrderMetrics {
    
    private final MeterRegistry meterRegistry;
    private final Counter orderCreatedCounter;
    private final Timer orderProcessingTimer;
    
    public OrderMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.orderCreatedCounter = Counter.builder("orders.created")
            .description("Number of orders created")
            .register(meterRegistry);
        this.orderProcessingTimer = Timer.builder("orders.processing.time")
            .description("Order processing time")
            .register(meterRegistry);
    }
    
    public void incrementOrderCreated() {
        orderCreatedCounter.increment();
    }
    
    public Timer.Sample startOrderProcessing() {
        return Timer.start(meterRegistry);
    }
    
    public void recordOrderProcessingTime(Timer.Sample sample) {
        sample.stop(orderProcessingTimer);
    }
}

1.7 总结

微服务架构是一种强大的架构模式，它能够帮助组织构建可扩展、可维护的分布式系统。然而，它也带来了额外的复杂性，需要团队具备相应的技术能力和运维经验。

选择微服务架构的考虑因素：

1. 团队规模：大型团队更适合微服务架构
2. 业务复杂度：复杂业务场景受益于服务拆分
3. 技术能力：需要具备分布式系统开发和运维能力
4. 扩展需求：需要独立扩展不同业务模块
5. 部署频率：需要频繁独立部署不同服务

微服务架构成功的关键：

1. 合理的服务拆分：基于业务边界进行拆分
2. 完善的基础设施：服务发现、配置管理、监控等
3. 自动化运维：CI/CD、容器化部署
4. 团队文化：DevOps文化，全栈团队
5. 渐进式演进：从单体架构逐步演进到微服务

Spring Cloud为微服务架构提供了完整的解决方案，在后续章节中，我们将深入学习Spring Cloud的各个组件，掌握构建企业级微服务系统的技能。