Storm Hello World

.pom 文件

<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>storm01</groupId>

  <artifactId>storm01</artifactId>

  <version>0.0.1-SNAPSHOT</version>

  <packaging>jar</packaging>

  <name>storm01</name>

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

  <repositories>

        <!-- Repository where we can found the storm dependencies  -->

        <repository>

            <id>clojars.org</id>

            <url>http://clojars.org/repo</url>

        </repository>

  </repositories>

  <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>

</dependency>

    <dependency>

      <groupId>junit</groupId>

      <artifactId>junit</artifactId>

      <version>4.11</version>

      <scope>test</scope>

    </dependency>

  </dependencies>

    <build>

    <finalName>storm01</finalName>

   <plugins>

        <plugin>

            <groupId>org.apache.maven.plugins</groupId>

            <artifactId>maven-war-plugin</artifactId>

            <version>2.4</version>

        </plugin>

        <plugin>

            <groupId>org.apache.maven.plugins</groupId>

            <artifactId>maven-compiler-plugin</artifactId>

            <version>2.1</version>

            <configuration>

                <source>1.7</source>

                <target>1.7</target>

            </configuration>

        </plugin>

<!-- 单元测试 -->

<plugin>

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-surefire-plugin</artifactId>

<configuration>

<skip>true</skip>

<includes>

<include>**/*Test*.java</include>

</includes>

</configuration>

</plugin>

     <plugin>

     <groupId>org.apache.maven.plugins</groupId>

     <artifactId>maven-source-plugin</artifactId>

     <version>2.1.2</version>

     <executions>

     <!-- 绑定到特定的生命周期之后，运行maven-source-pluin 运行目标为jar-no-fork -->

<execution>

<phase>package</phase>

<goals>

<goal>jar-no-fork</goal>

</goals>

</execution>

</executions>

     </plugin>

    </plugins>    

  </build>

</project>

我们首先回顾下Storm的组件，安装这个流程去写我们的java代码:

首先编写我们的数据源类:Spout。可以使用俩种方式:

继承BaseRichSpout类

实现IRichSpout接口

重点需要几个方法进行重写或实现:open、nextTuple、declareOutputField

继续编写我们的数据处理类:Bolt。可以使用俩种方式:

继承BaseBasicBolt类

实现IRichBolt接口

重点需要几个方法进行重写或实现:execute、declareOutputFields

最后我们编写主函数(Topology)去进行提交一个任务。

在使用Topology的时候，Storm框架为我们提供了俩种模式:本地模式和集群模式

本地模式:(无需storm集群，直接在java中即可运行，一般用于测试和开发阶段)执行运行main函数即可。

集群模式:(需要storm集群，把实现的java程序打包，然后Topology进行提交)需要把应用打成jar，使用storm命令把Topology提交到集群中去。

项目文件目录

逻辑如下

PWSpout  ====》PrintBolt  =====》 WriteBolt  

package bhz.topology;

import backtype.storm.Config;

import backtype.storm.LocalCluster;

import backtype.storm.StormSubmitter;

import backtype.storm.topology.TopologyBuilder;

import bhz.bolt.PrintBolt;

import bhz.bolt.WriteBolt;

import bhz.spout.PWSpout;

public class PWTopology1 {

public static void main(String[] args) throws Exception {

//

Config cfg = new Config();

cfg.setNumWorkers(2); //JVM有几个

cfg.setDebug(true);

TopologyBuilder builder = new TopologyBuilder();

builder.setSpout("spout", new PWSpout());

builder.setBolt("print-bolt", new PrintBolt()).shuffleGrouping("spout");

builder.setBolt("write-bolt", new WriteBolt()).shuffleGrouping("print-bolt");

//1 本地模式 不依赖于集群环境

LocalCluster cluster = new LocalCluster();

cluster.submitTopology("top1", cfg, builder.createTopology());

Thread.sleep(10000);

cluster.killTopology("top1");

cluster.shutdown();

//2 集群模式

// StormSubmitter.submitTopology("top1", cfg, builder.createTopology());

}

}

package bhz.spout;

import java.util.HashMap;

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;

public class PWSpout extends BaseRichSpout {

private static final long serialVersionUID = 1L;

private SpoutOutputCollector collector;

private static final Map<Integer, String> map = new HashMap<Integer, String>();

static {

map.put(0, "java");

map.put(1, "php");

map.put(2, "groovy");

map.put(3, "python");

map.put(4, "ruby");

}

@Override

public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {

//对spout进行初始化

this.collector = collector;

//System.out.println(this.collector);

}

/**

 * <B>方法名称：</B>轮询tuple<BR>

 * <B>概要说明：</B><BR>

 * @see backtype.storm.spout.ISpout#nextTuple()

 */

