微服务相关八股文

Loen

十月 14, 2025

微服务架构深度解析

1. 微服务如何拆分？

1.1 拆分原则

1.1.1 单一职责原则

1
2
3
4
5
6
graph TB
    A[电商系统] --> B[用户服务]
    A --> C[商品服务]
    A --> D[订单服务]
    A --> E[支付服务]
    A --> F[库存服务]

1.1.2 领域驱动设计（DDD）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 基于限界上下文的拆分
public class BoundedContext {
    // 用户上下文
    class UserContext {
        - User
        - Profile
        - Authentication
    }
    
    // 订单上下文
    class OrderContext {
        - Order
        - OrderItem
        - Shipping
    }
    
    // 商品上下文
    class ProductContext {
        - Product
        - Category
        - Inventory
    }
}

1.1.3 共同闭包原则

同时变化的模块放在同一个服务中
变更频率相似的业务放在一起

1.2 拆分策略

1.2.1 按业务能力拆分

1
2
3
4
5
6
7
电商平台拆分：
├── 用户服务 (User Service)
├── 商品服务 (Product Service) 
├── 订单服务 (Order Service)
├── 支付服务 (Payment Service)
├── 库存服务 (Inventory Service)
└── 物流服务 (Shipping Service)

1.2.2 按领域模型拆分

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
// 识别聚合根
@Entity
public class Order {  // 订单聚合根
    private Long orderId;
    private List<OrderItem> items;
    private ShippingAddress address;
}

@Entity  
public class Product {  // 商品聚合根
    private Long productId;
    private String name;
    private BigDecimal price;
}

1.2.3 按数据模型拆分

1
2
3
4
5
6
7
8
-- 用户数据库
CREATE TABLE users (id, username, email, created_at);

-- 商品数据库  
CREATE TABLE products (id, name, price, stock);

-- 订单数据库
CREATE TABLE orders (id, user_id, total_amount, status);

1.3 拆分步骤

1.3.1 识别业务边界

1
2
3
4
5
6
flowchart TD
    A[分析业务流程] --> B[识别业务实体]
    B --> C[定义业务边界]
    C --> D[识别服务依赖]
    D --> E[确定服务接口]
    E --> F[设计数据模型]

1.3.2 服务粒度评估

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
public class ServiceGranularity {
    // 过粗的服务
    class MonolithicService {
        - userManagement()
        - productManagement() 
        - orderProcessing()
        - paymentHandling()
    }
    
    // 合适的服务粒度
    class ProperService {
        class UserService { - userManagement() }
        class ProductService { - productManagement() }
        class OrderService { - orderProcessing() }
        class PaymentService { - paymentHandling() }
    }
}

2. 微服务构建使用完成后后续如何解耦拆分？

2.1 识别解耦需求

2.1.1 监控指标分析

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
public class DecouplingIndicators {
    // 性能指标
    private double responseTime;      // 响应时间增长
    private double errorRate;         // 错误率上升
    private double resourceUsage;     // 资源使用率过高
    
    // 业务指标
    private int changeFrequency;      // 变更频率
    private int teamBlocking;         // 团队间阻塞
    private double deploymentFrequency; // 部署频率下降
}

2.1.2 依赖关系分析

1
2
3
4
5
6
7
8
9
graph LR
    A[服务A] --> B[服务B]
    A --> C[服务C]
    B --> D[服务D]
    C --> D
    D --> E[服务E]
    
    style D fill:#f96
    style E fill:#f96

2.2 解耦策略

2.2.1 数据库解耦

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
-- 解耦前：共享数据库
-- 所有服务访问同一个数据库

-- 解耦后：数据库分离
-- 用户服务数据库
CREATE DATABASE user_db;

-- 订单服务数据库  
CREATE DATABASE order_db;

-- 商品服务数据库
CREATE DATABASE product_db;

2.2.2 API 解耦

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// 解耦前：直接调用
@Service
public class OrderService {
    @Autowired
    private UserService userService;  // 直接依赖
    
    public void createOrder(Order order) {
        User user = userService.getUser(order.getUserId());  // 同步调用
        // 处理订单
    }
}

// 解耦后：事件驱动
@Service
public class OrderService {
    @Autowired
    private EventPublisher eventPublisher;
    
    public void createOrder(Order order) {
        eventPublisher.publish(new OrderCreatedEvent(order));  // 发布事件
    }
}

