Storm超实用教程详解-附示例

一、理论基础

      Storm 是一个免费并开源的分布式实时计算系统。利用 Storm 可以很容易做到可靠地处理无限的 数据流,像 Hadoop 批量处理大数据一样,Storm 可以实时处理数据。在Storm中,topology的构建是一个有向无环图。结点就是Spout或者Bolt,而边就是Spout和Bolt之间或者是Bolt和Bolt之间连接关系。它的一些基本概念如下:在传统的master/slave架构中,都是master节点负责任务的接受、分配、监控等管理任务,从节点负责任务的执行。

Storm超实用教程详解-附示例_第1张图片

 

Spout发送单元,流的源头

它有两种实现方式BaseRichSpout和IRichSpout,建议实现前一种。通常Spout从外部数据源,如消息队列中读取元组数据并吐到拓扑里。Spout可以是可靠的(reliable)或者不可靠(unreliable)的。通过配置config的acker为0或emit方法不带msgId来实现,默认acker值为1。

Spout可以一次给多个流吐数据。此时需要通过OutputFieldsDeclarer的declareStream函数来声明多个流并在调用SpoutOutputCollector提供的emit方法时指定元组吐给哪个流。Storm框架会不断调用它去做元组的轮询。如果没有新的元组过来,就直接返回,否则把新元组吐到拓扑里。nextTuple必须是非阻塞的,因为Storm在同一个线程里执行Spout的函数。

Tuple:发送的数据流

是一个轻量级的数据格式,支持基本的类型,如果想实现自定义的类型,需要实现自己的序列化方式。在同一个流中,Tuple的数据格式应该都是一样的。不同流中的数据格式可能相同,也可能不同。这个对象必须是可序列化的。

Streams:核心抽象&&Stream Grouping:流分组

一个流由无限的元组序列组成,这些元组会被分布式并行地创建和处理。通过流中元组包含的字段名称来定义这个流。每个流声明时都被赋予了一个ID

  • OutputFieldsDeclarer: 用来声明流和流的定义
  • Serialization: Storm元组的动态类型转化,声明自定义的序列化方式
  • ISerialization: 自定义的序列化必须实现这个接口
  • CONFIG.TOPOLOGY_SERIALIZATIONS: 可以通过这个配置来注册自定义的序列化接口

Storm 中最重要的抽象,应该就是 Stream grouping 了,它能够控制 Spot/Bolt 对应的 Task 以什么样的方式来分发 Tuple,将 Tuple 发射到目的 Spot/Bolt 对应的 Task.定义拓扑的时候,一部分工作是指定每个Bolt应该消费哪些流。流分组定义了一个流在一个消费它的Bolt内的多个任务(task)之间如何分组。流分组跟计算机网络中的路由功能是类似的,决定了每个元组在拓扑中的处理路线。在Storm中有七个内置的流分组策略,你也可以通过实现CustomStreamGrouping接口来自定义一个流分组策略:

  1. shuffleGrouping:随机分配,元组到Bolt的某个任务上,这样保证同一个Bolt的每个任务都能够得到相同数量的元组。
  2. fieldsGrouping:字段分组, 按照指定的分组字段来进行流的分组。例如,流是用字段“user-id"来分组的,那有着相同“user-id"的元组就会分到同一个任务里,但是有不同“user-id"的元组就会分到不同的任务里。通过这种流分组方式,我们就可以做到让Storm产出的消息在这个"user-id"级别是严格有序的,这对一些对时序敏感的应用(例如,计费系统)是非常重要的。
  3. Partial Key grouping: 跟字段分组一样,流也是用指定的分组字段进行分组的,但是在多个下游Bolt之间是有负载均衡的,这样当输入数据有倾斜时可以更好的利用资源。
  4. allGrouping:广播发送,流会复制给Bolt的所有任务。小心使用这种分组方式。在拓扑中,如果希望某类元祖发送到所有的下游消费者,就可以使用这种All grouping的流分组策略。
  5. globalGrouping: 整个流会分配给Bolt的一个任务。具体一点,会分配给有最小ID的任务。全局分组, 这个tuple被分配到storm中的一个bolt的其中一个task。再具体一点就是分配给id值最低的那个task。 
  6. Direct grouping:一种特殊的分组。对于这样分组的流,元组的生产者决定消费者的哪个任务会接收处理这个元组。只能在声明做直连的流(direct streams)上声明Direct groupings分组方式。只能通过使用emitDirect系列函数来吐元组给直连流。一个Bolt可以通过提供的TopologyContext来获得消费者的任务ID,也可以通过OutputCollector对象的emit函数(会返回元组被发送到的任务的ID)来跟踪消费者的任务ID。在ack的实现中,Spout有两个直连输入流,ack和ackFail,使用了这种直连分组的方式。
  7. Local or shuffle grouping:如果目标Bolt在同一个worker进程里有一个或多个任务,元组就会通过洗牌的方式分配到这些同一个进程内的任务里。否则,就跟普通的洗牌分组一样。这种方式的好处是可以提高拓扑的处理效率,因为worker内部通信就是进程内部通信了,相比拓扑间的进程间通信要高效的多。worker进程间通信是通过使用Netty来进行网络通信的。
  • TopologyBuilder: 使用这个类来定义拓扑
  • InputDeclarer: 当调用TopologyBuilder的setBolt函数时会返回这个对象,它用来声明一个Bolt的输入流并指定流的分组方式
  • CoordinatedBolt: 这个Bolt对于分布式的RPC拓扑很有用,大量使用了直连流(direct streams)和直连分组(direct groupings)

