面试系统设计:交易风控与 Kafka

通识对照:Kafka 架构通识:分区日志、副本 ISR 与消费者组

面试系统设计:交易风控与 Kafka

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。


面试场景:交易/支付风控部门,要求设计一套可靠、高吞吐的流式风控数据系统 核心挑战:多源异构数据聚合、消息不丢失不重复、状态一致性、毫秒级延迟决策


一、业务场景与问题定义

1.1 场景描述

在一个加密货币交易所或电商交易平台的风控部门,需要对每一笔交易进行全链路实时风控判断:

一笔完整的交易包含多个业务阶段,每个阶段由不同微服务产生事件:

业务阶段产生服务关键数据
1. 用户下单Order Serviceuser_id, order_id, symbol, side, quantity, price, timestamp
2. 风控预检Risk Pre-check Servicedevice_fingerprint, ip_geo, velocity_check_result
3. 用户支付Payment Servicepayment_method, amount, currency, bank/card_info_hash
4. 资金冻结Wallet Servicefreeze_tx_id, frozen_balance, margin_ratio
5. 订单撮合/执行Matching/Trade Servicefill_price, fill_qty, counterparty_info
6. 资金清算Settlement Servicesettlement_tx_id, fee, net_amount

风控侧的要求:

  • 必须在下单前完成实时预检(< 50ms)
  • 必须在支付后、撮合前完成综合风控判断(< 100ms)
  • 必须在清算后完成事后审计与异常检测(秒级即可)
  • 需要聚合一笔订单的所有阶段数据,形成完整视图后才能做综合判断

1.2 核心挑战

  1. 多源异构数据聚合:6 个阶段由 6 个不同服务产生,数据格式、产生时间、频率都不同
  2. 消息可靠性:Kafka 消息不能丢、不能重复、顺序不能乱
  3. 状态一致性:风控判断依赖"订单当前处于哪个阶段",需要维护跨阶段的状态机
  4. 延迟要求:关键路径(预检)必须 < 50ms,综合判断 < 100ms
  5. 吞吐量:交易所场景下,每秒 10万+ 笔订单,Kafka 峰值 50万+ msg/s

二、总体架构设计

2.1 架构全景图

2.2 各层职责

层级组件职责
数据采集层Order/Payment/Trade Service产生领域事件,写入对应 Kafka Topic
消息总线层Kafka Cluster分区、副本、持久化,保证消息不丢
流处理层Flink / Kafka Streams多流 Join、窗口聚合、状态管理
状态存储层RocksDB (本地) + Redis (共享)维护订单全生命周期状态、特征缓存
决策引擎层Risk Engine规则匹配、ML 推理、综合打分
决策输出层Decision API / Webhook同步返回拦截/放行,异步下发处置指令
审计分析层ClickHouse + Grafana事后分析、模型训练、报表

三、Kafka Topic 与分区策略设计

3.1 Topic 划分原则

原则一:按业务领域拆分 Topic,避免单 Topic 过大
原则二:关键路径 Topic 独立分区,保证顺序和延迟
原则三:风控信号 Topic 单独拆分,与业务事件解耦

3.2 具体 Topic 设计

Topic分区数Key说明
trade.order.created12order_id订单相关事件,按 order_id 分区保证单订单顺序
trade.payment.result12order_id支付结果,必须与订单同 Key
trade.wallet.freeze12order_id资金冻结
trade.matching.fill24symbol按交易对分区,撮合是高并发场景
trade.settlement.done12order_id清算完成
risk.signal.device6user_id设备指纹,按用户聚合
risk.signal.behavior6user_id行为特征,如登录异常、IP 变动
risk.decision.result12order_id风控决策结果输出

3.3 分区 Key 的选择理由

Key = order_id 的核心原因:

1. 保证单订单全链路事件的顺序性
   Kafka 保证:同一个 Partition 内,消息按 Key 顺序写入和消费
   如果 order.created 和 payment.result 使用相同的 order_id 作为 Key,
   它们会落入同一个 Partition,消费者一定能按顺序看到这两个事件

2. 保证多流 Join 的局部性
   Flink / Kafka Streams 在处理 keyed stream 时,会将相同 Key 的数据
   路由到同一个 Task/Partition,本地状态访问效率最高

