strom架构和构建Topology

来源：互联网发布：s5700 telnet 默认端口编辑：程序博客网时间：2024/06/08 11:55

1.Hadoop的MapReduce与Storm的topology有什么不一样的地方？
2.Nimbus与hadoop的jobtracer作用是否类似？
3.Nimbus和Supervisor之间的所有协调工作有谁来完成？
4.一个topology由哪两部分组成？
5.Storm HA模式如果机器意外停止，是如何处理任务的？
6.storm如何运行一个topology
7.Spout类里面最重要的方法是nextTuple，它的作用是什么？
8.Storm里面有几种种类型的stream grouping，分别是什么？

9.如何构建Topology？

一、Storm基本概念

在运行一个Storm任务之前，需要了解一些概念：

Topologies
Streams
Spouts
Bolts
Stream groupings
Reliability
Tasks
Workers
Configuration

基础知识：

Storm是一个分布式的，可靠的，容错的数据流处理系统。它会把工作任务委托给不同类型的组件，每个组件负责处理一项简单特定的任务。Storm集群的输入流由一个被称作spout的组件管理，spout把数据传递给bolt， bolt要么把数据保存到某种存储器，要么把数据传递给其它的bolt。你可以想象一下，一个Storm集群就是在一连串的bolt之间转换spout传过来的数据。

这里用一个简单的例子来说明这个概念。昨晚我在新闻节目里看到主持人在谈论政治人物和他们对于各种政治话题的立场。他们一直重复着不同的名字，而我开始考虑这些名字是否被提到了相同的次数，以及不同次数之间的偏差。

想像播音员读的字幕作为你的数据输入流。你可以用一个spout读取一个文件（或者socket，通过HTTP，或者别的方法）。文本行被spout传给一个bolt，再被bolt按单词切割。单词流又被传给另一个bolt，在这里每个单词与一张政治人名列表比较。每遇到一个匹配的名字，第二个bolt为这个名字在数据库的计数加1。你可以随时查询数据库查看结果，而且这些计数是随着数据到达实时更新的。所有组件（spouts和bolts）及它们之间的关系请参考拓扑图1-1

现在想象一下，很容易在整个Storm集群定义每个bolt 和spout的并行性级别，因此你可以无限的扩展你的拓扑结构。很神奇，是吗？尽管这是个简单例子，你也可以看到Storm的强大。

架构：

在Storm的集群里面有两种节点：控制节点（master node）和工作节点（worker node）。控制节点上面运行一个叫Nimbus后台程序，它的作用类似Hadoop里面的JobTracker(2.X版本为ResourceManager和ApplicationMaster)。Nimbus负责在集群里面分发代码，分配计算任务给机器，并且监控状态。

Storm集群和Hadoop集群表面上看很类似。但是Hadoop上运行的是MapReduce jobs，而在Storm上运行的是拓扑（topology），这两者之间是非常不一样的。一个关键的区别是：一个MapReduce job最终会结束，而一个topology永远会运行（除非你手动kill掉）。

每一个工作节点上面运行一个叫做Supervisor的节点。Supervisor会监听分配给它那台机器的工作，根据需要启动/关闭工作进程。每一个工作进程执行一个topology的一个子集；一个运行的topology由运行在很多机器上的很多工作进程组成。

Nimbus和Supervisor之间的所有协调工作都是通过Zookeeper集群完成。另外，Nimbus进程和Supervisor进程都是快速失败（fail-fast)和无状态的。所有的状态要么在zookeeper里面，要么在本地磁盘上。这也就意味着你可以用kill -9来杀死Nimbus和Supervisor进程，然后再重启它们，就好像什么都没有发生过。这个设计使得Storm异常的稳定。

1、Topologies

一个topology是spouts和bolts组成的图，通过stream groupings（下文和下篇文章会做详细介绍）将图中的spouts和bolts连接起来，如下图：

一个topology会一直运行直到你手动kill掉，Storm自动重新分配执行失败的任务，并且Storm可以保证你不会有数据丢失（如果开启了高可靠性的话）。如果一些机器意外停机它上面的所有任务会被转移到其他机器上。

运行一个topology很简单。首先，把你所有的代码以及所依赖的jar打进一个jar包。然后运行类似下面的这个命令：

storm jar all-my-code.jar backtype.storm.MyTopology arg1 arg2

这个命令会运行主类: backtype.strom.MyTopology, 参数是arg1, arg2。这个类的main函数定义这个topology并且把它提交给Nimbus。storm jar负责连接到Nimbus并且上传jar包。

Topology的定义是一个Thrift结构，并且Nimbus就是一个Thrift服务，你可以提交由任何语言创建的topology。上面的方面是用JVM-based语言提交的最简单的方法。