@Service
public class UserService {
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 异步处理用户相关逻辑
    }
}

2.2.3 服务拆分步骤

1
2
3
4
5
6
7
flowchart TD
    A[识别耦合点] --> B[设计解耦方案]
    B --> C[创建新服务]
    C --> D[数据迁移]
    D --> E[API切换]
    E --> F[验证测试]
    F --> G[停用旧功能]

2.3 解耦技术实现

2.3.1 事件驱动架构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// 事件定义
public class OrderCreatedEvent {
    private String orderId;
    private Long userId;
    private BigDecimal amount;
    private LocalDateTime createdAt;
}

// 事件发布
@Component
public class EventPublisher {
    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;
    
    public void publishOrderCreated(Order order) {
        OrderCreatedEvent event = new OrderCreatedEvent(order);
        applicationEventPublisher.publishEvent(event);
    }
}

// 事件处理
@Component
public class UserPointsHandler {
    @EventListener
    @Async
    public void handleOrderCreated(OrderCreatedEvent event) {
        // 异步处理用户积分
        userService.addPoints(event.getUserId(), calculatePoints(event.getAmount()));
    }
}

2.3.2 API 网关解耦

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
# API Gateway 路由配置
spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/api/users/**
        - id: order-service  
          uri: lb://order-service
          predicates:
            - Path=/api/orders/**
        - id: product-service
          uri: lb://product-service
          predicates:
            - Path=/api/products/**

3. 项目管理如何操作的？

3.1 微服务项目管理框架

3.1.1 团队组织架构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
graph TB
    A[产品负责人] --> B[架构师团队]
    A --> C[业务领域团队]
    
    C --> D[用户服务团队]
    C --> E[订单服务团队] 
    C --> F[商品服务团队]
    C --> G[支付服务团队]
    
    B --> H[平台支撑团队]
    H --> I[配置中心]
    H --> J[监控平台]
    H --> K[CI/CD流水线]

3.1.2 项目治理结构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class ProjectGovernance {
    // 技术决策委员会
    class TechnicalCommittee {
        - approveArchitecture()
        - reviewStandards()
        - resolveConflicts()
    }
    
    // 领域团队
    class DomainTeam {
        - designService()
        - implementFeatures()
        - operateService()
    }
    
    // 平台团队  
    class PlatformTeam {
        - provideInfrastructure()
        - maintainTools()
        - supportTeams()
    }
}

3.2 开发流程管理

3.2.1 敏捷开发流程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
sprint
title 2周迭代周期
dateFormat YYYY-MM-DD

section 需求阶段
需求梳理 :done, des1, 2023-10-01, 2d
技术方案评审 :active, des2, 2023-10-03, 1d

section 开发阶段 
服务A开发 :dev1, 2023-10-04, 4d
服务B开发 :dev2, 2023-10-04, 3d

section 测试阶段
集成测试 :test1, after dev1, 3d
端到端测试 :test2, after test1, 2d

section 发布阶段
生产发布 :release, after test2, 1d

3.2.2 CI/CD 流水线

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# .gitlab-ci.yml 示例
stages:
  - test
  - build
  - deploy

unit_test:
  stage: test
  script:
    - mvn test
  only:
    - merge_requests

build_service:
  stage: build  
  script:
    - mvn clean package -DskipTests
    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
  only:
    - main

deploy_dev:
  stage: deploy
  script:
    - kubectl set image deployment/user-service user-service=$CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
  environment:
    name: dev
  only:
    - main

3.3 依赖和版本管理

3.3.1 服务依赖管理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# 服务依赖配置
service-dependencies:
  order-service:
    required:
      - user-service:v1.2.0
      - product-service:v2.1.0
    optional:
      - promotion-service:v1.0.0
      
  payment-service:
    required:
      - order-service:v1.3.0
      - notification-service:v1.1.0

3.3.2 API 版本管理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
// API版本控制
@RestController
@RequestMapping("/api/v1/users")
public class UserControllerV1 {
    @GetMapping("/{id}")
    public User getUserV1(@PathVariable Long id) {
        // V1版本逻辑
    }
}

@RestController  
@RequestMapping("/api/v2/users")
public class UserControllerV2 {
    @GetMapping("/{id}")
    public UserResponse getUserV2(@PathVariable Long id) {
        // V2版本逻辑，返回结构不同
    }
}

4. 微服务的理解

4.1 核心概念

4.1.1 微服务定义

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
public class MicroserviceDefinition {
    // 单一职责
    - eachServiceHasSingleResponsibility()
    
    // 独立部署
    - independentlyDeployable()
    
    // 技术异构  
    - polyglotPersistence()
    - technologyDiversity()
    
    // 去中心化治理
    - decentralizedGovernance()
    - decentralizedDataManagement()
}

4.1.2 微服务 vs 单体架构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
graph TD
    subgraph 单体架构
        A[Monolithic App] --> B[所有功能耦合]
        B --> C[单一技术栈]
        C --> D[统一部署]
        D --> E[扩展困难]
    end
    
    subgraph 微服务架构
        F[Service A] --> G[独立功能]
        H[Service B] --> G
        I[Service C] --> G
        G --> J[技术多样性]
        J --> K[独立部署]
        K --> L[弹性扩展]
    end

4.2 微服务优势

4.2.1 技术优势

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class TechnicalAdvantages {
    // 技术栈灵活性
    public void technologyFlexibility() {
        // 不同服务可以使用不同技术栈
        UserService -> Java/Spring Boot
        AnalyticsService -> Python/FastAPI  
        RecommendationService -> Go/Gin
    }
    
    // 独立扩展
    public void independentScaling() {
        // 根据负载单独扩展服务
        kubernetes.scale("user-service", 2);     // 2个副本
        kubernetes.scale("order-service", 5);    // 5个副本
        kubernetes.scale("product-service", 3);  // 3个副本
    }
    
    // 容错性
    public void faultTolerance() {
        // 一个服务故障不影响其他服务
        try {
            paymentService.processPayment(order);
        } catch (ServiceUnavailableException e) {
            // 支付服务宕机，但订单服务仍可用
            orderService.markAsPending(order);
        }
    }
}

4.2.2 组织优势

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
public class OrganizationalAdvantages {
    // 团队自治
    private TeamAutonomy teamAutonomy;
    
    // 快速交付
    private DeploymentFrequency deploymentFrequency;
    
    // 技术创新
    private TechnologyInnovation innovation;
    
    // 专注领域
    private DomainFocus domainFocus;
}

4.3 微服务挑战

4.3.1 技术挑战

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
public class TechnicalChallenges {
    // 分布式系统复杂性
    private DistributedComplexity complexity;
    
    // 数据一致性
    private DataConsistency consistency;
    
    // 服务发现和通信
    private ServiceDiscovery discovery;
    private ServiceCommunication communication;
    
    // 测试复杂性
    private TestingComplexity testing;
}

4.3.2 运维挑战

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
# 运维复杂度增加
operational_challenges:
  monitoring: 
    - 分布式追踪
    - 日志聚合
    - 指标监控
    
  deployment:
    - 容器编排
    - 服务网格
    - 配置管理
    
  networking:
    - 服务发现
    - 负载均衡
    - 网络安全

4.4 最佳实践

4.4.1 设计原则

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
public class DesignPrinciples {
    // 围绕业务领域建模
    public void domainDrivenDesign() {
        // 使用DDD战术设计
        // 识别聚合根、实体、值对象
    }
    
    // 自动化一切
    public void automateEverything() {
        // CI/CD流水线
        // 基础设施即代码
        // 自动化测试
    }
    
    // 文化和流程
    public void cultureAndProcess() {
        // DevOps文化
        // 你构建，你运行
        // 持续改进
    }
}

4.4.2 演进策略

1
2
3
4
5
6
7
8
9
flowchart LR
    A[单体应用] --> B[识别拆分候选]
    B --> C[提取第一个服务]
    C --> D[建立基础设施]
    D --> E[逐步拆分更多服务]
    E --> F[成熟微服务架构]
    
    style A fill:#e1f5fe
    style F fill:#e8f5e8

总结

微服务架构是一种将应用程序构建为一组小型服务的架构风格，每个服务运行在自己的进程中，服务之间通过轻量级机制（通常是 HTTP API）进行通信。成功的微服务实施需要：

合理的服务拆分 - 基于业务领域和团队结构
渐进式解耦 - 识别瓶颈，逐步优化架构
有效的项目管理 - 适应分布式团队的治理模式
全面的技术理解 - 认识优势同时正视挑战

微服务不是银弹，而是一种需要相应技术能力和组织成熟度支撑的架构选择。