例外场景:
- matching.fill 按 symbol 分区,因为撮合是高频、低延迟场景,
  同一个交易对的大量成交需要并行处理,不需要按 order_id 顺序

四、关键路径设计:实时风控预检(< 50ms)

4.1 预检流程

4.2 为什么预检不走 Kafka?

预检要求 < 50ms,Kafka 的延迟在毫秒到几十毫秒级,且消费者是异步的,
无法满足同步 API 的延迟要求。

所以预检路径是:同步 HTTP/gRPC 调用 → 直接查询 Redis 特征缓存 → 规则引擎判断

Kafka 在这里的角色是:
1. 异步产生 risk.signal 事件,供流处理层更新特征
2. 异步产生 audit log,供事后分析
3. 复杂规则(如跨订单聚合、时间窗口判断)由 Flink CEP 异步处理,
   结果写入 Redis,影响下一笔订单的预检

五、综合风控判断:多流聚合与状态管理

5.1 场景定义

一笔订单从创建到清算,风控需要在支付完成后、撮合前做一次综合判断:

综合判断需要的数据:
- 订单基本信息(品种、方向、数量、价格)
- 用户历史特征(7日交易量、亏损比例、提现频率)
- 支付信息(支付方式、金额、是否跨境)
- 设备与环境(设备指纹、IP 地理位置、是否虚拟机)
- 行为模式(下单频率、撤单率、是否跟单)
- 对手方信息(是否高风险地址、是否涉及洗钱地址)
// 1. Interval Join:订单流与支付流按 order_id 关联
// 允许支付事件在订单创建后 0~5 分钟内到达
orderStream
    .keyBy(OrderEvent::getOrderId)
    .intervalJoin(paymentStream.keyBy(PaymentEvent::getOrderId))
    .between(Time.seconds(0), Time.minutes(5))
    .process(new OrderPaymentJoinFunction())
    .keyBy(JoinedEvent::getUserId)
    .connect(deviceSignalStream.keyBy(DeviceSignal::getUserId))
    .process(new EnrichWithDeviceFunction());
 
// 2. Async I/O:异步查询外部特征存储(Redis / Feature Store)
// 避免阻塞流处理线程
DataStream<OrderRiskView> enrichedStream = AsyncDataStream
    .unorderedWait(
        joinedStream,
        new AsyncFeatureLookupFunction(redisPool),
        100, TimeUnit.MILLISECONDS,
        100  // 并发请求数
    );
 
// 3. 风控规则判断
enrichedStream
    .map(new RiskRuleEvaluator(ruleEngine))
    .addSink(new KafkaSink<>("risk.decision.result"));

5.4 状态一致性保障

Flink 的 Checkpoint 机制:

1. 每 10 秒触发一次 Checkpoint,将算子状态(包括窗口状态、Join 状态)
   持久化到分布式存储(HDFS / S3)

2. Exactly-Once 语义:
   - Kafka Source:记录消费的 Offset,与状态一起 Checkpoint
   - Kafka Sink:两阶段提交(2PC),先预写事务,Checkpoint 成功后提交事务

3. 状态 TTL:
   - Join 状态保留 10 分钟(超过 10 分钟未收到支付,订单自动取消)
   - 用户行为窗口保留 7 天(滑动窗口)

六、消息可靠性:不丢失、不重复、顺序性

6.1 消息不丢失(Producer → Kafka → Consumer)

Producer 端:Outbox 模式

核心问题:业务数据库操作和 Kafka 发送不是原子性的。
如果 DB 提交成功但 Kafka 发送失败(或反之),数据就会不一致。

解决方案:Outbox 模式

1. 业务操作和消息写入在同一个本地事务中:
   BEGIN;
     INSERT INTO orders (...) VALUES (...);
     INSERT INTO outbox (topic, key, payload, headers) VALUES (...);
   COMMIT;

2. 单独的 Relay 进程(CDC 或轮询)读取 outbox 表,发送到 Kafka

3. 发送成功后标记 outbox 记录为已处理(或删除)

优势:
- 利用 DB 事务的原子性,保证"业务发生 → 消息必产生"
- 即使 Kafka 暂时不可用,消息也会保存在 outbox 中,不会丢失
- Relay 进程可以重试,直到发送成功