Bolt:流水线上的处理单元

把数据的计算处理过程合理的拆分到多个Bolt、合理设置Bolt的task数量,能够提高Bolt的处理能力,提升流水线的并发度。它也有两种实现方式BaseRichBolt和IRichBolt,建议实现前一种。

Bolt可以给多个流吐出元组数据。此时需要使用OutputFieldsDeclarer的declareStream方法来声明多个流并在使用[OutputColletor]的emit方法时指定给哪个流吐数据。当你声明了一个Bolt的输入流,也就订阅了另外一个组件的某个特定的输出流。如果希望订阅另一个组件的所有流,需要单独挨个订阅。InputDeclarer有语法糖来订阅ID为默认值的流。例如declarer.shuffleGrouping("redBolt")订阅了redBolt组件上的默认流,跟declarer.shuffleGrouping("redBolt", DEFAULT_STREAM_ID)是相同的。

必须注意OutputCollector不是线程安全的,所以所有的吐数据(emit)、确认(ack)、通知失败(fail)必须发生在同一个线程里。

  • IRichBolt: 这是Bolt的通用接口
  • IBasicBolt: 很方便的Bolt接口,用于定义做过滤或者简单处理的Bolt
  • OutputCollector: Bolt通过这个类的实例来吐元组给输出流

Topology

把spout和bolt连接起来,构建一张有向无图topy图,拓扑会一直运行下去直到被kill掉。一个拓扑就是一个复杂的多阶段的流计算。worker、executor、task的关系

Storm超实用教程详解-附示例_第2张图片

  1. worker是一个进程.1 个 worker 进程执行的是 1 个 topology 的子集(注:不会出现 1 个 worker 为多个 topology 服务)。1 个 worker 进程会启动 1 个或多个 executor 线程来执行 1 个 topology 的 component(spout 或 bolt)。因此,1 个运行中的 topology 就是由集群中多台物理机上的多个 worker 进程组成的。
  2. executor是一个线程,是运行tasks的物理容器.executor 是 1 个被 worker 进程启动的单独线程。每个 executor 只会运行 1 个 topology 的 1 个 component(spout 或 bolt)的 task(注:task 可以是 1 个或多个,storm 默认是 1 个 component 只生成 1 个 task,executor 线程里会在每次循环里顺序调用所有 task 实例)。
  3. task是对spout/bolt/acker等任务的逻辑抽象.是最终运行 spout 或 bolt 中代码的单元(注:1 个 task 即为 spout 或 bolt 的 1 个实例, executor 线程在执行期间会调用该 task 的 nextTuple 或 execute 方法)。topology 启动后,1 个 component(spout 或 bolt)的 task 数目是固定不变的,但该 component 使用的 executor 线 程数可以动态调整(例如:1 个 executor 线程可以执行该 component 的 1 个或多个 task 实 例)。这意味着,对于 1 个 component 存在这样的条件:#threads<=#tasks(即:线程数小于 等于 task 数目)。默认情况下 task 的数目等于 executor 线程数目,即 1 个 executor 线程只运 行 1 个 task。

二、常见配置

有很多topology级的配置可以设。 以”TOPOLOGY”打头的配置是topology级别的配置,可以覆盖全局级别的配置。下面是一些比较常见的:

1)Config.TOPOLOGY_WORKER设置:  这个设置用多少个工作进程来执行这个topology。比如,如果你把它设置成25, 那么集群里面一共会有25个java进程来执行这个topology的所有task。如果你的这个topology里面所有组件加起来一共有150的并行 度,那么每个进程里面会有6个线程(150 / 25 = 6)。

2)Config.TOPOLOGY_ACKERS: 这个配置设置acker线程的数目。Ackers是Storm的可靠性API的一部分。

3)Config.TOPOLOGY_MAX_SPOUT_PENDING:  这个设置一个spout task上面最多有多少个没有处理的tuple(没有ack/failed)回复, 我们推荐你设置这个配置,以防止tuple队列爆掉。