2、Streams

消息流stream是storm里的关键抽象。一个消息流是一个没有边界的tuple序列，而这些tuple序列会以一种分布式的方式并行地创建和处理。通过对stream中tuple序列中每个字段命名来定义stream。在默认的情况下，tuple的字段类型可以是：integer，long，short， byte，string，double，float，boolean和byte array。你也可以自定义类型（只要实现相应的序列化器）。

每个消息流在定义的时候会被分配给一个id，因为单向消息流使用的相当普遍， OutputFieldsDeclarer定义了一些方法让你可以定义一个stream而不用指定这个id。在这种情况下这个stream会分配个值为‘default’默认的id 。

Storm提供的最基本的处理stream的原语是spout和bolt。你可以实现spout和bolt提供的接口来处理你的业务逻辑。

3、Spouts

消息源spout是Storm里面一个topology里面的消息生产者。一般来说消息源会从一个外部源读取数据并且向topology里面发出消息：tuple。Spout可以是可靠的也可以是不可靠的。如果这个tuple没有被storm成功处理，可靠的消息源spouts可以重新发射一个tuple，但是不可靠的消息源spouts一旦发出一个tuple就不能重发了。

消息源可以发射多条消息流stream。使用OutputFieldsDeclarer.declareStream来定义多个stream，然后使用SpoutOutputCollector来发射指定的stream。

Spout类里面最重要的方法是nextTuple。要么发射一个新的tuple到topology里面或者简单的返回如果已经没有新的tuple。要注意的是nextTuple方法不能阻塞，因为storm在同一个线程上面调用所有消息源spout的方法。

另外两个比较重要的spout方法是ack和fail。storm在检测到一个tuple被整个topology成功处理的时候调用ack，否则调用fail。storm只对可靠的spout调用ack和fail。

4、Bolts

所有的消息处理逻辑被封装在bolts里面。Bolts可以做很多事情：过滤，聚合，查询数据库等等。

Bolts可以简单的做消息流的传递。复杂的消息流处理往往需要很多步骤，从而也就需要经过很多bolts。比如算出一堆图片里面被转发最多的图片就至少需要两步：第一步算出每个图片的转发数量。第二步找出转发最多的前10个图片。（如果要把这个过程做得更具有扩展性那么可能需要更多的步骤）。

Bolts可以发射多条消息流，使用OutputFieldsDeclarer.declareStream定义stream，使用OutputCollector.emit来选择要发射的stream。

Bolts的主要方法是execute, 它以一个tuple作为输入，bolts使用OutputCollector来发射tuple，bolts必须要为它处理的每一个tuple调用OutputCollector的ack方法，以通知Storm这个tuple被处理完成了，从而通知这个tuple的发射者spouts。一般的流程是： bolts处理一个输入tuple, 发射0个或者多个tuple, 然后调用ack通知storm自己已经处理过这个tuple了。storm提供了一个IBasicBolt会自动调用ack。

5、Stream groupings

定义一个topology的其中一步是定义每个bolt接收什么样的流作为输入。stream grouping就是用来定义一个stream应该如果分配数据给bolts上面的多个tasks。

Storm里面有7种类型的stream grouping

Shuffle Grouping: 随机分组，随机派发stream里面的tuple，保证每个bolt接收到的tuple数目大致相同。
Fields Grouping：按字段分组，比如按userid来分组，具有同样userid的tuple会被分到相同的Bolts里的一个task，而不同的userid则会被分配到不同的bolts里的task。
All Grouping：广播发送，对于每一个tuple，所有的bolts都会收到。
Global Grouping：全局分组，这个tuple被分配到storm中的一个bolt的其中一个task。再具体一点就是分配给id值最低的那个task。
Non Grouping：不分组，这个分组的意思是说stream不关心到底谁会收到它的tuple。目前这种分组和Shuffle grouping是一样的效果，有一点不同的是storm会把这个bolt放到这个bolt的订阅者同一个线程里面去执行。
Direct Grouping：直接分组，这是一种比较特别的分组方法，用这种分组意味着消息的发送者指定由消息接收者的哪个task处理这个消息。只有被声明为Direct Stream的消息流可以声明这种分组方法。而且这种消息tuple必须使用emitDirect方法来发射。消息处理者可以通过TopologyContext来获取处理它的消息的task的id （OutputCollector.emit方法也会返回task的id）。
Local or shuffle grouping：如果目标bolt有一个或者多个task在同一个工作进程中，tuple将会被随机发生给这些tasks。否则，和普通的Shuffle Grouping行为一致。

6、Reliability

