Apache Storm 核心概念全解析:拓扑、流、Spout、Bolt、流分组与可靠性机制

原创2026-10-06 18:00:421,716 阅读
文章标签:流处理大数据实时分析分布式数据库

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 拓扑结构示意

上图展示了一个典型 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);
}

实践指引

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 接口自定义分组:

  1. Shuffle grouping(随机分组):tuple 被随机分发到 Bolt 的各 task,保证每个 task 最终收到数量相等的 tuple。
  2. Fields grouping(字段分组):按分组中指定的字段对流进行分区。例如按 "user-id" 字段分组时,相同 user-id 的 tuple 总是进入同一个 task,不同 user-id 的 tuple 可能进入不同 task。
  3. Partial Key grouping(局部键分组):与字段分组一样按键分区,但在两个下游 Bolt 之间做负载均衡,当输入数据存在倾斜(skew)时能更好地利用资源。其原理来自"the power of both choices"负载均衡思想。仓库中的 PartialKeyGrouping 实现显示:每个 key 被分配一个由两个 task 组成的子集(RandomTwoTaskAssignmentCreator),tuple 再从该子集中按均衡策略(BalancedTargetSelector)选择目标 task,从而在保持键亲和的同时摊平热点。
  4. All grouping(全量分组):流被复制到 Bolt 的每一个 task。谨慎使用(每个 tuple 会被每个 task 各处理一次)。
  5. Global grouping(全局分组):整个流进入唯一一个 task——即id 最小的那个 task。
  6. None grouping(不关心分组):表示你不关心如何分区。当前实现等价于 shuffle grouping;未来 Storm 会在可能的情况下,将使用 none grouping 的 Bolt "下推"到与所订阅的 Bolt/Spout 同一线程执行。
  7. Direct grouping(直接分组):特殊分组。由 tuple 的生产者决定该 tuple 由消费方的哪个 task 接收。直接分组只能声明在被声明为 direct 的流上;发射到 direct 流的 tuple 必须使用 OutputCollector 的 emitDirect 系列方法。Bolt 可以通过 TopologyContext 获取消费方 task id,也可以利用 emit 方法的返回值(它会返回 tuple 被发送到的 task id 列表)。
  8. 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 的可靠性能力,你必须做两件事:

  1. 告知 Storm 元组树中何时创建了新边——即通过 OutputCollector.emit 发射 tuple 时进行锚定(anchoring);
  2. 告知 Storm 你何时处理完某个 tuple——即调用 OutputCollector.ack(tuple)。

Ack 树结构示意

上图示意 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

实践指引

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 中的示例代码动手验证。

登录后查看全文
storm