Kafka 端:副本与 ISR 策略

# Kafka 配置
default.replication.factor=3        # 每个分区 3 个副本
min.insync.replicas=2               # 写入至少同步 2 个副本才算成功
acks=all                            # Producer 等待所有 ISR 确认
unclean.leader.election.enable=false # 不允许非同步副本成为 Leader
retention.ms=604800000              # 消息保留 7 天
为什么 unclean.leader.election=false?

如果 Leader 宕机,Kafka 会从 ISR(In-Sync Replicas)中选举新 Leader。
如果 ISR 为空,unclean.leader.election=true 会允许从非同步副本中选举,
这可能导致消息丢失(非同步副本可能缺少最新的消息)。

对于交易风控场景,绝对不能容忍消息丢失,所以必须设为 false。
代价是:如果所有 ISR 都挂了,该分区会暂时不可用(宁愿不可用,也不丢数据)。

Consumer 端:手动提交 + 幂等处理

// Kafka Consumer 配置
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");
props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, "500");
props.put(ConsumerConfig.ISOLATION_LEVEL_CONFIG, "read_committed");
 
// 消费逻辑
while (true) {
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
 
    for (ConsumerRecord<String, String> record : records) {
        try {
            // 1. 业务处理
            process(record);
 
            // 2. 将 Offset 和状态一起存入外部存储(如 Redis)
            storeOffsetAndState(record.offset(), processedState);
        } catch (Exception e) {
            // 3. 失败不提交 Offset,进入重试队列
            sendToRetryTopic(record);
        }
    }
 
    // 4. 批量同步提交(可选,看一致性要求)
    consumer.commitSync();
}

6.2 消息不重复:幂等设计

重复消息的来源:
1. Producer 重试:发送超时后重试,实际第一次已成功
2. Consumer 重启:Offset 未提交,重启后重新消费
3. 网络抖动:Kafka 确认丢失,Producer 重发

解决方案:业务层幂等

方案一:数据库唯一约束(最简单)

-- 风控判断结果表
CREATE TABLE risk_decisions (
    order_id VARCHAR(64) PRIMARY KEY,
    decision VARCHAR(20),       -- PASS / REVIEW / BLOCK
    score DECIMAL(5,2),
    created_at TIMESTAMP
);
 
-- 如果重复消费,INSERT 会报主键冲突,捕获异常即可

方案二:Redis + Lua 原子脚本(高性能)

-- 检查并标记 order_id 是否已处理
local key = KEYS[1]
local order_id = ARGV[1]
local ttl = ARGV[2]
 
if redis.call("SISMEMBER", key, order_id) == 1 then
    return 0  -- 已处理,幂等跳过
end
 
redis.call("SADD", key, order_id)
redis.call("EXPIRE", key, ttl)
return 1  -- 首次处理
// Java 调用
Long result = jedis.eval(luaScript,
    Collections.singletonList("risk:processed"),
    Arrays.asList(orderId, "86400")  // 24小时过期
);
 
if (result == 0) {
    log.info("Duplicate message skipped: {}", orderId);
    return;
}

方案三:状态机幂等(复杂场景)

一笔订单有状态机:CREATED → PAID → FROZEN → MATCHED → SETTLED

如果重复收到 PAID 事件:
- 当前状态是 CREATED → 正常处理
- 当前状态已经是 PAID → 幂等跳过
- 当前状态是 MATCHED → 日志告警(乱序,但不需要处理)

好处:不仅防重复,还防乱序

6.3 消息顺序性保障

Kafka 只能保证 Partition 内有序,不保证 Topic 全局有序。

我们的策略:

1. 同一笔订单的所有事件,使用相同的 order_id 作为 Key
2. 保证这些事件发送到同一个 Partition
3. 消费者单线程消费该 Partition(或 Kafka Streams/Flink 的 Keyed Stream)

Mermaid 图解:
极端情况:
如果某个 order_id 产生的事件量特别大(如高频交易策略),
单 Partition 可能成为瓶颈。

解决方案:
- 监控 Partition 消费延迟(consumer lag)
- 如果某个 Key 热点严重,可以进一步拆分(如 order_id + 时间窗口)
- 或者将"顺序要求"和"吞吐量要求"分离:
  关键状态变更必须顺序,但审计日志可以并行

