storm 常用类

获得

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

常用类

backtype.storm.topology. TopologyBuilder
用来建立topology。
Spout Declarer backtype.storm.topology.TopologyBuilder. setSpout(String id, IRichSpout spout, Number parallelism_hint)
给topology设置spout。parallelism_hint为将要执行这个spout的任务数，每个任务对应着一个线程。
Bolt Declarer 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(OutputFields Declarer declarer)
声明当前topology的所有stream的输出模式。

backtype.storm.topology. OutputFieldsDeclarer

输出字段的声明者。

void backtype.storm.topology.OutputFields Declarer. 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的字符串加一个感叹号后再喷射出去。
  */