Storm保证每个tuple会被topology完整的执行。Storm会追踪由每个spout tuple所产生的tuple树（一个bolt处理一个tuple之后可能会发射别的tuple从而形成树状结构），并且跟踪这棵tuple树什么时候成功处理完。每个topology都有一个消息超时的设置，如果storm在这个超时的时间内检测不到某个tuple树到底有没有执行成功，那么topology会把这个tuple标记为执行失败，并且过一会儿重新发射这个tuple。

为了利用Storm的可靠性特性，在你发出一个新的tuple以及你完成处理一个tuple的时候你必须要通知storm。这一切是由OutputCollector来完成的。通过emit方法来通知一个新的tuple产生了，通过ack方法通知一个tuple处理完成了。

Storm的可靠性我们在第四章会深入介绍。

7、Tasks

每一个spout和bolt会被当作很多task在整个集群里执行。每一个executor对应到一个线程，在这个线程上运行多个task，而stream grouping则是定义怎么从一堆task发射tuple到另外一堆task。你可以调用TopologyBuilder类的setSpout和setBolt来设置并行度（也就是有多少个task）。

8、Workers

一个topology可能会在一个或者多个worker（工作进程）里面执行，每个worker是一个物理JVM并且执行整个topology的一部分。比如，对于并行度是300的topology来说，如果我们使用50个工作进程来执行，那么每个工作进程会处理其中的6个tasks。Storm会尽量均匀的工作分配给所有的worker。

9、Configuration

Storm里面有一堆参数可以配置来调整Nimbus, Supervisor以及正在运行的topology的行为，一些配置是系统级别的，一些配置是topology级别的。default.yaml里面有所有的默认配置。你可以通过定义个storm.yaml在你的classpath里来覆盖这些默认配置。并且你也可以在代码里面设置一些topology相关的配置信息（使用StormSubmitter）。

二、构建Topology

1. 实现的目标：

我们将设计一个topology，来实现对一个句子里面的单词出现的频率进行统计。这是一个简单的例子，目的是让大家对于topology快速上手，有一个初步的理解。

2. 设计Topology结构：

在开始开发Storm项目的第一步，就是要设计topology。确定好你的数据处理逻辑，我们今天将的这个简单的例子，topology也非常简单。整个topology如下：

整个topology分为三个部分：

KestrelSpout:数据源，负责发送sentence
Splitsentence:负责将sentence切分
Wordcount:负责对单词的频率进行累加

3. 设计数据流

这个topology从kestrel queue读取句子,并把句子划分成单词,然后汇总每个单词出现的次数,一个tuple负责读取句子,每一个tuple分别对应计算每一个单词出现的次数,大概样子如下所示：

4. 代码实现：

1) 构建maven环境：

为了开发storm topology, 你需要把storm相关的jar包添加到classpath里面去：要么手动添加所有相关的jar包，要么使用maven来管理所有的依赖。storm的jar包发布在Clojars(一个maven库), 如果你使用maven的话，把下面的配置添加在你项目的pom.xml里面。

<repository> 
    <id>clojars.org</id> 
    <url>http://clojars.org/repo</url> 
</repository> 
<dependency> 
     <groupId>storm</groupId> 
    <artifactId>storm</artifactId> 
     <version>0.5.3</version> 
     <scope>test</scope> 
</dependency>

2) 定义topology：

TopologyBuilder builder = new TopologyBuilder(); 
builder.setSpout(1, new KestrelSpout(“kestrel.backtype.com”,22133,           ”sentence_queue”,   new StringScheme())); 
builder.setBolt(2, new SplitSentence(), 10) 
.shuffleGrouping(1); 
builder.setBolt(3, new WordCount(), 20) 
.fieldsGrouping(2, new Fields(“word”));

这种topology的spout从句子队列中读取句子，在kestrel.backtype.com位于一个Kestrel的服务器端口22133。

Spout用setSpout方法插入一个独特的id到topology。 Topology中的每个节点必须给予一个id，id是由其他bolts用于订阅该节点的输出流。 KestrelSpout在topology中id为1。

setBolt是用于在Topology中插入bolts。在topology中定义的第一个bolts 是切割句子的bolts。这个bolts 将句子流转成成单词流。

让我们看看SplitSentence实施：

public class SplitSentence implements IBasicBolt{ 
        public void prepare(Map conf, TopologyContext context) { 
         } 
       public void execute(Tuple tuple, BasicOutputCollector collector) { 
              String sentence = tuple.getString(0); 
               for(String word: sentence.split(“ ”)) { 
                        collector.emit(new Values(word)); 
                  } 
             } 
         public void cleanup() { 
        } 
        public void declareOutputFields(OutputFieldsDeclarer declarer) { 
                declarer.declare(new Fields(“word”)); 
             } 
 }

