Apache Storm 核心概念全解析:拓扑、流、Spout、Bolt、流分组与可靠性机制
Apache Storm 核心概念全解析:拓扑、流、Spout、Bolt、流分组与可靠性机制
Apache Storm 是一个分布式实时计算系统,其全部编程模型都建立在一组精炼而稳定的核心抽象之上:拓扑(Topology)、流(Stream)、Spout、Bolt、流分组(Stream Grouping)、任务(Task)与 Worker。本文以仓库 docs/Concepts.md 为主线,结合 storm-client 源码与仓库内的示例与配置,系统讲解这些概念的语义、接口契约与实际用法,帮助你快速掌握 Storm 应用开发的地基,并为后续阅读 Guaranteeing message processing、Understanding-the-parallelism-of-a-Storm-topology 等进阶文档做好准备。
上图展示了一个典型 Storm 拓扑的有向无环图(DAG):Spout 作为数据源产生 tuple,Bolt 负责逐级处理,箭头表示数据流方向。
1. Topologies:实时应用逻辑的载体
实时应用的处理逻辑被打包进一个 拓扑(topology) 中。拓扑与 MapReduce 作业(job)类似,但有一个关键差异:MapReduce 作业最终会结束,而拓扑会一直运行下去——除非你显式地 kill 掉它。拓扑本质上是由 Spout 与 Bolt 构成的图(graph),各节点之间通过流分组(stream grouping)相连。
在 Java 中,构建拓扑的标准方式是使用 TopologyBuilder。从源码可以看到,TopologyBuilder 的核心职责是:把组件 id 与 IRichSpout/IRichBolt 实例建立映射,收集每个组件的 ComponentCommon(含并行度、输入流声明等公共信息),并在 createTopology() 时将所有内容序列化为 Thrift 结构 StormTopology:
TopologyBuilder builder = new TopologyBuilder();
builder.setSpout("1", new TestWordSpout(true), 5); // 5 个 task 的 spout
builder.setSpout("2", new TestWordSpout(true), 3);
builder.setBolt("3", new TestWordCounter(), 3)
.fieldsGrouping("1", new Fields("word")) // 声明输入流与分组方式
.fieldsGrouping("2", new Fields("word"));
builder.setBolt("4", new TestGlobalCount())
.globalGrouping("1");
Map<String, Object> conf = new HashMap<>();
conf.put(Config.TOPOLOGY_WORKERS, 4); // 分配 4 个 worker 进程
StormSubmitter.submitTopology("mytopology", conf, builder.createTopology());
同样的拓扑也可以在本地模式下(进程内)运行与调试,例如通过 LocalCluster 提交并让拓扑运行 10 秒后关闭:
try (LocalCluster cluster = new LocalCluster();
LocalTopology topo = cluster.submitTopology("mytopology", conf, builder.createTopology())) {
Utils.sleep(10000);
}
实践指引
- 开发与单元测试阶段优先使用 本地模式 验证逻辑,无需部署集群;
- 部署到生产集群前,阅读 Running topologies on a production cluster;
- 仓库中的 examples/storm-starter 提供了大量可运行的入门拓扑示例,是学习
TopologyBuilderAPI 的直观素材。
2. Streams:Storm 的核心抽象
流(stream) 是 Storm 中最核心的抽象:它是一个无界的、按分布式方式并行创建与处理的 tuple 序列。流由 schema 定义,schema 声明了流中 tuple 的字段名。
tuple 内默认可以包含以下类型:整数(int)、长整型(long)、短整型(short)、字节(byte)、字符串(String)、双精度浮点(double)、单精度浮点(float)、布尔(boolean)以及字节数组(byte array)。此外,你还可以注册自定义序列化器,从而在 tuple 中直接使用自定义类型。类型声明与序列化的细节见 Serialization。
每条流在声明时都会被赋予一个 id。由于"单流"的 Spout 与 Bolt 极其常见,OutputFieldsDeclarer 提供了便捷方法,可以在不指定流 id 的情况下声明单条流——此时流使用默认 id "default"(对应源码中的 Utils.DEFAULT_STREAM_ID)。OutputCollector 中大量重载方法都隐式使用了 DEFAULT_STREAM_ID,例如 emit(Tuple, List) 与 emit(Collection, List) 都委托到默认流的 emit。
实践指引
- 声明输出 schema 使用 OutputFieldsDeclarer 的
declare/declareStream方法; - 如需多流输出(如区分"正常数据"与"异常数据"两条流),为每条流显式命名,并在发射时通过带 streamId 参数的
emit指定目标流; - 注意:发射到流中的值必须不可变(immutable),这是
OutputCollector源码中反复强调的约定(参见 OutputCollector.java)。
3. Spouts:流的源头
Spout 是拓扑中流的来源。通常,Spout 从外部源读取数据(例如 Kestrel 队列、Kafka topic、Twitter API 等),并以 tuple 形式发射进拓扑。
Spout 分为 可靠(reliable) 与 不可靠(unreliable) 两类:
- 可靠 Spout:能够记录已发射 tuple 的 message id,当 tuple 处理失败时能够重放该 tuple;
- 不可靠 Spout:tuple 一经发射即被遗忘,不做任何追踪。
Spout 可以发射不止一条流。做法是:用 OutputFieldsDeclarer.declareStream 声明多条流,然后在发射时用 SpoutOutputCollector.emit 的带流 id 重载指定目标流。
Spout 的核心方法
从 ISpout 接口源码可以看出,Spout 的完整生命周期由以下方法构成:
| 方法 | 作用 |
|---|---|
open(conf, context, collector) |
组件初始化时被调用,提供配置、TopologyContext 与发射用的 SpoutOutputCollector;collector 线程安全,可保存为实例变量随时使用 |
nextTuple() |
Spout 的主方法。要么发射一个新 tuple 到拓扑,要么在没有新 tuple 时直接返回 |
ack(Object msgId) |
Storm 检测到该 msgId 对应的 tuple 树已被完整处理时调用,可靠 Spout 借此把消息移出队列、避免重放 |
fail(Object msgId) |
该 msgId 对应的 tuple 树处理失败时调用,可靠 Spout 借此把消息放回队列以便稍后重放 |
close() / activate() / deactivate() |
关闭、激活、停用组件(激活/停用对应 storm 客户端的拓扑操作) |
关键约束:nextTuple 绝不能阻塞。 因为 Storm 会在同一个线程上以紧凑循环方式依次调用 nextTuple、ack 与 fail(ISpout 源码注释明确说明了这一点,参见 ISpout.java)。若 nextTuple 阻塞,会连带阻塞待处理的 ack/fail 回调。当没有新 tuple 可发时,礼貌的做法是让 nextTuple 短睡约 1 毫秒,以免空转浪费 CPU。
实践指引
- 实现 Spout 时实现 IRichSpout(它继承了
ISpout与IComponent,增加了declareOutputFields等方法)即可; - 发射 tuple 时带上 message id,是启用可靠性追踪的前提(message id 为 null 时 Storm 不做追踪,也不会回调 ack/fail,见 ISpout.java);
- 可靠性机制的完整实现原理见 Guaranteeing message processing。
4. Bolts:一切处理逻辑的落脚点
拓扑中的所有数据处理都在 Bolt 中进行。Bolt 可以完成任意处理:过滤、函数变换、聚合、join、访问数据库,等等。
Bolt 既可以做简单的流变换,也可以串联成多步复杂变换。例如,把"推文流"变换成"热门图片流"至少需要两步:一个 Bolt 对每张图片的转发数做滚动计数,再有一个或多个 Bolt 输出 Top X 图片(用三个 Bolt 实现比两个更可扩展)。
与 Spout 类似,Bolt 也能发射多条流:用 declareStream 声明多条输出流,发射时用 OutputCollector 的带流 id 重载指定目标。
输入订阅与 execute
声明 Bolt 的输入流时,你总是订阅另一个组件的特定流。如果想订阅某组件的全部流,需要逐条声明。InputDeclarer 提供了针对默认流的语法糖:
declarer.shuffleGrouping("1"); // 等价于下面这行
declarer.shuffleGrouping("1", DEFAULT_STREAM_ID); // 订阅组件 "1" 的默认流
Bolt 的主方法是 execute(Tuple input),每次收到一个新 tuple 时被调用。Bolt 通过 OutputCollector 发射新 tuple。Bolt 必须对每个处理过的 tuple 调用 OutputCollector.ack,Storm 才能知道该 tuple 已完成,进而判断原始 Spout tuple 是否可以安全 ack。对于"处理一个输入 tuple → 发射 0 个或多个派生 tuple → ack 该输入 tuple"这一常见模式,Storm 提供了 IBasicBolt 接口来自动完成 ack 管理——你只需在 execute(Tuple, BasicOutputCollector) 中写业务逻辑;如需主动失败该 tuple,抛出 FailedException 即可。
关于线程安全:在 Bolt 内另起线程做异步处理完全可行,因为 OutputCollector 是线程安全的,可随时调用(源码中以 delegate 委托方式实现,所有方法转发给底层 IOutputCollector,参见 OutputCollector.java)。
实践指引
- 通用 Bolt 实现 IRichBolt(继承
IBolt与IComponent); - 简单过滤/函数型处理优先用
IBasicBolt,省去手动 ack 的样板代码; - 需要把输出"锚定"到输入 tuple 时,使用
emit(Tuple anchor, ...)/emit(Collection<Tuple> anchors, ...)重载;不锚定的emit(List, ...)发射的是 unanchored tuple,下游失败不会影响 Spout tuple 的成败判定(详见 OutputCollector.java)。
5. Stream groupings:流在 task 间的分区规则
定义拓扑时,需要为每个 Bolt 指明它接收哪些流作为输入。流分组(stream grouping)定义了该流如何被划分到 Bolt 的各 task 之间。
Storm 内置 8 种流分组,并且可以通过实现 CustomStreamGrouping 接口自定义分组:
- Shuffle grouping(随机分组):tuple 被随机分发到 Bolt 的各 task,保证每个 task 最终收到数量相等的 tuple。
- Fields grouping(字段分组):按分组中指定的字段对流进行分区。例如按
"user-id"字段分组时,相同user-id的 tuple 总是进入同一个 task,不同user-id的 tuple 可能进入不同 task。 - Partial Key grouping(局部键分组):与字段分组一样按键分区,但在两个下游 Bolt 之间做负载均衡,当输入数据存在倾斜(skew)时能更好地利用资源。其原理来自"the power of both choices"负载均衡思想。仓库中的 PartialKeyGrouping 实现显示:每个 key 被分配一个由两个 task 组成的子集(
RandomTwoTaskAssignmentCreator),tuple 再从该子集中按均衡策略(BalancedTargetSelector)选择目标 task,从而在保持键亲和的同时摊平热点。 - All grouping(全量分组):流被复制到 Bolt 的每一个 task。谨慎使用(每个 tuple 会被每个 task 各处理一次)。
- Global grouping(全局分组):整个流进入唯一一个 task——即id 最小的那个 task。
- None grouping(不关心分组):表示你不关心如何分区。当前实现等价于 shuffle grouping;未来 Storm 会在可能的情况下,将使用 none grouping 的 Bolt "下推"到与所订阅的 Bolt/Spout 同一线程执行。
- Direct grouping(直接分组):特殊分组。由 tuple 的生产者决定该 tuple 由消费方的哪个 task 接收。直接分组只能声明在被声明为 direct 的流上;发射到 direct 流的 tuple 必须使用 OutputCollector 的
emitDirect系列方法。Bolt 可以通过TopologyContext获取消费方 task id,也可以利用emit方法的返回值(它会返回 tuple 被发送到的 task id 列表)。 - Local or shuffle grouping(本地或随机分组):若目标 Bolt 在当前 worker 进程内有 1 个或多个 task,tuple 仅在这些进程内 task 间随机分发;否则退化为普通 shuffle grouping。该分组能显著减少跨进程/跨节点的网络传输。
上图展示了字段分组的效果:左侧是待分发的 tuple 集合,右侧是按 word 字段值归并后,相同字段值的 tuple 被送往同一分区的结构。
实践指引
- 分组声明统一通过 TopologyBuilder 的
setBolt返回的 InputDeclarer 完成(shuffleGrouping、fieldsGrouping、partialKeyGrouping、allGrouping、globalGrouping、noneGrouping、directGrouping、localOrShuffleGrouping); - 自定义分组实现
CustomStreamGrouping并实现prepare(WorkerTopologyContext, GlobalStreamId, List<Integer>)与chooseTasks(int taskId, List<Object> values); - 若追求更好的吞吐与更均匀的分布,可关注 JitterAwareStreamGrouping(基于抖动感知的动态负载均衡分组)与 LocalityAwareness(本地感知调度)。
6. Reliability:Storm 的"恰好完整处理"保证
Storm 保证每个 Spout tuple 都会被拓扑完整处理。 实现方式:追踪每个 Spout tuple 所触发的 tuple 树(DAG),并判断该树是否已全部成功完成。
每个拓扑都关联一个 message timeout(消息超时)(对应配置 Config.TOPOLOGY_MESSAGE_TIMEOUT_SECS,即 topology.message.timeout.secs)。如果 Storm 在超时时间内未能检测到 Spout tuple 被完整处理,就会 fail 该 tuple,并在稍后重放。
要享受 Storm 的可靠性能力,你必须做两件事:
- 告知 Storm 元组树中何时创建了新边——即通过
OutputCollector.emit发射 tuple 时进行锚定(anchoring); - 告知 Storm 你何时处理完某个 tuple——即调用
OutputCollector.ack(tuple)。
上图示意 Spout tuple 触发的 ack 树:上游 tuple 失败(红色叉号)会导致依赖它的下游 tuple 树被标记为失败,并沿树向下游传播,这正是 Storm 判定失败与重放的依据。
关于 ack 树、锚定、超时与重放的完整机制,请阅读 Guaranteeing message processing。需要提醒的是:不可靠 Spout(发射时不带 message id)与不锚定的发射不会参与追踪;可靠性是有代价的,若业务对丢数据不敏感,可以关闭追踪以换取吞吐。
实践指引
- 超时时间通过
Config.TOPOLOGY_MESSAGE_TIMEOUT_SECS设置,单位秒,默认值参见 conf/storm.yaml.example 中的对应说明; - 需要延长某个 tuple 树的超时时间时,可调用
OutputCollector.resetTimeout(Tuple)(注意该操作开销较大,应谨慎使用,见 OutputCollector.java)。
7. Tasks:并行度的最小执行单元
每个 Spout 或 Bolt 在集群中会以多个 task 的形式执行。每个 task 对应一个执行线程,流分组定义了 tuple 如何从一组 task 发送到另一组 task。
组件并行度(即 task 数量)在 TopologyBuilder 的 setSpout 与 setBolt 方法中设置:
builder.setSpout("word-spout", new WordSpout(), 5); // 该 spout 有 5 个 task
builder.setBolt("count-bolt", new CountBolt(), 3); // 该 bolt 有 3 个 task
实践指引
- 并行度与数据量、下游处理能力需要配套设计,避免单点过热或资源浪费;
- 任务(task)、执行器(executor)与 worker 进程之间的关系,详见 Understanding the parallelism of a Storm topology。
8. Workers:物理 JVM 与任务编排
拓扑运行在一个或多个 worker 进程中。每个 worker 进程是一个物理 JVM,执行拓扑的一部分 task。
举例说明:若拓扑的合计并行度为 300,分配 50 个 worker,则每个 worker 执行 6 个 task(以线程形式运行在 worker 内)。Storm 会尽量把 task 均匀分布到所有 worker 上。
worker 数量通过配置项 Config.TOPOLOGY_WORKERS(即 topology.workers,参见 Config.java)设置:
conf.put(Config.TOPOLOGY_WORKERS, 4); // 为该拓扑分配 4 个 worker 进程
// 或使用便捷方法
Config.setNumWorkers(conf, 4);
也可以在 storm.yaml 中配置默认值,或参考 conf/storm.yaml.example 了解集群侧与拓扑侧的配置项组织方式。
实践指引
- worker 数量的选择需权衡:太少会导致单 JVM 负载过高,太多会引入更多的进程间通信开销;
- 本地模式(
LocalCluster)通常在单进程内模拟多 worker 的执行语义,便于调试; - 涉及资源约束(CPU、内存)的调度策略可参考 Resource_Aware_Scheduler_overview。
9. 性能调优方向
当拓扑吞吐或延迟不达预期时,可系统性地从以下维度排查:
- 并行度与资源分配:task 数量、worker 数量、executor 数量之间的比例;
- 流分组选择:优先使用
localOrShuffleGrouping减少跨进程传输;热点数据场景使用partialKeyGrouping摊平倾斜; - 可靠性开销:不需要 at-least-once 语义时关闭追踪(不设 message id),可显著提升吞吐;
- 序列化与 tuple 体积:控制字段数量与 payload 大小,必要时注册自定义高效序列化器。
更完整的调优方法论参见官方 性能调优指南 Performance。
结语
Storm 的核心概念环环相扣:拓扑是图,流是边上的数据,Spout 是源头,Bolt 是处理节点,流分组决定数据如何分发,可靠性机制保证端到端的处理语义,而 task 与 worker 则定义了并行执行的物理模型。掌握这些概念后,建议按以下顺序继续深入:Guaranteeing message processing(可靠性实现细节)→ Understanding the parallelism of a Storm topology(并行度模型)→ Running topologies on a production cluster(生产部署),并结合 examples/storm-starter 中的示例代码动手验证。


