storm 常用类

获得

<dependency>
	<groupId>org.apache.storm</groupId>
	<artifactId>storm-core</artifactId>
	<version>0.9.5</version>
</dependency>

常用类

backtype.storm.topology.TopologyBuilder
用来建立topology。
SpoutDeclarer backtype.storm.topology.TopologyBuilder.setSpout(String id, IRichSpout spout, Number parallelism_hint)
给topology设置spout。parallelism_hint为将要执行这个spout的任务数，每个任务对应着一个线程。
BoltDeclarer backtype.storm.topology.TopologyBuilder.setBolt(String id, IRichBolt bolt, Number parallelism_hint)
给topology设置bolt。

backtype.storm.Config
此类拥有一系列成员方法，用来设置对应的参数。

void backtype.storm.StormSubmitter.submitTopology(String name, Map stormConf, StormTopology topology) 
向storm集群提交topology。

backtype.storm.topology.IComponent

一个接口，表明topology的组件。

void backtype.storm.topology.IComponent.declareOutputFields(OutputFieldsDeclarerdeclarer)
声明当前topology的所有stream的输出模式。

backtype.storm.topology.OutputFieldsDeclarer

输出字段的声明者。

void backtype.storm.topology.OutputFieldsDeclarer.declare(Fields fields)

用默认的stream id进行声明。

void backtype.storm.topology.OutputFieldsDeclarer.declareStream(String streamId, Fields fields)

用指定的stream id与field进行声明

backtype.storm.task.TopologyContext
一个topologyContext会在bolt的prepare()和spout的open()方法中传递给bolt和spout。该类包含了组件在topology内的位置信息，如任务id，输入与输出等。

List<Integer> backtype.storm.spout.SpoutOutputCollector.emit(List<Object> tuple)
喷出一个tuple到默认的输出stream，此steam没有消息id，所以storm没有办法跟踪，因此对于这个tuple将永远不会调用ack()与fail()方法。
List<Integer> backtype.storm.task.OutputCollector.emit(Tuple anchor, List<Object> tuple)
喷射一个新的tuple到默认的抛锚在一个单一tuple的流上。

Tuple

backtype.storm.tuple.Tuple
tuple是storm中的主要数据结构之一，是喷口与闪电之间发送消息的基本单位。它是一个被命名的values的list，其中的每一个value都可以是任意类型。
backtype.storm.tuple.Fields.Fields(String... fields)
Fields类的构造函数，形参列表为(String... fields)。
调试中的一个tuple见图1.

图1：调试中的一个tuple

Spout

backtype.storm.spout.ISpout

这是spout类的核心接口。它有一下几种方法。

void backtype.storm.spout.ISpout.open(Map conf, TopologyContext context, SpoutOutputCollector collector)

当这个组件的task在集群中的一台worker内被初始化的时候，该函数被调用。它向spout提供了该spout执行的环境。

void backtype.storm.spout.ISpout.close()
当spout被关闭时此方法得到调用。

void backtype.storm.spout.ISpout.activate()

当spout从抑制状态变为激活状态时调用。

void backtype.storm.spout.ISpout.deactivate()

当spout被抑制时调用。此时它的nextTuple()方法不会被调用。

void backtype.storm.spout.ISpout.nextTuple()
当该方法被调用时，要求SpoutOutputCollector喷射tuple。
void backtype.storm.spout.ISpout.ack(Object msgId)
表示从此spout喷出的带有messageID的tuple已被完全处理。该方法的一个典型实现是把消息从队列中移走，避免被再次处理。

void backtype.storm.spout.ISpout.fail(Object msgId)
表示从此spout喷出的带有messageID的tuple未被完全处理。该方法的一个典型实现是把该消息再次放入队列，以便被再次发送。

backtype.storm.topology.IRichSpout
继承自ISpout与IComponent。

backtype.storm.spout.SpoutOutputCollector

用于spout的tuple喷射。注意与backtype.storm.task.OutputCollector的区别。

List<Integer> backtype.storm.spout.SpoutOutputCollector.emit(List<Object> tuple)
喷出一个tuple到默认的输出stream，此steam没有消息id，所以storm没有办法跟踪，因此对于这个tuple将永远不会调用ack()与fail()方法。

Bolt

backtype.storm.task.IBolt

这是bolt类的核心接口。有以下几个方法：

void backtype.storm.task.IBolt.prepare(Map stormConf, TopologyContext context, OutputCollector collector)
当这个组件的task在集群中的一台worker内被初始化的时候，该函数被调用。它向bolt提供了该bolt执行的环境。

void backtype.storm.task.IBolt.execute(Tuple input)
处理输入的一个单一tuple。

backtype.storm.topology.IRichBolt

继承自IBolt与IComponent。

backtype.storm.task.OutputCollector
输出收集器用于发射来自IRichBolt的tuple。

List<Integer> backtype.storm.task.OutputCollector.emit(Tuple anchor, List<Object> tuple)
喷射一个新的tuple到默认的抛锚在一个单一tuple的流上。

List<Integer> backtype.storm.task.OutputCollector.emit(String streamId, List<Object> tuple)

