Apache Storm 核心概念详解:拓扑、流、Spout、Bolt、分组与可靠并发模型

原创2026-10-08 22:15:152,173 阅读
文章标签:流处理后端大数据

Apache Storm 核心概念详解:拓扑、流、Spout、Bolt、分组与可靠并发模型

本文基于 Apache Storm 官方文档《Concepts》并结合仓库源码(storm-core 模块)展开,系统讲解 Storm 实时计算应用的基础抽象:拓扑(Topology)、流(Stream)、Spout、Bolt、流分组(Stream Grouping)、可靠性(Reliability)、任务(Task)与 Worker。读完本文,你将能理解一个 Storm 拓扑从"定义"到"分布式执行"的完整脉络,掌握 8 种内置流分组的语义差异,并清楚 TopologyBuilder、ISpout、IRichBolt、OutputCollector 等核心类在实际代码中的角色与调用关系,为后续阅读 Guaranteeing message processing(消息处理保障机制)和动手编写拓扑打好基础。

Storm 拓扑示意图

一个运行中的 Storm 拓扑,是由 spout、bolt 和流分组连接而成的有向图。

Topologies:实时应用的整体逻辑单元

拓扑(Topology)是 Storm 中一个实时应用程序的整体逻辑封装。 文档中明确将其类比为 MapReduce 中的 Job,二者最关键的差异在于:MapReduce 的 Job 执行完毕后会结束,而一个拓扑会一直运行下去——直到你主动将其 kill 掉。

一个拓扑本质上是一个由 spout 和 bolt 构成的图(Graph),图中的各个组件通过流分组(Stream Grouping)相互连接。在 Java 中,拓扑的构造通过 TopologyBuilder 完成。该类注释中给出了一个完整的构造与提交示例,这也是构建拓扑的标准模板:

TopologyBuilder builder = new TopologyBuilder();

builder.setSpout("1", new TestWordSpout(true), 5);
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 conf = new HashMap();
conf.put(Config.TOPOLOGY_WORKERS, 4);

StormSubmitter.submitTopology("mytopology", conf, builder.createTopology());