关键的方法是 execute方法。正如你可以看到，它将句子拆分成单词，并发出每个单词作为一个新的元组。另一个重要的方法是declareOutputFields，其中宣布bolts输出元组的架构。在这里宣布，它发出一个域为word的元组。

setBolt的最后一个参数是你想为bolts的并行量。 SplitSentence bolts 是10个并发，这将导致在storm集群中有十个线程并行执行。你所要做的的是增加bolts的并行量在遇到topology的瓶颈时。

setBolt方法返回一个对象，用来定义bolts的输入。例如，SplitSentence螺栓订阅组件“1”使用随机分组的输出流。 “1”是指已经定义KestrelSpout。我将解释在某一时刻的随机分组的一部分。到目前为止，最要紧的是，SplitSentence bolts会消耗KestrelSpout发出的每一个元组。

下面在让我们看看wordcount的实现：

public class WordCount implements IBasicBolt { 
        private Map<String, Integer> _counts = new HashMap<String, Integer>(); 
        public void prepare(Map conf, TopologyContext context) { 
        } 
       public void execute(Tuple tuple, BasicOutputCollector collector) { 
              String word = tuple.getString(0); 
              int count; 
              if(_counts.containsKey(word)) { 
                     count = _counts.get(word); 
              } else { 
                    count = 0; 
} 
              count++; 
              _counts.put(word, count); 
              collector.emit(new Values(word, count)); 
       } 
       public void cleanup() { 
       } 
       public void declareOutputFields(OutputFieldsDeclarer declarer) { 
              declarer.declare(new Fields(“word”, “count”)); 
       } 
}

SplitSentence对于句子里面的每个单词发射一个新的tuple, WordCount在内存里面维护一个单词->次数的mapping， WordCount每收到一个单词，它就更新内存里面的统计状态。

5. 运行Topology

storm的运行有两种模式: 本地模式和分布式模式.

1) 本地模式：

storm用一个进程里面的线程来模拟所有的spout和bolt. 本地模式对开发和测试来说比较有用。你运行storm-starter里面的topology的时候它们就是以本地模式运行的，你可以看到topology里面的每一个组件在发射什么消息。

2) 分布式模式：

storm由一堆机器组成。当你提交topology给master的时候，你同时也把topology的代码提交了。master负责分发你的代码并且负责给你的topolgoy分配工作进程。如果一个工作进程挂掉了， master节点会把认为重新分配到其它节点。

3) 下面是以本地模式运行的代码：

Config conf = new Config(); 
conf.setDebug(true); 
conf.setNumWorkers(2); 
LocalCluster cluster = new LocalCluster(); 
cluster.submitTopology(“test”, conf, builder.createTopology()); 
Utils.sleep(10000); 
cluster.killTopology(“test”); 
cluster.shutdown();

首先，这个代码定义通过定义一个LocalCluster对象来定义一个进程内的集群。提交topology给这个虚拟的集群和提交topology给分布式集群是一样的。通过调用submitTopology方法来提交topology，它接受三个参数：要运行的topology的名字，一个配置对象以及要运行的topology本身。

topology的名字是用来唯一区别一个topology的，这样你然后可以用这个名字来杀死这个topology的。前面已经说过了，你必须显式的杀掉一个topology，否则它会一直运行。

Conf对象可以配置很多东西，下面两个是最常见的：

TOPOLOGY_WORKERS(setNumWorkers) 定义你希望集群分配多少个工作进程给你来执行这个topology. topology里面的每个组件会被需要线程来执行。每个组件到底用多少个线程是通过setBolt和setSpout来指定的。这些线程都运行在工作进程里面. 每一个工作进程包含一些节点的一些工作线程。比如，如果你指定300个线程，60个进程，那么每个工作进程里面要执行6个线程，而这6个线程可能属于不同的组件(Spout, Bolt)。你可以通过调整每个组件的并行度以及这些线程所在的进程数量来调整topology的性能。

TOPOLOGY_DEBUG(setDebug), 当它被设置成true的话， storm会记录下每个组件所发射的每条消息。这在本地环境调试topology很有用，但是在线上这么做的话会影响性能的。

如果上面这个看得迷糊，再看看这个例子

Hello World

我们在这个工程里创建一个简单的拓扑，数单词数量。我们可以把这个看作Storm的“Hello World”。不过，这是一个非常强大的拓扑，因为它能够扩展到几乎无限大的规模，而且只需要做一些小修改，就能用它构建一个统计系统。举个例子，我们可以修改一下工程用来找出Twitter上的热点话题。

