知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 03 - 分布式架构模式 ## 概述 分布式架构模式是解决分布式系统常见问题的通用方案。本章介绍主流的架构模式及其适用场景。 ## 主从模式(Master-Slave) ### 基本架构  ### 特点 | 优点 | 缺点 | |------|------| | 读写分离,提高读性能 | 主节点是单点 | | 架构简单,易于实现 | 复制延迟导致读不一致 | | 从节点可做备份 | 写入无法水平扩展 | ### 应用示例 ```java // MySQL 读写分离配置 public class DataSourceRouter { private DataSource master; private List<DataSource> slaves; private AtomicInteger counter = new AtomicInteger(0); public DataSource route(boolean isWrite) { if (isWrite) { return master; // 写操作走主库 } // 读操作轮询从库 int index = counter.getAndIncrement() % slaves.size(); return slaves.get(index); } } ``` ## 对等模式(Peer-to-Peer) ### 基本架构  *图:去中心化的对等架构,所有节点地位平等都能处理读写* ``` ┌─────────┐ │ Node A │ └────┬────┘ │ ┌────────┼────────┐ │ │ │ ▼ ▼ ▼ ┌───────┐ ┌───────┐ ┌───────┐ │Node B │─│Node C │─│Node D │ └───────┘ └───────┘ └───────┘ │ │ │ └─────────┴─────────┘ 所有节点地位平等,都可以处理读写请求 ``` ### 特点 | 优点 | 缺点 | |------|------| | 无单点故障 | 数据一致性复杂 | | 可水平扩展读写 | 需要解决冲突 | | 任一节点可服务请求 | 运维复杂度高 | ### 典型系统 - **Cassandra**:无中心架构,数据通过一致性哈希分布 - **Redis Cluster**:无中心架构,16384 个槽位分布数据 - **区块链**:完全去中心化的 P2P 网络 ## 微服务架构 ### 架构演进  *图:单体 All In One 拆分为三个微服务并各自独立建库* ``` 单体架构 微服务架构 ┌─────────────────────┐ ┌───────┐ ┌───────┐ ┌───────┐ │ │ │ 用户 │ │ 订单 │ │ 商品 │ │ All In One │ → │ 服务 │ │ 服务 │ │ 服务 │ │ (所有功能在一起) │ └───┬───┘ └───┬───┘ └───┬───┘ │ │ │ │ │ └─────────────────────┘ ┌───▼───┐ ┌───▼───┐ ┌───▼───┐ │用户 DB│ │订单 DB│ │商品 DB│ └───────┘ └───────┘ └───────┘ ``` ### 微服务架构组件  *图:微服务三层结构:API 网关、服务层、基础设施层* ``` ┌─────────────────────────────────────────────────────────────┐ │ API Gateway │ │ (路由、认证、限流、熔断) │ └─────────────────────────────────────────────────────────────┘ │ ┌─────────────────────┼─────────────────────┐ ▼ ▼ ▼ ┌─────────┐ ┌─────────┐ ┌─────────┐ │Service A│◄────────►│Service B│◄────────►│Service C│ └────┬────┘ └────┬────┘ └────┬────┘ │ │ │ ▼ ▼ ▼ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ DB │ │ Cache │ │ Queue │ └─────────┘ └─────────┘ └─────────┘ ┌───────────────────────────────────────────────────────┐ │ 基础设施层 │ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │ │服务注册 │ │配置中心 │ │链路追踪 │ │ │ │发现 │ │ │ │ │ │ │ └──────────┘ └──────────┘ └──────────┘ │ └───────────────────────────────────────────────────────┘ ``` ### 服务间通信 ```java // 同步通信:REST/gRPC @FeignClient(name = "order-service") public interface OrderClient { @GetMapping("/orders/{id}") Order getOrder(@PathVariable("id") Long orderId); } // 异步通信:消息队列 @Service public class OrderEventPublisher { @Autowired private RabbitTemplate rabbitTemplate; public void publishOrderCreated(Order order) { rabbitTemplate.convertAndSend( "order.exchange", "order.created", order ); } } ``` ### 微服务设计原则 1. **单一职责**:每个服务只负责一个业务领域 2. **自治性**:服务独立开发、部署、扩展 3. **去中心化**:数据管理和治理去中心化 4. **弹性设计**:服务能够处理失败和降级 5. **可观测性**:日志、指标、链路追踪 ## 事件驱动架构(EDA) ### 基本模式  *图:生产者发布事件,经 Event Broker 分发给多个消费者* ``` ┌─────────────┐ ┌─────────────┐ │ Producer │ │ Consumer │ │ (事件生产者) │──────────────────────────►│ (事件消费者) │ └─────────────┘ │ └─────────────┘ │ ▼ ┌─────────────────┐ │ Event Broker │ │ (消息中间件) │ │ Kafka/RabbitMQ │ └─────────────────┘ │ ┌───────────────┼───────────────┐ ▼ ▼ ▼ ┌─────────┐ ┌─────────┐ ┌─────────┐ │Consumer1│ │Consumer2│ │Consumer3│ └─────────┘ └─────────┘ └─────────┘ ```  ### 事件类型 | 类型 | 说明 | 示例 | |------|------|------| | **领域事件** | 业务状态变化 | OrderCreated, PaymentCompleted | | **集成事件** | 服务间通信 | 跨服务调用的事件 | | **命令** | 请求执行操作 | CreateOrder, CancelPayment | ### 事件驱动示例 ```java // 领域事件 public class OrderCreatedEvent { private String orderId; private String userId; private BigDecimal amount; private LocalDateTime createdAt; } // 事件发布 @Service public class OrderService { @Autowired private ApplicationEventPublisher eventPublisher; @Transactional public Order createOrder(CreateOrderRequest request) { Order order = orderRepository.save(new Order(request)); // 发布领域事件 eventPublisher.publishEvent(new OrderCreatedEvent( order.getId(), order.getUserId(), order.getAmount(), LocalDateTime.now() )); return order; } } // 事件消费 @Component public class InventoryEventHandler { @EventListener public void handleOrderCreated(OrderCreatedEvent event) { // 扣减库存 inventoryService.deductStock(event.getOrderId()); } } ``` ## CQRS(命令查询职责分离) ### 基本概念  *图:传统读写同库,对比 CQRS 的写库事件同步到读库* ``` 传统架构: CQRS 架构: ┌─────────────┐ ┌─────────────┐ │ Service │ │ Command │ (写操作) │ 读写都在 │ │ Service │ │ 一起处理 │ └──────┬──────┘ └──────┬──────┘ │ │ ┌──────▼──────┐ ┌──────▼──────┐ │ 写数据库 │ │ Database │ │ (Write DB) │ └─────────────┘ └──────┬──────┘ │ 事件/同步 ┌──────▼──────┐ │ 读数据库 │ │ (Read DB) │ └──────┬──────┘ │ ┌──────▼──────┐ │ Query │ (读操作) │ Service │ └─────────────┘ ```  ### CQRS 实现 ```java // Command 模型(写) @Service public class OrderCommandService { @Autowired private OrderRepository orderRepository; @Autowired private EventPublisher eventPublisher; public void createOrder(CreateOrderCommand cmd) { Order order = new Order(cmd); orderRepository.save(order); // 发布事件,同步到读模型 eventPublisher.publish(new OrderCreatedEvent(order)); } } // Query 模型(读) @Service public class OrderQueryService { @Autowired private OrderReadRepository readRepository; // 可以是 ES、Redis public OrderView getOrder(String orderId) { return readRepository.findById(orderId); } public List<OrderView> searchOrders(SearchCriteria criteria) { return readRepository.search(criteria); } } // 事件同步处理器 @Component public class OrderProjection { @EventHandler public void on(OrderCreatedEvent event) { OrderView view = OrderView.from(event); readRepository.save(view); // 写入读库 } } ``` ### CQRS 适用场景 | 适用场景 | 不适用场景 | |----------|------------| | 读写比例严重不均 | 简单 CRUD 系统 | | 读写模型差异大 | 业务逻辑简单 | | 需要复杂查询 | 数据实时性要求极高 | | 高并发读取 | 团队对 CQRS 不熟悉 | ## 事件溯源(Event Sourcing) ### 核心理念  *图:传统方式只存当前状态,事件溯源存全部事件并重放* ``` 传统方式:存储当前状态 ┌─────────────────────────────────────┐ │ Account: { id: 1, balance: 900 } │ └─────────────────────────────────────┘ 事件溯源:存储所有事件 ┌─────────────────────────────────────────────────────────┐ │ Events: │ │ 1. AccountCreated { id: 1, balance: 0 } │ │ 2. MoneyDeposited { id: 1, amount: 1000 } │ │ 3. MoneyWithdrawn { id: 1, amount: 100 } │ │ │ │ 当前状态 = 事件1 + 事件2 + 事件3 = balance: 900 │ └─────────────────────────────────────────────────────────┘ ```  ### 实现示例 ```java // 事件基类 public abstract class DomainEvent { private String aggregateId; private LocalDateTime occurredAt; private int version; } // 具体事件 public class MoneyDepositedEvent extends DomainEvent { private BigDecimal amount; } public class MoneyWithdrawnEvent extends DomainEvent { private BigDecimal amount; } // 聚合根 public class Account { private String id; private BigDecimal balance; private List<DomainEvent> changes = new ArrayList<>(); // 从事件重建状态 public static Account fromEvents(List<DomainEvent> events) { Account account = new Account(); events.forEach(account::apply); return account; } public void deposit(BigDecimal amount) { // 产生事件 apply(new MoneyDepositedEvent(this.id, amount)); } private void apply(DomainEvent event) { if (event instanceof MoneyDepositedEvent e) { this.balance = this.balance.add(e.getAmount()); } else if (event instanceof MoneyWithdrawnEvent e) { this.balance = this.balance.subtract(e.getAmount()); } this.changes.add(event); } public List<DomainEvent> getUncommittedChanges() { return changes; } } // 事件存储 public interface EventStore { void saveEvents(String aggregateId, List<DomainEvent> events); List<DomainEvent> getEvents(String aggregateId); } ``` ### Event Sourcing 优缺点 | 优点 | 缺点 | |------|------| | 完整的审计日志 | 查询复杂度高 | | 可以重放历史 | 事件 schema 演化困难 | | 时间旅行调试 | 最终一致性 | | 事件可用于集成 | 学习曲线陡峭 | ## 架构模式对比  *图:按项目规模选架构:单体、微服务、CQRS、事件溯源* ``` ┌─────────────────────────────────────────────────────────────┐ │ 架构模式选择指南 │ ├─────────────────────────────────────────────────────────────┤ │ │ │ 小型项目 / 初创期 │ │ └── 单体架构 / 主从架构 │ │ │ │ 中型项目 / 成长期 │ │ └── 微服务架构 + 消息队列 │ │ │ │ 大型项目 / 高并发 │ │ └── 微服务 + CQRS + 事件驱动 │ │ │ │ 金融/审计场景 │ │ └── 事件溯源 │ │ │ └─────────────────────────────────────────────────────────────┘ ``` ## 本章小结 - **主从模式**:简单有效的读写分离方案 - **对等模式**:无中心化,高可用但复杂 - **微服务**:服务拆分,独立部署,适合中大型系统 - **事件驱动**:解耦服务,异步通信 - **CQRS**:读写分离,优化读性能 - **事件溯源**:存储事件而非状态,完整审计 ## 思考题 1. 微服务架构中,如何处理分布式事务? 2. CQRS 模式下,读模型和写模型的数据如何保证最终一致? 3. 事件溯源中,如果事件格式发生变化,如何处理历史事件? ## QA ### Q1:微服务架构中,如何处理分布式事务? 微服务里通常不优先用 2PC/XA,而是按场景选择柔性事务方案。短流程且资源可预留时可用 TCC;长流程、跨多个服务时更常用 Saga;大量异步链路则常配合本地消息表或 Outbox 保证最终一致。无论选哪种方案,都需要补偿机制、重试、幂等、去重和对账能力。 ### Q2:CQRS 模式下,读模型和写模型的数据如何保证最终一致? 一般做法是写模型完成后发布领域事件,读模型异步订阅事件并更新自己的投影表。为了保证链路可靠,通常会配合消息队列、Outbox、本地消息表和消费端幂等处理。这样虽然写完后读模型不会立刻同步,但经过重试和补偿后会最终收敛一致。 ### Q3:事件溯源中,如果事件格式发生变化,如何处理历史事件? 最常见的方法是做事件版本化。也就是给事件加 `version` 字段,新代码读取旧事件时通过 upcaster、适配器或转换层把老版本升级成新模型,而不是直接修改历史事件。对于影响特别大的变更,也可以通过重放事件构建新投影,或引入新事件类型替代旧类型,尽量保持历史事件不可变。 --- 下一篇:[04 - 共识基础与 Paxos](./04-consensus-basics.md)
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入