STORM_0005_第一个非常简单的storm topology的提交运行

配置好storm之后就可以开始在eclipse里面写topology了。

下面是我在网上搜到的一个简单的例子，我按照自己的理解注释了一下。

第一步，创建mvn工程

这是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>cn.aeths.storm</groupId>
   <artifactId>storm001</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>storm001</name>
   <url>http://maven.apache.org</url>

   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>

   <dependencies>
      <dependency>
       <groupId>org.apache.storm</groupId>
       <artifactId>storm-core</artifactId>
       <version>0.9.2-incubating</version>
       <scope>provided</scope>
     </dependency>
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
       <version>3.8.1</version>
       <scope>test</scope>
     </dependency>
   </dependencies>

   <build>
     <plugins>
       <plugin>
         <artifactId>maven-assembly-plugin</artifactId>
         <version>2.4</version>
         <configuration>
           <descriptorRefs>
             <descriptorRef>jar-with-dependencies</descriptorRef>
           </descriptorRefs>
         </configuration>
         <executions>
           <execution>
             <id>make-assembly</id>
             <phase>package</phase>
             <goals>
               <goal>single</goal>
             </goals>
           </execution>
         </executions>
       </plugin>
     </plugins>
   </build>
 </project>

使用的是storm-core-0.9.2-incubating.jar

我没找到这个jar包的源码导致没看到LocalCliuster的源码，也可能是添加的方式有问题

第二步，创建spout输入tuple

这是RandomSpout.java类的代码

 package cn.aeths.storm.storm001.spout;

 import java.util.Map;
 import java.util.Random;

 import backtype.storm.spout.SpoutOutputCollector;
 import backtype.storm.task.TopologyContext;
 import backtype.storm.topology.OutputFieldsDeclarer;
 import backtype.storm.topology.base.BaseRichSpout;
 import backtype.storm.tuple.Fields;
 import backtype.storm.tuple.Values;

 //简单的输入spout
 @SuppressWarnings("serial")
 public class RandomSpout extends BaseRichSpout {
     //继承了一个方法少的抽象类
     //私有属性，一个收集器，收集来自spout的tuple，这个和OutputCollector的区别是可以打id保证都执行一次
     private SpoutOutputCollector collector;
     //这是个字符串数组，虚拟的输入源
     private static String[] words = { "happy", "excited", "angry" };

     //可以当做是worker的初始化的方法，传递的参数分别是配置信息，获取id的参数，处理流的参数。
     public void open(Map arg0, TopologyContext arg1, SpoutOutputCollector arg2) {
         this.collector = arg2;
     }

     //调用这个方法就是在要求spout传递流交给收集器
     public void nextTuple() {
         //随机的给word赋值
         String word = words[new Random().nextInt(words.length)];
         //将流发射到输出，不带id的发射，所以不跟踪，没有ack和fail的调用
         collector.emit(new Values(word));
     }

     public void declareOutputFields(OutputFieldsDeclarer arg0) {
         //声明分发的方式
         arg0.declare(new Fields("randomstring"));
     }

 }

第三步，创建bolt处理tuple

这是SequenceBolt.java类的代码

 package cn.aeths.storm.storm001.bolt;

 import backtype.storm.topology.BasicOutputCollector;
 import backtype.storm.topology.OutputFieldsDeclarer;
 import backtype.storm.topology.base.BaseBasicBolt;
 import backtype.storm.tuple.Tuple;
 //这个是简单的bolt类
 @SuppressWarnings("serial")
 public class SenqueceBolt extends BaseBasicBolt{
     //继承了一个BaseBasicBolt
     //这是简单的方式，因为它也是别的类实现的BaseBasicBolt extends BaseComponent implements IBasicBolt
     //public interface IBasicBolt extends IComponent
     //总之继承基础的抽象类，实现了其中的两个方法

     public void execute(Tuple input, BasicOutputCollector collector) {
         //处理输入tuple或者在输入的tuple的基础上emit tuple
         //在本例中就是获取输入，将它包装一下，打印在命令行
          String word = (String) input.getValue(0);
          String out = "I'm " + word +  "!";
          System.out.println("out=" + out);
     }

     public void declareOutputFields(OutputFieldsDeclarer declarer) {
         //声明拓扑的流的输出约束，这里没用到
     }

 }

第四步，创建topology

这是FirstTopo.java类的代码

 package cn.aeths.storm.storm001.topology;

 import backtype.storm.Config;
 import backtype.storm.LocalCluster;
 import backtype.storm.StormSubmitter;
 import backtype.storm.topology.TopologyBuilder;
 import backtype.storm.utils.Utils;
 import cn.aeths.storm.storm001.bolt.SenqueceBolt;
 import cn.aeths.storm.storm001.spout.RandomSpout;
 //拓扑创建的额类
 public class FirstTopo {

     public static void main(String[] args) throws Exception {
         //声明拓扑创建的api
         TopologyBuilder builder = new TopologyBuilder();
         //设置输入spout，第一个参数是id可以用这个被bolt调用，第二个参数是实例化的spout
         builder.setSpout("spout", new RandomSpout());
         //设置一个新的bolt处理流，第一个参数是id可以被其他的消费它的bolt使用，第二个参数是实例化的bolt
         builder.setBolt("bolt", new SenqueceBolt()).shuffleGrouping("spout");
         Config conf = new Config();      //方便的为拓扑创建配置，是继承map的，使用setter方法
         conf.setDebug(false);//关闭调试模式
         if (args != null && args.length > 0) {
             //有参数的时候，集群模式
             conf.setNumWorkers(3);
             //把本类，本配置，本拓扑提交
             StormSubmitter.submitTopology(args[0], conf, builder.createTopology());
         } else {
             //本地模式
             LocalCluster cluster = new LocalCluster();
             //提交拓扑，名字自定义
             cluster.submitTopology("firstTopo", conf, builder.createTopology());
             //休眠10s
             Utils.sleep(10000);
             //杀死拓扑
             cluster.killTopology("firstTopo");
             cluster.shutdown();
         }
     }
 }

第五步，提交storm运行

命令行的结果如下：

 out=I'm happy!
 out=I'm excited!
 out=I'm happy!
 out=I'm happy!
 out=I'm excited!
 out=I'm angry!
 out=I'm angry!
 out=I'm happy!
 52008 [Thread-8-bolt] INFO  backtype.storm.util - Async loop interrupted!
 52009 [main] INFO  backtype.storm.daemon.executor - Shut down executor bolt:[2 2
 ]
 52009 [main] INFO  backtype.storm.daemon.executor - Shutting down executor spout
 :[3 3]
 52010 [Thread-10-spout] INFO  backtype.storm.util - Async loop interrupted!

http://blog.csdn.net/annkie/article/details/6960934
这个文献教会我怎么给eclipse添加jre的源码

这是第一个本地虚拟的集群运行的topology，下面学习一下相对复杂的一个例子。