@Override

public void nextTuple() {

//随机发送一个单词

final Random r = new Random();

int num = r.nextInt(5);

try {

Thread.sleep(500);

} catch (InterruptedException e) {

e.printStackTrace();

}

this.collector.emit(new Values(map.get(num)));

}

/**

 * <B>方法名称：</B>declarer声明发送数据的field<BR>

 * <B>概要说明：</B><BR>

 * @see backtype.storm.topology.IComponent#declareOutputFields(backtype.storm.topology.OutputFieldsDeclarer)

 */

@Override

public void declareOutputFields(OutputFieldsDeclarer declarer) {

//进行声明

declarer.declare(new Fields("print"));

}

}

package bhz.bolt;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import backtype.storm.topology.BasicOutputCollector;

import backtype.storm.topology.OutputFieldsDeclarer;

import backtype.storm.topology.base.BaseBasicBolt;

import backtype.storm.tuple.Fields;

import backtype.storm.tuple.Tuple;

import backtype.storm.tuple.Values;

public class PrintBolt extends BaseBasicBolt {

private static final Log log = LogFactory.getLog(PrintBolt.class);

private static final long serialVersionUID = 1L;

@Override

public void execute(Tuple input, BasicOutputCollector collector) {

//获取上一个组件所声明的Field

String print = input.getStringByField("print");

log.info("【print】： " + print);

//System.out.println("Name of input word is : " + word);

//进行传递给下一个bolt

collector.emit(new Values(print));

}

@Override

public void declareOutputFields(OutputFieldsDeclarer declarer) {

declarer.declare(new Fields("write"));

}

}

package bhz.bolt;

import java.io.FileWriter;

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import clojure.main;

import backtype.storm.topology.BasicOutputCollector;

import backtype.storm.topology.OutputFieldsDeclarer;

import backtype.storm.topology.base.BaseBasicBolt;

import backtype.storm.tuple.Tuple;

public class WriteBolt extends BaseBasicBolt {

private static final long serialVersionUID = 1L;

private static final Log log = LogFactory.getLog(WriteBolt.class);

private FileWriter writer ;

@Override

public void execute(Tuple input, BasicOutputCollector collector) {

//获取上一个组件所声明的Field

String text = input.getStringByField("write");

try {

if(writer == null){

if(System.getProperty("os.name").equals("Windows 10")){

writer = new FileWriter("D:\\099_test\\" + this);

} else if(System.getProperty("os.name").equals("Windows 8.1")){

writer = new FileWriter("D:\\099_test\\" + this);

} else if(System.getProperty("os.name").equals("Windows 7")){

writer = new FileWriter("D:\\099_test\\" + this);

} else if(System.getProperty("os.name").equals("Linux")){

System.out.println("----:" + System.getProperty("os.name"));

writer = new FileWriter("/usr/local/temp/" + this);

}

}

log.info("【write】： 写入文件");

writer.write(text);

writer.write("\n");

writer.flush();

} catch (Exception e) {

e.printStackTrace();

}

}

@Override

public void declareOutputFields(OutputFieldsDeclarer declarer) {

}

}

运行结果

D盘文件夹下多了个文件

内容如下