要创建这个拓扑，我们要用一个spout读取文本，第一个bolt用来标准化单词，第二个bolt为单词计数，如图2-1所示。

你可以从这个网址下载源码压缩包， https://github.com/storm-book/examples-ch02-getting_started/zipball/master。

NOTE: 如果你使用git（一个分布式版本控制与源码管理工具），你可以执行git clone git@github.com:storm-book/examples-ch02-getting_started.git，把源码检出到你指定的目录。

创建工程

开始之前，先为这个应用建一个目录（就像你平常为Java应用做的那样）。这个目录用来存放工程源码。

接下来我们要下载Storm依赖包，这是一些jar包，我们要把它们添加到应用类路径中。你可以采用如下两种方式之一完成这一步：

下载所有依赖，解压缩它们，把它们添加到类路径
使用Apache Maven

NOTE: Maven是一个软件项目管理的综合工具。它可以用来管理项目的开发周期的许多方面，从包依赖到版本发布过程。在这本书中，我们将广泛使用它。如果要检查是否已经安装了maven，在命令行运行mvn。如果没有安装你可以从http://maven.apache.org/download.html下载。

没有必要先成为一个Maven专家才能使用Storm，不过了解一下关于Maven工作方式的基础知识仍然会对你有所帮助。你可以在Apache Maven的网站上找到更多的信息（http://maven.apache.org/）。

NOTE: Storm的Maven依赖引用了运行Storm本地模式的所有库。

要运行我们的拓扑，我们可以编写一个包含基本组件的pom.xml文件。

    <project xmlns="http://maven.apache.org/POM/4.0.0"             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0             http://maven.apache.org/xsd/maven-4.0.0.xsd">             <modelVersion>4.0.0</modelVersion>             <groupId>storm.book</groupId>             <artifactId>Getting-Started</artifactId>             <version>0.0.1-SNAPSHOT</version>             <build>                 <plugins>                     <plugin>                         <groupId>org.apache.maven.plugins</groupId>                         <artifactId>maven-compiler-plugin</artifactId>                         <version>2.3.2</version>                         <configuration>                             <source>1.6</source>                             <target>1.6</target>                             <compilerVersion>1.6</compilerVersion>                         </configuration>                     </plugin>                 </plugins>             </build>             <repositories>                 <!-- Repository where we can found the storm dependencies -->                 <repository>                     <id>clojars.org</id>                     <url>http://clojars.org/repo</url>                 </repository>             </repositories>             <dependencies>                 <!-- Storm Dependency -->                 <dependency>                     <groupId>storm</groupId>                     <artifactId>storm</artifactId>                     <version>0.6.0</version>                 </dependency>             </dependencies>    </project>

开头几行指定了工程名称和版本号。然后我们添加了一个编译器插件，告知Maven我们的代码要用Java1.6编译。接下来我们定义了Maven仓库（Maven支持为同一个工程指定多个仓库）。clojars是存放Storm依赖的仓库。Maven会为运行本地模式自动下载必要的所有子包依赖。

一个典型的Maven Java工程会拥有如下结构：

    我们的应用目录/             ├── pom.xml             └── src                   └── main                      └── java                   |  ├── spouts                   |  └── bolts                   └── resources

java目录下的子目录包含我们的代码，我们把要统计单词数的文件保存在resource目录下。

NOTE：命令mkdir -p 会创建所有需要的父目录。

创建我们的第一个Topology

我们将为运行单词计数创建所有必要的类。可能这个例子中的某些部分，现在无法讲的很清楚，不过我们会在随后的章节做进一步的讲解。

Spout

pout WordReader类实现了IRichSpout接口。WordReader负责从文件按行读取文本，并把文本行提供给第一个bolt。

NOTE: 一个spout发布一个定义域列表。这个架构允许你使用不同的bolts从同一个spout流读取数据，它们的输出也可作为其它bolts的定义域，以此类推。