七、性能优化:吞吐量与响应速度

7.1 吞吐量提升(Kafka Consumer)

优化手段配置/方法效果
批量消费max.poll.records=500单次拉取更多消息
多分区并行Partition 数 = Consumer 实例数理想 1:1 配比
异步处理消费线程只负责入队,业务线程异步处理解耦消费与处理
零拷贝Kafka 本身的 sendfile 机制减少数据拷贝
压缩compression.type=lz4降低网络带宽
批提交 Offset每 N 条或每 M 秒提交一次减少 Offset Commit 开销

7.2 响应速度优化(风控判断)

优化手段实现方式效果
本地缓存Caffeine / Guava Cache热点特征内存命中,微秒级
预计算特征Flink 实时聚合写入 Redis查询时无需计算
规则预编译Drools / EasyRules 规则编译为决策树避免运行时解释
异步特征补全核心规则同步判断,复杂特征异步加载保证关键路径延迟
模型量化XGBoost/LightGBM 模型转换为 PMML/ONNX降低推理延迟
决策结果缓存相同输入缓存决策结果避免重复计算

7.3 典型性能数字

目标场景:10万 QPS 订单,每笔订单 5 个阶段事件,Kafka 峰值 50万 msg/s

优化后预期:
- 风控预检:p99 < 30ms(同步 Redis + 规则引擎)
- 综合判断:p99 < 80ms(Flink 多流 Join + 特征补全)
- Kafka 消费延迟:p99 < 1s(Flink 处理)
- 端到端延迟(下单 → 风控决策):p99 < 200ms
- 可用性:99.99%(全年停机 < 1小时)

八、异常场景与应对策略

8.1 Kafka 消息积压(Consumer Lag 过高)

现象:业务高峰期间,消费者处理速度跟不上生产速度,Lag 持续增长

应对策略:

1. 水平扩容消费者
   - Kafka Consumer Group 支持动态扩容
   - 新增 Consumer 实例,自动重新分配 Partition
   - 注意:Partition 数要 >= Consumer 实例数,否则扩容无效

2. 降级处理
   - 非关键路径(如审计日志)可以采样处理(如只处理 10%)
   - 关键路径(如风控判断)保持全量,但简化规则

3. 背压(Backpressure)
   - Flink 天然支持背压:下游慢时,自动减缓上游消费速度
   - 避免 OOM 或消息丢失

4. 临时存储
   - 如果 Kafka 本身也成为瓶颈(磁盘 I/O),可以引入 Kafka MirrorMaker
     或多集群架构,将流量分散

8.2 消费者故障与重启

现象:Consumer 实例宕机或重启,Partition 重新分配

应对策略:

1. 优雅关闭
   - 捕获 SIGTERM,先完成当前批次处理,再提交 Offset,最后退出
   - Kubernetes 中配置 preStop Hook

2. Rebalance 优化
   - 使用 Kafka 的 Cooperative Rebalance(增量重平衡),
     避免每次扩容/缩容都触发全局重新分配
   - 设置 session.timeout.ms=45s, heartbeat.interval.ms=15s

3. 状态恢复
   - Flink 从最近的 Checkpoint 恢复状态,保证 Exactly-Once
   - 如果状态存储在 RocksDB,重启后自动加载

8.3 乱序消息与延迟到达

现象:由于网络抖动或 Producer 重试,支付事件比订单创建事件先到

应对策略:

1. Flink Event Time + Watermark
   - 使用事件时间(Event Time)而非处理时间(Processing Time)
   - 设置 Watermark 允许最大乱序时间(如 30 秒)
   - 在 Watermark 内的乱序数据会被缓冲并正确排序

2. 状态机校验
   - 如果 PAID 事件先到,但状态机中没有 CREATED,
     将 PAID 放入"待处理缓冲区"
   - 等待 CREATED 到达后,再按顺序处理
   - 如果超过最大等待时间(如 5 分钟),触发告警并人工处理

九、面试 Q&A

Q1: "如何保证 Kafka 消息绝对不丢失?从 Producer 到 Consumer 全链路说说。"

A: 保证消息不丢失需要从三个层面入手:

Producer 层:
- 使用 Outbox 模式,业务操作和消息写入在同一个 DB 事务中
- Producer 设置 acks=all,等待所有 ISR 确认
- 设置 retries=3 和 enable.idempotence=true,防止发送失败和重复

Kafka 层:
- replication.factor=3,min.insync.replicas=2
- unclean.leader.election=false,防止非同步副本成为 Leader 导致数据丢失
- 合理设置 retention,避免消息过期被删除

Consumer 层:
- 关闭自动提交,手动管理 Offset
- 采用"先处理业务,再提交 Offset"的顺序
- 或者将 Offset 和状态一起存入外部存储(如 Redis),实现原子性
- 处理失败时进入死信队列(DLQ),而不是无限重试导致阻塞

极端情况:
如果整个 Kafka 集群不可用(如机房级故障),Outbox 表中的消息仍然保存在 DB 中,
等集群恢复后可以继续发送。这是最后一道防线。

Q2: "如果一笔订单的支付事件比订单创建事件先到,怎么处理?"

A: 这是典型的乱序问题,我们的处理策略分三层:

第一层:Kafka 分区顺序
- 同一笔订单的事件使用 order_id 作为 Key,保证进入同一个 Partition
- Kafka 保证 Partition 内有序,所以如果是同一个 Producer 发送,不会乱序
- 乱序通常发生在:多 Producer、网络重试、消费者重启后重新消费

第二层:Flink Watermark + 状态机
- 使用 Event Time 而非 Processing Time
- 设置允许的最大乱序时间(如 30 秒),Watermark 会缓冲乱序数据
- 在状态机层面:如果收到 PAID 但状态不是 CREATED,放入"待处理缓冲"
  等待 CREATED 到达后触发处理

第三层:超时兜底
- 如果 CREATED 事件始终未到达(如上游服务 Bug),
  缓冲区的 PAID 事件在 5 分钟后触发告警,并人工处理或自动拒绝

实际经验:
在 某业务 的用户行为分析系统中,我们也遇到过类似问题(如页面点击事件比页面浏览事件先到)。
我们使用了 Flink 的 allowedLateness 机制,允许 1 分钟内的乱序数据更新窗口结果,
超过 1 分钟的数据进入侧输出流(Side Output)单独处理。

Q3: "Kafka Partition 数量怎么定?如果后期需要扩容怎么办?"

A: Partition 数量的确定需要考虑三个因素:

1. 吞吐量需求
   - 单 Partition 的写入上限约 10MB/s 或 1万 msg/s(取决于消息大小和硬件)
   - 如果需要 50万 msg/s,至少需要 50 个 Partition

2. 消费者并行度
   - 一个 Consumer Group 中,一个 Partition 只能分配给一个 Consumer
   - 如果计划部署 20 个 Consumer 实例,Partition 数至少 20

3. Key 分布均匀性
   - 如果 Key 是 user_id,需要评估是否有热点用户(如机构账户交易量巨大)
   - 热点 Key 会导致某些 Partition 负载过高,需要监控和再分区

扩容策略:
- Kafka 支持在线增加 Partition,但已有数据不会重新分配
- 新增 Partition 后,只有新消息会按新分区数路由
- 如果要重新分配已有数据,需要停机或使用 Kafka 的 reassign-partitions 工具

最佳实践:
- 初期预估峰值 2-3 倍设置 Partition 数(如预期 12 个,初期设 36 个)
- 使用 Kafka Streams 或 Flink,它们对 Partition 变化有较好的适应性
- 监控 Consumer Lag,当 Lag 持续增长且扩容 Consumer 无效时,说明需要加 Partition
A: Flink 的容错核心机制是 Checkpoint 和 Savepoint。

Checkpoint(自动):
- 每 10 秒(可配置)触发一次,将所有算子状态异步快照到分布式存储(HDFS/S3)
- 使用 Chandy-Lamport 分布式快照算法,保证一致性且不影响处理延迟
- 如果 Job 失败,自动从最近一次成功的 Checkpoint 恢复

Savepoint(手动):
- 由用户手动触发,用于代码升级或迁移
- 与 Checkpoint 格式相同,但生命周期由用户管理

Exactly-Once 语义:
- Source(Kafka):Checkpoint 时记录消费的 Offset
- Sink(Kafka):使用 Two-Phase Commit,先预写事务,Checkpoint 成功后提交
- 如果 Checkpoint 失败,事务回滚,Offset 不提交,下次从旧 Offset 重读