4)Config.TOPOLOGY_MESSAGE_TIMEOUT_SECS: 这个配置storm的tuple的超时时间  – 超过这个时间的tuple被认为处理失败了。这个设置的默认设置是30秒,对于大多数的topology都已经足够了。

5)Config.TOPOLOGY_SERIALIZATIONS: 为了在你的tuple里面使用自定义类型,你可以用这个配置注册自定义serializer。

三、示例程序

示例1:BaseRichSpout

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;
import backtype.storm.utils.Utils;

import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

public class SentenceSpout extends BaseRichSpout {
    private static final long serialVersionUID = 4608825077450573093L;
    private ConcurrentHashMap pending;
    private SpoutOutputCollector collector;
    private String[] sentences = {
            "connecting the dots",
            "love and loss",
            "keep looking",
            "do not settle",
            "stay hungry",
            "stay foolish"
    };
    private int index;

    /**
     * Spout的构造函数,类初始化时被调用,一般会把读取数据源的操作放在此方法里。里面接收了三个参数,
     * 第一个是创建Topology时的配置,
     * 第二个是所有的Topology数据,可以设置一些变量
     * 第三个是用来把Spout的数据发射给bolt,发布交给bolts处理的数据
     * **/
    @Override
    public void open(Map conf, TopologyContext context, SpoutOutputCollector collector) {
        this.index = 0;
        this.collector = collector;
        //要处理的数据
        this.pending = new ConcurrentHashMap();
    }

    /**
     * 声明输出元组的字段信息
     */
    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("sentence"));
    }

    /**
     * 这是Spout最主要的方法,在这里我们读取文本文件,并把它的每一行发射出去(给bolt)
     * 这个方法会不断被调用,死循环。为了降低它对CPU的消耗,当任务完成时让它sleep一下
     * /
    @Override
    public void nextTuple() {
        Values value = new Values(sentences[index]);
        UUID msgId = UUID.randomUUID();
        this.pending.put(msgId, value);
        //每行发布一个Tuple,后面必须带个消息ID,如果不带msgID则下游Blot处理失败时就不会调用ack方法
        this.collector.emit(value,msgId);
        index++;
        if(index >= sentences.length){
            index = 0;
        }
        // 休眠0.1毫秒
        Utils.sleep(100);
    }

    /**
     * 元组被正常处理后的操作
     */
    @Override
    public void ack(Object msgId){
        this.pending.remove(msgId);
    }

    /**
     * 如果元组未被正常处理就重发
     */
    @Override
    public void fail(Object msgId){
        this.collector.emit(this.pending.get(msgId),msgId);
    }
}

示例2:BaseRichBolt

/*把句子分割成为单词,然后传递到下游的Bolt*/
public class SplitSentenceBolt extends BaseRichBolt {
    private static final long serialVersionUID = 2390867112177953110L;
    private OutputCollector collector;

    /**
     * 在Storm中,这个方法相当于Bolt的构造函数,类初始化时被调用,
     * 所以一般会把Bolt初始化操作放在这个方法里
     */
    @Override
    public void prepare(Map conf, TopologyContext context, OutputCollector collector) {
        this.collector = collector;
    }

    /**
     * 声明输出元组的字段信息,发送给下一个Bolt
     */
    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("word"));
    }

    /**这是bolt中最重要的方法,每当接收到一个tuple时,此方法便被调用
     * 这个方法的作用就是把文本文件中的每一行切分成一个个单词,并把这些单词发射出去(给下一个bolt处理)
     * **/
    @Override
    public void execute(Tuple tuple) {
        String sentence = tuple.getStringByField("sentence");//值可以按位置或名称读取
        String[] words = sentence.split(" ");
        for(String word:words){
            word = word.trim();
            // 将输出的tuple和输入的tuple锚定
            this.collector.emit(tuple,new Values(word));
        }
        // 告诉Spout,这个元组已经被成功处理了
        this.collector.ack(tuple);
    }
}
--------------------------------------------------------------------------------
/*统计各个单词出现的次数,然后传递给下游的Bolt*/
public class WordCountBolt extends BaseRichBolt {
    private static final long serialVersionUID = 360868701353402042L;
    private OutputCollector collector;
    private HashMap counters;

    @Override
    public void prepare(Map conf, TopologyContext context, OutputCollector collector) {
        this.collector = collector;
        counters = new HashMap();
    }

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

    @Override
    public void execute(Tuple tuple) {
        String word = tuple.getStringByField("word");
        Integer count = counters.get(word);
        if(null == count){
            count = 0;
        }
        count++;
        this.counters.put(word, count);
        // 将输出的tuple和输入的tuple锚定
        this.collector.emit(tuple,new Values(word,count));
        // 告诉上游Bolt,这个元组已经被成功处理了
        this.collector.ack(tuple);
    }
}
--------------------------------------------------------------------------------
/*拓扑运行结束时打印单词计数(这里只是演示而这样做的,生成环境中Storm会一直运行下去,除非你主动停止它)*/
public class ReportBolt extends BaseRichBolt {
    private static final long serialVersionUID = -1884042962508663765L;
    private HashMap counts;