例2-1包含WordRead类的完整代码（我们将会分析下述代码的每一部分）。

       /**         *  例2-1.src/main/java/spouts/WordReader.java         */        package spouts;        import java.io.BufferedReader;        import java.io.FileNotFoundException;        import java.io.FileReader;        import java.util.Map;        import backtype.storm.spout.SpoutOutputCollector;        import backtype.storm.task.TopologyContext;        import backtype.storm.topology.IRichSpout;        import backtype.storm.topology.OutputFieldsDeclarer;        import backtype.storm.tuple.Fields;        import backtype.storm.tuple.Values;        public class WordReader implements IRichSpout {            private SpoutOutputCollector collector;            private FileReader fileReader;            private boolean completed = false;            private TopologyContext context;            public boolean isDistributed() {return false;}            public void ack(Object msgId) {                    System.out.println("OK:"+msgId);            }            public void close() {}            public void fail(Object msgId) {                 System.out.println("FAIL:"+msgId);            }            /**             * 这个方法做的惟一一件事情就是分发文件中的文本行             */            public void nextTuple() {            /**             * 这个方法会不断的被调用，直到整个文件都读完了，我们将等待并返回。             */                 if(completed){                     try {                         Thread.sleep(1000);                     } catch (InterruptedException e) {                         //什么也不做                     }                    return;                 }                 String str;                 //创建reader                 BufferedReader reader = new BufferedReader(fileReader);                 try{                     //读所有文本行                    while((str = reader.readLine()) != null){                     /**                      * 按行发布一个新值                      */                         this.collector.emit(new Values(str),str);                     }                 }catch(Exception e){                     throw new RuntimeException("Error reading tuple",e);                 }finally{                     completed = true;                 }             }             /**              * 我们将创建一个文件并维持一个collector对象              */             public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {                     try {                         this.context = context;                         this.fileReader = new FileReader(conf.get("wordsFile").toString());                     } catch (FileNotFoundException e) {                         throw new RuntimeException("Error reading file ["+conf.get("wordFile")+"]");                     }                     this.collector = collector;             }             /**              * 声明输入域"word"              */             public void declareOutputFields(OutputFieldsDeclarer declarer) {                 declarer.declare(new Fields("line"));             }        }

第一个被调用的spout方法都是public void open(Map conf, TopologyContext context, SpoutOutputCollector collector)。它接收如下参数：配置对象，在定义topology对象是创建；TopologyContext对象，包含所有拓扑数据；还有SpoutOutputCollector对象，它能让我们发布交给bolts处理的数据。下面的代码主是这个方法的实现。

    public void open(Map conf, TopologyContext context,        SpoutOutputCollector collector) {        try {            this.context = context;            this.fileReader = new FileReader(conf.get("wordsFile").toString());        } catch (FileNotFoundException e) {            throw new RuntimeException("Error reading file ["+conf.get("wordFile")+"]");        }        this.collector = collector;    }

我们在这个方法里创建了一个FileReader对象，用来读取文件。接下来我们要实现public void nextTuple()，我们要通过它向bolts发布待处理的数据。在这个例子里，这个方法要读取文件并逐行发布数据。

    public void nextTuple() {        if(completed){            try {                Thread.sleep(1);            } catch (InterruptedException e) {                //什么也不做            }            return;        }        String str;        BufferedReader reader = new BufferedReader(fileReader);        try{            while((str = reader.readLine()) != null){                this.collector.emit(new Values(str));            }        }catch(Exception e){            throw new RuntimeException("Error reading tuple",e);        }finally{            completed = true;        }    }

NOTE: Values是一个ArrarList实现，它的元素就是传入构造器的参数。

nextTuple()会在同一个循环内被ack()和fail()周期性的调用。没有任务时它必须释放对线程的控制，其它方法才有机会得以执行。因此nextTuple的第一行就要检查是否已处理完成。如果完成了，为了降低处理器负载，会在返回前休眠一毫秒。如果任务完成了，文件中的每一行都已被读出并分发了。

NOTE:元组(tuple)是一个具名值列表，它可以是任意java对象（只要它是可序列化的）。默认情况，Storm会序列化字符串、字节数组、ArrayList、HashMap和HashSet等类型。

Bolts

现在我们有了一个spout，用来按行读取文件并每行发布一个元组，还要创建两个bolts，用来处理它们（看图2-1）。bolts实现了接口backtype.storm.topology.IRichBolt。

bolt最重要的方法是void execute(Tuple input)，每次接收到元组时都会被调用一次，还会再发布若干个元组。

NOTE: 只要必要，bolt或spout会发布若干元组。当调用nextTuple或execute方法时，它们可能会发布0个、1个或许多个元组。你将在第五章学习更多这方面的内容。

第一个bolt，WordNormalizer，负责得到并标准化每行文本。它把文本行切分成单词，大写转化成小写，去掉头尾空白符。

首先我们要声明bolt的出参：

    public void declareOutputFields(OutputFieldsDeclarer declarer){        declarer.declare(new Fields("word"));    }

这里我们声明bolt将发布一个名为“word”的域。

下一步我们实现public void execute(Tuple input)，处理传入的元组：

    public void execute(Tuple input){        String sentence=input.getString(0);        String[] words=sentence.split(" ");        for(String word : words){            word=word.trim();            if(!word.isEmpty()){                word=word.toLowerCase();                //发布这个单词                collector.emit(new Values(word));            }        }        //对元组做出应答        collector.ack(input);    }

第一行从元组读取值。值可以按位置或名称读取。接下来值被处理并用collector对象发布。最后，每次都调用collector对象的ack()方法确认已成功处理了一个元组。

例2-2是这个类的完整代码。

    //例2-2 src/main/java/bolts/WordNormalizer.java    package bolts;    import java.util.ArrayList;    import java.util.List;    import java.util.Map;    import backtype.storm.task.OutputCollector;    import backtype.storm.task.TopologyContext;    import backtype.storm.topology.IRichBolt;    import backtype.storm.topology.OutputFieldsDeclarer;    import backtype.storm.tuple.Fields;    import backtype.storm.tuple.Tuple;    import backtype.storm.tuple.Values;    public class WordNormalizer implements IRichBolt{        private OutputCollector collector;        public void cleanup(){}        /**          * *bolt*从单词文件接收到文本行，并标准化它。          * 文本行会全部转化成小写，并切分它，从中得到所有单词。         */        public void execute(Tuple input){            String sentence = input.getString(0);            String[] words = sentence.split(" ");            for(String word : words){                word = word.trim();                if(!word.isEmpty()){                    word=word.toLowerCase();                    //发布这个单词                    List a = new ArrayList();                    a.add(input);                    collector.emit(a,new Values(word));                }            }            //对元组做出应答            collector.ack(input);        }        public void prepare(Map stormConf, TopologyContext context, OutputCollector collector) {            this.collector=collector;        }        /**          * 这个*bolt*只会发布“word”域          */        public void declareOutputFields(OutputFieldsDeclarer declarer) {            declarer.declare(new Fields("word"));        }    }

NOTE:通过这个例子，我们了解了在一次execute调用中发布多个元组。如果这个方法在一次调用中接收到句子“This is the Storm book”，它将会发布五个元组。

下一个bolt，WordCounter，负责为单词计数。这个拓扑结束时（cleanup()方法被调用时），我们将显示每个单词的数量。

NOTE: 这个例子的bolt什么也没发布，它把数据保存在map里，但是在真实的场景中可以把数据保存到数据库。

package bolts;import java.util.HashMap;import java.util.Map;import backtype.storm.task.OutputCollector;import backtype.storm.task.TopologyContext;import backtype.storm.topology.IRichBolt;import backtype.storm.topology.OutputFieldsDeclarer;import backtype.storm.tuple.Tuple;public class WordCounter implements IRichBolt{    Integer id;    String name;    Map<String,Integer> counters;    private OutputCollector collector;    /**      * 这个spout结束时（集群关闭的时候），我们会显示单词数量      */    @Override    public void cleanup(){        System.out.println("-- 单词数 【"+name+"-"+id+"】 --");        for(Map.Entry<String,Integer> entry : counters.entrySet()){            System.out.println(entry.getKey()+": "+entry.getValue());        }    }    /**     *  为每个单词计数     */    @Override    public void execute(Tuple input) {        String str=input.getString(0);        /**         * 如果单词尚不存在于map，我们就创建一个，如果已在，我们就为它加1         */        if(!counters.containsKey(str)){            conters.put(str,1);        }else{            Integer c = counters.get(str) + 1;            counters.put(str,c);        }        //对元组作为应答        collector.ack(input);    }    /**     * 初始化     */    @Override    public void prepare(Map stormConf, TopologyContext context, OutputCollector collector){        this.counters = new HashMap<String, Integer>();        this.collector = collector;        this.name = context.getThisComponentId();        this.id = context.getThisTaskId();    }    @Override    public void declareOutputFields(OutputFieldsDeclarer declarer) {}}

execute方法使用一个map收集单词并计数。拓扑结束时，将调用clearup()方法打印计数器map。（虽然这只是一个例子，但是通常情况下，当拓扑关闭时，你应当使用cleanup()方法关闭活动的连接和其它资源。）

主类

你可以在主类中创建拓扑和一个本地集群对象，以便于在本地测试和调试。LocalCluster可以通过Config对象，让你尝试不同的集群配置。比如，当使用不同数量的工作进程测试你的拓扑时，如果不小心使用了某个全局变量或类变量，你就能够发现错误。（更多内容请见第三章）

NOTE：所有拓扑节点的各个进程必须能够独立运行，而不依赖共享数据（也就是没有全局变量或类变量），因为当拓扑运行在真实的集群环境时，这些进程可能会运行在不同的机器上。

接下来，TopologyBuilder将用来创建拓扑，它决定Storm如何安排各节点，以及它们交换数据的方式。

    TopologyBuilder builder = new TopologyBuilder();    builder.setSpout("word-reader", new WordReader());    builder.setBolt("word-normalizer", new WordNormalizer()).shuffleGrouping("word-reader");    builder.setBolt("word-counter", new WordCounter()).shuffleGrouping("word-normalizer");

在spout和bolts之间通过shuffleGrouping方法连接。这种分组方式决定了Storm会以随机分配方式从源节点向目标节点发送消息。

下一步，创建一个包含拓扑配置的Config对象，它会在运行时与集群配置合并，并通过prepare方法发送给所有节点。

    Config conf = new Config();    conf.put("wordsFile", args[0]);    conf.setDebug(true);

由spout读取的文件的文件名，赋值给wordFile属性。由于是在开发阶段，设置debug属性为true，Strom会打印节点间交换的所有消息，以及其它有助于理解拓扑运行方式的调试数据。

正如之前讲过的，你要用一个LocalCluster对象运行这个拓扑。在生产环境中，拓扑会持续运行，不过对于这个例子而言，你只要运行它几秒钟就能看到结果。

    LocalCluster cluster = new LocalCluster();    cluster.submitTopology("Getting-Started-Topologie", conf, builder.createTopology());    Thread.sleep(2000);    cluster.shutdown();

调用createTopology和submitTopology，运行拓扑，休眠两秒钟（拓扑在另外的线程运行），然后关闭集群。

例2-3是完整的代码

    //例2-3 src/main/java/TopologyMain.java    import spouts.WordReader;    import backtype.storm.Config;    import backtype.storm.LocalCluster;    import backtype.storm.topology.TopologyBuilder;    import backtype.storm.tuple.Fields;    import bolts.WordCounter;    import bolts.WordNormalizer;    public class TopologyMain {        public static void main(String[] args) throws InterruptedException {        //定义拓扑            TopologyBuilder builder = new TopologyBuilder());            builder.setSpout("word-reader", new WordReader());            builder.setBolt("word-normalizer", new WordNormalizer()).shuffleGrouping("word-reader");            builder.setBolt("word-counter", new WordCounter(),2).fieldsGrouping("word-normalizer", new Fields("word"));        //配置            Config conf = new Config();            conf.put("wordsFile", args[0]);            conf.setDebug(false);        //运行拓扑             conf.put(Config.TOPOLOGY_MAX_SPOUT_PENDING, 1);            LocalCluster cluster = new LocalCluster();            cluster.submitTopology("Getting-Started-Topologie", conf, builder.createTopology();            Thread.sleep(1000);            cluster.shutdown();        }    }

观察运行情况

你已经为运行你的第一个拓扑准备好了。在这个目录下面创建一个文件，/src/main/resources/words.txt，一个单词一行，然后用下面的命令运行这个拓扑：mvn exec:java -Dexec.mainClass=”TopologyMain” -Dexec.args=”src/main/resources/words.txt。

举个例子，如果你的words.txt文件有如下内容： Storm test are great is an Storm simple application but very powerful really Storm is great 你应该会在日志中看到类似下面的内容： is: 2 application: 1 but: 1 great: 1 test: 1 simple: 1 Storm: 3 really: 1 are: 1 great: 1 an: 1 powerful: 1 very: 1 在这个例子中，每类节点只有一个实例。但是如果你有一个非常大的日志文件呢？你能够很轻松的改变系统中的节点数量实现并行工作。这个时候，你就要创建两个WordCounter实例。

    builder.setBolt("word-counter", new WordCounter(),2).shuffleGrouping("word-normalizer");

程序返回时，你将看到： — 单词数【word-counter-2】 — application: 1 is: 1 great: 1 are: 1 powerful: 1 Storm: 3 — 单词数 [word-counter-3] — really: 1 is: 1 but: 1 great: 1 test: 1 simple: 1 an: 1 very: 1 棒极了！修改并行度实在是太容易了（当然对于实际情况来说，每个实例都会运行在单独的机器上）。不过似乎有一个问题：单词is和great分别在每个WordCounter各计数一次。怎么会这样？当你调用shuffleGrouping时，就决定了Storm会以随机分配的方式向你的bolt实例发送消息。在这个例子中，理想的做法是相同的单词问题发送给同一个WordCounter实例。你把shuffleGrouping(“word-normalizer”)换成fieldsGrouping(“word-normalizer”, new Fields(“word”))就能达到目的。试一试，重新运行程序，确认结果

结论：

本章从storm的基本对象的定义，到广泛的介绍了storm的开发环境，从一个简单的例子讲解了topology的构建和定义。希望大家可以从本章的内容对storm有一个基本的理解和概念，并且已经可以构建一个简单的topology！！

1 0