状态存储选择:
- Heap State Backend:快,但受 JVM 内存限制,适用于小状态
- RocksDB State Backend:支持大状态(TB 级),增量 Checkpoint,适合我们的场景

我们在交易风控场景中,状态主要包括:
- 订单 Join 状态(等待支付事件到达)
- 用户行为窗口(7 日滑动窗口聚合)
- 这些状态大小可控(订单状态 TTL 10 分钟,行为窗口按用户分片),
  使用 RocksDB 本地存储 + 增量 Checkpoint 完全没问题。

Q5: "风控规则引擎如果要求 < 50ms 响应,但规则很复杂(几百条规则),怎么优化?"

A: 这是我们实际遇到的挑战,优化策略分三层:

第一层:规则预编译与剪枝
- 将规则表达式预编译为决策树或 Rete 网络
- 利用规则的互斥性剪枝:如果规则 A 的某个条件不满足,依赖该条件的规则 B/C/D 直接跳过
- 实际效果:几百条规则中,平均每次只需要评估 20-30 条

第二层:特征预计算与缓存
- 用户历史特征(如 7 日交易量)由 Flink 实时计算,写入 Redis
- 风控查询时直接读取,不做实时聚合
- 热点特征(如黑名单)使用 Caffeine 本地缓存,避免网络往返

第三层:规则分层执行
- P0 规则(如黑名单、金额上限):同步执行,< 10ms
- P1 规则(如行为模式分析):异步执行,结果在 100ms 内返回
- P2 规则(如关联图谱分析):事后执行,不阻塞交易流程

兜底策略:
- 如果规则引擎超时(如 Redis 抖动),走默认策略(如降级为 REVIEW 人工审核)
- 绝不会因为风控系统慢而阻塞交易,这是交易所的风控底线

Q6: "如果 Kafka 集群挂了,交易还能继续吗?风控怎么兜底?"

A: 这是极端故障场景,需要分层兜底:

第一层:Kafka 本身高可用
- 3 副本 + min.insync.replicas=2,单节点故障不影响服务
- 跨可用区部署(3 个 AZ,每个 AZ 至少 1 个 Broker)
- 监控 + 自动故障转移

第二层:降级模式(Kafka 集群级故障)
- 风控预检(同步路径):依赖 Redis,不依赖 Kafka,继续可用
- 综合判断(异步路径):暂停复杂规则,仅执行本地缓存中的基础规则
- 审计日志:先写入本地文件或备用队列(如 RabbitMQ),Kafka 恢复后回放

第三层:熔断与限流
- 如果风控系统整体降级,触发全局限流(如每秒只允许 1000 笔交易)
- 新订单进入 REVIEW 状态,人工审核后放行
- 历史经验:交易所的风控系统宁可误判(拦截正常交易),也不能漏判(放行风险交易)

底线原则:
交易系统的可用性和数据一致性优先于实时风控的完整性。
如果风控系统故障,交易可以继续(基于缓存规则),但风险会升高,
需要通过限流和人工审核来补偿。

十、关键概念速查表

概念一句话解释面试关键词
Outbox 模式DB 事务内同时写业务表和消息表,Relay 异步发送到 Kafka最终一致性、原子性、消息不丢
Exactly-Once消息既不丢失也不重复Kafka 事务、Flink 两阶段提交
WatermarkFlink 允许乱序数据的最大延迟阈值Event Time、乱序处理、窗口触发
ISRKafka 同步副本集合acks=all、unclean.leader.election
Backpressure下游慢时自动减缓上游Flink 背压、反压、流控
CEP复杂事件处理(Complex Event Processing)模式匹配、规则引擎、实时风控
Rete 算法规则引擎的高效模式匹配算法规则剪枝、预编译、内存网络
Two-Phase Commit分布式事务的两阶段提交Kafka 事务、Exactly-Once Sink

面试提示:这套设计题的考察重点不是你的方案是否"完美",而是你的系统性思维——能否从数据采集、消息可靠性、流处理、状态管理、决策输出全链路考虑问题,并在约束条件下做出合理权衡。记住:先讲清楚数据流,再讲可靠性保障,最后讲性能优化。