    @Override
    public void prepare(Map conf, TopologyContext context, OutputCollector arg2) {
        this.counts = new HashMap();
    }

    /**
     * 这个Bolt什么也不输出
     */
    @Override
    public void declareOutputFields(OutputFieldsDeclarer arg0) {

    }

    @Override
    public void execute(Tuple tuple) {
        String word = tuple.getStringByField("word");
        Integer count = tuple.getIntegerByField("count");
        this.counts.put(word, count);
    }

    /*Topology执行完毕的清理工作,比如关闭连接、释放资源等操作都会写在这里*/
    @Override
    public void cleanup(){
        System.out.println("******count result******");
        for (Map.Entry entry : counts.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

示例3:Topology

/*Topology中的各结点已经构造完毕,接下来要把它们连接起来,构成一张有向无环图*/
public class WordCountTopology {
    private static final String CENTENER_SPOUT_ID = "sentence-spout";
    private static final String SPLIT_BOLT_ID = "split-bolt";
    private static final String COUNT_BOLT_ID = "count-bolt";
    private static final String REPORT_BOLT_ID = "report-bolt";
    private static final String TOPOLOGY_NAME = "word-count-toplogy";
    public static void main(String[] args){
        SentenceSpout spout = new SentenceSpout();
        SplitSentenceBolt splitBolt = new SplitSentenceBolt();
        WordCountBolt countBolt = new WordCountBolt();
        ReportBolt reportBolt = new ReportBolt();

        TopologyBuilder builder = new TopologyBuilder();
        builder.setSpout(CENTENER_SPOUT_ID, spout);

        //下面setBolt方法的并发度全是1,根据情况来设置
        // SentenceSpout ---> SplitSentenceBolt。在spout和bolts之间通过shuffleGrouping(随机分配Bolt)方法连接
        builder.setBolt(SPLIT_BOLT_ID, splitBolt).shuffleGrouping(CENTENER_SPOUT_ID);

        // SplitSentenceBolt ---> WordCountBolt,把相同的单词发给同一个Bolt
        builder.setBolt(COUNT_BOLT_ID, countBolt).fieldsGrouping(SPLIT_BOLT_ID, new Fields("word"));

        // WordCountBolt ---> ReportBolt
        builder.setBolt(REPORT_BOLT_ID, reportBolt).globalGrouping(COUNT_BOLT_ID);

        Config config = new Config();

        /*//在storm中可以用这种方式取出值来
        config.put("wordsFile", "d:/text.txt");
        config.get("wordsFile");
        conf.put(Config.TOPOLOGY_MAX_SPOUT_PENDING, 1);
        */

        //创建一个本地模式cluster
        LocalCluster cluster = new LocalCluster();
        cluster.submitTopology(TOPOLOGY_NAME, config, builder.createTopology());
        // 休眠10秒
        Utils.sleep(10000);
        cluster.killTopology(TOPOLOGY_NAME);
        cluster.shutdown();
    }
}

四、与Kafka集成

public class StormKafkaTopo {
     public static void main(String[] args) {
         BrokerHosts brokerHosts = new ZkHosts("192.168.1.216:2181/kafka");
         SpoutConfig spoutConfig = new SpoutConfig(brokerHosts, "topic1", "/kafka", "kafkaspout");
         Config conf = new Config();
         Map map = new HashMap();
         map.put("metadata.broker.list", "192.168.1.216:9092");
         map.put("serializer.class", "kafka.serializer.StringEncoder");
         conf.put("kafka.broker.properties", map);32         conf.put("topic", "topic2");
         spoutConfig.scheme = new SchemeAsMultiScheme(new MessageScheme());
         TopologyBuilder builder = new TopologyBuilder();
         builder.setSpout("spout", new KafkaSpout(spoutConfig));
         builder.setBolt("bolt", new SenqueceBolt()).shuffleGrouping("spout");
         builder.setBolt("kafkabolt", new KafkaBolt()).shuffleGrouping("bolt");
         if(args != null && args.length > 0) {
             //提交到集群运行
            try {
                 StormSubmitter.submitTopology(args[0], conf, builder.createTopology());
            } catch (AlreadyAliveException e) {
                 e.printStackTrace();
             } catch (InvalidTopologyException e) {
                 e.printStackTrace();
             }
        } else {
             //本地模式运行
             LocalCluster cluster = new LocalCluster();
             cluster.submitTopology("Topotest1121", conf, builder.createTopology());
             Utils.sleep(1000000);
            cluster.killTopology("Topotest1121");
             cluster.shutdown();
         }       
    }
}

 

你可能感兴趣的:(#,活动,大数据,storm)