从源码看,TopologyBuilder 维护了 _bolts、_spouts 等映射表,setSpout / setBolt 分别注册组件并返回 SpoutGetter / BoltGetter(即 SpoutDeclarer / BoltDeclarer)用于声明该组件的输入流与分组方式(见 TopologyBuilder.java#L128-L205)。createTopology() 最终把组件序列化后封装为 Thrift 结构 StormTopology(见 TopologyBuilder.java#L101-L118)。

关于"如何运行"拓扑,仓库文档提供了两类指引:

仓库 examples/storm-starter 模块提供了 WordCountTopology、ExclamationTopology 等可直接运行的入门示例,适合作为第一个实验对象。

Streams:Storm 的核心抽象

流(Stream)是 Storm 中最核心的抽象。 一个流是无界(unbounded)的 tuple 序列,以分布式方式被并行地创建和处理。流通过 schema 定义,schema 声明了流中每个 tuple 所包含的字段名。

关于 tuple 的字段类型:默认情况下,tuple 可以包含整数(int/long/short)、字节(byte/byte array)、字符串、双精度浮点数、单精度浮点数、布尔值等基础类型。如果需要使用自定义类型,可以定义自己的序列化器,让自定义类型原生地出现在 tuple 中。相关要点:

  • Serialization 详细介绍了 Storm 对 tuple 的动态类型处理以及如何声明自定义序列化;
  • 自定义序列化器需要实现 ISerialization 接口;
  • 自定义序列化器可通过配置 CONFIG.TOPOLOGY_SERIALIZATIONS(即 topology.serializations)注册。

每个流在声明时都会获得一个 id。由于"单流"的 spout 和 bolt 非常常见,OutputFieldsDeclarer 提供了省略流 id 的便捷方法——此时流被赋予默认 id "default"(对应源码常量 Utils.DEFAULT_STREAM_ID)。在 TopologyBuilder.java#L285-L344 中可以看到,fieldsGrouping("1", ...) 等所有分组方法都默认作用于 Utils.DEFAULT_STREAM_ID,这正是文档所说"declarer.shuffleGrouping("1") 等价于 declarer.shuffleGrouping("1", DEFAULT_STREAM_ID)"的源码依据。

Spouts:拓扑的数据源头

Spout 是拓扑中的流来源(source of streams)。 通常 spout 从外部数据源读取 tuple 并发射进拓扑(例如 Kestrel 队列、Twitter API 等)。

Spout 可分为两类:

  • 可靠(reliable)Spout:如果 tuple 未被 Storm 成功处理,它可以重新播放(replay)该 tuple;
  • 不可靠(unreliable)Spout:tuple 一经发射即被遗忘,不参与失败重放。

Spout 可以发射多个流:使用 OutputFieldsDeclarer 的 declareStream 方法声明多个流,并在发射时通过 SpoutOutputCollector 的 emit 方法指定要发射到的流。Spout 发射带消息 id 的 tuple 后,Storm 会在该 tuple 的整棵派生树被完整处理或失败时,分别回调 spout 的 ack / fail 方法(仅可靠 spout 会收到这些回调)。

从 ISpout.java 源码看,spout 的核心方法包括:

方法 说明
open(conf, context, collector) 任务在 worker 中初始化时调用,提供环境与发射用的 collector(见 ISpout.java#L57)
nextTuple() 请求 spout 发射新 tuple;没有 tuple 可发射时应直接返回(见 ISpout.java#L90)
ack(msgId) 该 msgId 对应的 tuple 已完整处理,通常将该消息移出队列、不再重放(见 ISpout.java#L99)
fail(msgId) 该 msgId 对应的 tuple 处理失败,通常将其放回队列待稍后重放(见 ISpout.java#L108)
activate() / deactivate() 拓扑被激活/暂停时调用(配合 storm 客户端操作)
close() spout 关闭时调用(集群模式下 supervisor 可能直接 kill -9 worker,close 不保证执行)

实现 spout 需要实现接口 IRichSpout(源码中该接口位于 backtype.storm.topology 包下,继承自 ISpout 与 IComponent)。

重要约束:nextTuple 绝不能阻塞。 因为 Storm 会在同一个线程上以紧密循环调用 nextTuple、ack 和 fail,若 nextTuple 阻塞,将同时阻塞待处理的 ack/fail 回调。ISpout 的 Javadoc 明确说明了这一点,并建议在无 tuple 可发射时让 nextTuple 短暂 sleep(如 1 毫秒)以节省 CPU。此外,SpoutOutputCollector 是线程安全的(见 SpoutOutputCollector.java#L24-L48),发射时如果 messageId 为 null,Storm 将不跟踪该消息,spout 也不会收到任何 ack/fail 回调。

Bolts:拓扑中所有计算的执行者

拓扑中的所有处理都发生在 bolt 中。 Bolt 可以做任何事情:过滤(filtering)、函数计算、聚合(aggregation)、连接(join)、访问数据库等等。复杂的流转换通常需要多个步骤、因此需要多个 bolt 串联。文档给出了一个例子:把"tweet 流"转换为"热门图片流"至少需要两步——一个 bolt 对每张图片的转发数做滚动计数,再加一个或多个 bolt 输出 Top X 图片(该场景用三个 bolt 比两个 bolt 能得到更好的扩展性)。

与 spout 类似,bolt 也可以发射多个流:用 declareStream 声明,用 OutputCollector 的 emit 指定流。声明 bolt 的输入流时,你总是订阅另一个组件的特定流;若想订阅某组件的所有流,必须逐一订阅每个流。InputDeclarer 提供了针对默认流 id 的语法糖:declarer.shuffleGrouping("1") 订阅组件 "1" 的默认流,等价于 declarer.shuffleGrouping("1", DEFAULT_STREAM_ID)。

Bolt 的主方法是 execute(Tuple input),它接收一个新的 tuple。Bolt 通过 OutputCollector 发射 tuple,并且必须为每个处理的 tuple 调用 OutputCollector.ack,Storm 才能知道 tuple 已完成(并最终安全地 ack 最初的 spout tuple)。从 OutputCollector.java#L31-L219 可以看到它提供的方法族:

  • emit(...):可带锚点(anchor)发射,也可发射不带锚点的 tuple;返回 tuple 被发送到的任务 id 列表;
  • emitDirect(taskId, ...):直发给指定任务(要求流声明为 direct 流且消费方使用 direct grouping);
  • ack(Tuple) / fail(Tuple):声明输入 tuple 处理完成或失败;
  • reportError(Throwable):上报异常。

Bolt 内完全可以启动新线程做异步处理,因为 OutputCollector 是线程安全的,可以随时调用。

对于最常见的模式——"处理一个输入 tuple,据此发射 0 个或多个 tuple,然后 ack 该输入 tuple"——Storm 提供了 IBasicBolt 接口,由它自动完成 ack 管理(如果想主动失败 tuple,则抛出 FailedException,见 IBasicBolt.java#L26-L31)。在 TopologyBuilder.java#L159-L177 中可以看到,setBolt(id, IBasicBolt) 内部会用 BasicBoltExecutor 包装后以普通 bolt 方式注册,这正是"自动 ack"的实现机制。实现 bolt 的通用接口是 IRichBolt。

Stream groupings:流在 bolt 任务间的分发规则

定义拓扑的一部分工作,就是为每个 bolt 指定它应接收哪些流作为输入。流分组(Stream Grouping)定义了该流应如何在 bolt 的各任务(task)之间分区。

Storm 内置 8 种分组;此外你还可以通过实现 CustomStreamGrouping 接口定义自定义分组(该接口含 prepare(context, stream, targetTasks) 与 chooseTasks(taskId, values) 两个方法,见 CustomStreamGrouping.java#L25-L42)。各内置分组在 TopologyBuilder.java#L285-L364 中都有对应的声明方法,语义如下:

  1. Shuffle grouping(随机分组):tuple 被随机分发到 bolt 的各任务,保证每个 bolt 获得数量大致相等的 tuple。对应 shuffleGrouping(),构造 Grouping.shuffle。
  2. Fields grouping(字段分组):按分组中指定的字段对流分区。例如按 "user-id" 字段分组,则相同 "user-id" 的 tuple 总是进入同一任务,不同 "user-id" 的 tuple 可能进入不同任务。对应 fieldsGrouping(componentId, Fields),构造 Grouping.fields。
  3. Partial Key grouping(部分键分组):与 Fields grouping 一样按字段分区,但在两个下游 bolt 之间做负载均衡,当输入数据存在倾斜(skew)时能获得更好的资源利用率。其原理基于 "the power of both choices"(两选一策略)负载均衡算法。对应 partialKeyGrouping(componentId, Fields),内部用 PartialKeyGrouping 实现自定义分组(见 TopologyBuilder.java#L347-L354)。从 PartialKeyGrouping.java 源码看,它对键分别用两个不同种子(13 和 17)的 murmur3_128 哈希函数计算两个候选任务,再选择当前负载(统计计数)更小的那个(见 PartialKeyGrouping.java#L38-L39 与 PartialKeyGrouping.java#L99-L103)。仓库 test/jvm/backtype/storm/grouping/PartialKeyGroupingTest.java 提供了对应测试。
  4. All grouping(全量分组):流被复制到 bolt 的所有任务。请谨慎使用(每个任务都会收到每条 tuple 的副本)。
  5. Global grouping(全局分组):整个流只发送到 bolt 的某一个任务——具体是 id 最小的那个任务。从 TopologyBuilder.java#L293-L299 可以看到其实现本质是"字段列表为空"的 fields grouping,这也解释了为什么它总是固定选最低 id 任务。
  6. None grouping(无分组):表示"不关心流如何分组"。目前 none grouping 等价于 shuffle grouping;未来 Storm 会在可能的情况下把使用 none grouping 的 bolt 下推到与其订阅的 bolt/spout 相同的线程中执行。
  7. Direct grouping(直连分组):特殊分组。使用该分组的流意味着由 tuple 的生产者(producer)决定消费方的哪个任务接收此 tuple。Direct grouping 只能声明在"direct 流"上;发射到 direct 流的 tuple 必须使用 OutputCollector 的 emitDirect 系列方法。bolt 获取其消费者任务 id 的方式有两种:使用注入的 TopologyContext,或记录 emit 方法返回值(返回 tuple 被发往的任务 id 列表)。从 OutputCollector.java#L104-L199 可见 emitDirect 的全部重载形态。
  8. Local or shuffle grouping(本地或随机分组):如果目标 bolt 在同一个 worker 进程内有一个或多个任务,tuple 只在这些进程内任务间随机分发;否则退化为普通 shuffle grouping。对应 localOrShuffleGrouping(),构造 Grouping.local_or_shuffle。该分组能显著减少跨进程/跨网络的消息开销。

需要再次强调的是:"订阅另一个组件的所有流"并不存在一条捷径——InputDeclarer 的便捷方法都只作用于默认流 id,其余流必须逐个显式订阅。

Reliability:消息处理的可靠性保证

Storm 保证每个 spout tuple 都会被拓扑完整处理(fully processed)。 实现方式是:Storm 跟踪每个 spout tuple 触发的整棵 tuple 树(tuple tree),并判断这棵树何时被成功完成。

每个拓扑都关联一个消息超时(message timeout)。如果 Storm 在超时时间内未能检测到某个 spout tuple 完成,就会将该 tuple 标记为失败,并在稍后重放(replay)它。

要利用 Storm 的可靠性能力,你需要主动告诉 Storm 两件事:

  1. 何时创建了 tuple 树的新边:在 OutputCollector.emit 时通过**锚定(anchoring)**完成——把新发射的 tuple 关联到(anchor 到)输入 tuple 上。从 OutputCollector.java#L48-L102 可以看到 emit 有多种重载:带 Tuple anchor 或 Collection<Tuple> anchors 的版本是"锚定发射";不带 anchor 的版本则是"非锚定发射",下游失败不会影响任何 spout tuple 的成败。
  2. 何时处理完单个 tuple:对每个输入 tuple 调用 ack 方法,声明"我已经处理完它了"。

在 spout 侧,对应的支撑点是:spout 发射 tuple 时可携带一个任意类型的 messageId,Storm ack/fail 该消息时会把同一个 messageId 回传给 spout,用于标识具体是哪个 tuple(见 SpoutOutputCollector.java#L38-L63)。超时阈值通过配置 Config.TOPOLOGY_MESSAGE_TIMEOUT_SECS(配置键 topology.message.timeout.secs,见 Config.java#L1106)设置,该配置在 Config.java 中被声明为整型校验。

锚定、ack、tuple 树追踪与重放的完整机制,文档指向了更详细的专题:Guaranteeing message processing。

Tasks:每个组件的并发执行单元

每个 spout 或 bolt 都会以多个任务(task)的形式在集群中执行。 每个任务对应一个执行线程;流分组定义了 tuple 如何从一组任务发送到另一组任务。

任务的并行度(parallelism)在 TopologyBuilder 的 setSpout 和 setBolt 方法中设置(即 parallelism_hint 参数)。源码 TopologyBuilder.java#L238-L251 表明:parallelism_hint 会被写入组件的 parallelism_hint 字段,且必须为正数,否则抛出 IllegalArgumentException("Parallelism must be positive.")。此外还可以通过配置 Config.TOPOLOGY_TASKS(配置键 topology.tasks,见 Config.java#L1087)在不需要重新部署拓扑的情况下调整任务数量(须不违反字段分组等约束,例如 fields grouping 保证相同键进入同一任务)。

Workers:承载任务的 JVM 进程

拓扑跨一个或多个 worker 进程执行。每个 worker 进程是一个物理 JVM,执行拓扑的部分任务。 例如:若拓扑的总并行度为 300、分配 50 个 worker,则每个 worker 执行 6 个任务(这些任务作为该进程内的线程运行)。Storm 会尽量把任务均匀地分布到所有 worker 上。

Worker 数量由配置 Config.TOPOLOGY_WORKERS(配置键 topology.workers,见 Config.java#L1076)设置,该配置声明为整型校验,并应在编写拓扑时与各组件上的 parallelism hint 配合使用以调优拓扑性能。

Worker 进程、Executor 与 Task 的关系

上图展示了 worker 进程、executor(线程)与 task 的层级关系:一个 worker 进程内运行多个 executor 线程,每个 executor 负责执行若干个 task,这正是"进程—线程—任务"三级并发模型的直观体现。对"任务、executor 与 worker"并发模型的更深入讨论,可进一步阅读 Understanding the parallelism of a Storm topology。

小结:八个核心概念的串讲

流分组示意

把八个概念串起来,一个 Storm 应用的完整图景是:

  • Topology 是常驻运行的实时应用逻辑图,由 spout 与 bolt 经 stream grouping 连接而成,用 TopologyBuilder 构造;
  • Stream 是无界 tuple 序列,带 schema(字段定义),默认流 id 为 "default",可通过自定义序列化扩展字段类型;
  • Spout 是数据源头,核心方法是 nextTuple(不可阻塞),可靠 spout 通过 ack/fail 配合 messageId 参与重放;
  • Bolt 承载全部处理逻辑,核心方法是 execute,通过线程安全的 OutputCollector 发射、锚定并 ack tuple;
  • Stream Grouping 决定上游流如何分区到下游任务的 8 种内置策略(shuffle / fields / partial key / all / global / none / direct / local-or-shuffle),也可实现 CustomStreamGrouping 自定义;
  • Reliability 依赖 tuple 树的锚定追踪与消息超时(topology.message.timeout.secs),保证每个 spout tuple 至少被完整处理一次;
  • Task 是执行线程,并行度在 setSpout/setBolt 的 parallelism hint 中声明;
  • Worker 是物理 JVM 进程,由 topology.workers 配置数量,均匀承载拓扑中的各任务。

对每个概念更深入的专题讲解(消息保障、本地模式、生产集群运行、序列化、并行度模型),均可从本仓库 docs/documentation 目录下的对应文档继续阅读。

登录后查看全文
storm