向指定的stream中喷射数据。

backtype.storm.topology.InputDeclarer.shuffleGrouping(String componentId)
用于声明接收哪些spout或bolt的输出作为该bolt的输入。

BoltDeclarer backtype.storm.topology.InputDeclarer.localOrShuffleGrouping(String componentId)

用于声明接收哪些spout或bolt的输出作为该bolt的输入。
BoltDeclarer backtype.storm.topology.InputDeclarer.fieldsGrouping(String componentId, String streamId, Fields fields)

用于声明接收指定spout或bolt的指定stream的指定fields作为该bolt的输入。
BoltDeclarer backtype.storm.topology.InputDeclarer.allGrouping(String componentId, String streamId)

用于声明接收指定spout或bolt的指定stream作为该bolt的输入。

例子

package storm.starter;

import backtype.storm.Config;
import backtype.storm.LocalCluster;
import backtype.storm.StormSubmitter;
import backtype.storm.spout.SpoutOutputCollector;
import backtype.storm.task.OutputCollector;
import backtype.storm.task.TopologyContext;
import backtype.storm.topology.OutputFieldsDeclarer;
import backtype.storm.topology.TopologyBuilder;
import backtype.storm.topology.base.BaseRichBolt;
import backtype.storm.topology.base.BaseRichSpout;
import backtype.storm.tuple.Fields;
import backtype.storm.tuple.Tuple;
import backtype.storm.tuple.Values;
import backtype.storm.utils.Utils;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * This is a basic example of a Storm topology.
 * spout随机产生单词，交给bolt，加一个感叹号，再交给bolt，再加一个感叹号
 */
public class ExclamationTopology {

  public static class ExclamationBolt extends BaseRichBolt {
    OutputCollector _collector;

    @Override
    public void prepare(Map conf, TopologyContext context, OutputCollector collector) {
      _collector = collector;
    }

    @Override
    public void execute(Tuple tuple) {
      _collector.emit(tuple, new Values(tuple.getString(0) + "!"));
      _collector.ack(tuple);
    }

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

  }

  public static void main(String[] args) throws Exception {
    TopologyBuilder builder = new TopologyBuilder();

    builder.setSpout("word", new TestWordSpout(), 2);
    builder.setBolt("exclaim1", new ExclamationBolt(), 2).shuffleGrouping("word");
    builder.setBolt("exclaim2", new ExclamationBolt(), 2).shuffleGrouping("exclaim1");

    Config conf = new Config();
    conf.setDebug(true);

    if (args != null && args.length > 0) {
      conf.setNumWorkers(3);

      StormSubmitter.submitTopologyWithProgressBar(args[0], conf, builder.createTopology());
    }
    else {

      LocalCluster cluster = new LocalCluster();
      cluster.submitTopology("test", conf, builder.createTopology());
      Utils.sleep(10000);
      cluster.killTopology("test");
      cluster.shutdown();
    }
  }
}
 class TestWordSpout extends BaseRichSpout {
    public static Logger LOG = LoggerFactory.getLogger(TestWordSpout.class);
    boolean _isDistributed;
    SpoutOutputCollector _collector;

    public TestWordSpout() {
        this(true);
    }

    public TestWordSpout(boolean isDistributed) {
        _isDistributed = isDistributed;
    }
        
    public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
        _collector = collector;
    }
    
    public void close() {
        
    }
        
    public void nextTuple() {
        Utils.sleep(100);
        final String[] words = new String[] {"nathan", "mike", "jackson", "golda", "bertels"};
        final Random rand = new Random();
        final String word = words[rand.nextInt(words.length)];
        _collector.emit(new Values(word));
    }
    
    public void ack(Object msgId) {

    }

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

    @Override
    public Map getComponentConfiguration() {
        if(!_isDistributed) {
            Map ret = new HashMap();
            ret.put(Config.TOPOLOGY_MAX_TASK_PARALLELISM, 1);
            return ret;
        } else {
            return null;
        }
    }    
}
 /*一些输出：
 14022 [Thread-15-exclaim2] INFO  backtype.storm.daemon.executor - Processing received message source: exclaim1:3, stream: default, id: {}, [bertels!]
 14022 [Thread-15-exclaim2] INFO  backtype.storm.daemon.task - Emitting: exclaim2 default [bertels!!]
 14022 [Thread-19-word] INFO  backtype.storm.daemon.task - Emitting: word default [golda]
 14022 [Thread-9-exclaim1] INFO  backtype.storm.daemon.executor - Processing received message source: word:7, stream: default, id: {}, [golda]
 14022 [Thread-9-exclaim1] INFO  backtype.storm.daemon.task - Emitting: exclaim1 default [golda!]
 14022 [Thread-15-exclaim2] INFO  backtype.storm.daemon.executor - Processing received message source: exclaim1:2, stream: default, id: {}, [golda!]
 14022 [Thread-15-exclaim2] INFO  backtype.storm.daemon.task - Emitting: exclaim2 default [golda!!]
 */
 /*
  * 输出说明：
  * 对Thread-15进行观察。对收到的tuple的字符串加一个感叹号后再喷射出去。
  */