• Storm专题二:Storm Trident API 使用具体解释


    一、概述
         Storm Trident中的核心数据模型就是“Stream”,也就是说,Storm Trident处理的是Stream。可是实际上Stream是被成批处理的。Stream被切分成一个个的Batch分布到集群中,全部应用在Stream上的函数终于会应用到每一个节点的Batch中。实现并行计算。详细例如以下图所看到的:
         
    在Trident中有五种操作类型:
    1. Apply Locally:本地操作,全部操作应用在本地节点数据上,不会产生网络传输     
    2. Repartitioning:数据流重定向,单纯的改变数据流向。不会改变数据内容,这部分会有网络传输
    3. Aggragation:聚合操作,会有网络传输
    4. Grouped streams上的操作
    5. Merge和Join
    小结:上面提到了Trident实际上是通过把函数应用到每一个节点的Batch上的数据以实现并行,而应用的这些函数就是TridentAPI,以下我们就详细介绍一下TridentAPI的各种操作。  

    二、Trident五种操作具体解释

    2.1 Apply Locally本地操作:操作都应用在本地节点的Batch上,不会产生网络传输

    2.1.1 Functions:函数操作

         函数的作用是接收一个tuple(需指定接收tuple的哪个字段),输出0个或多个tuples。

    输出的新字段值会被追加到原始输入tuple的后面,假设一个function不输出tuple,那就意味这这个tuple被过滤掉了,以下举例说明:

    • 定义一个Function:
        public class MyFunction extends BaseFunction {
          @Override
          public void execute(TridentTuple tuple, TridentCollector collector) {
               for ( int i = 0; i < tuple.getInteger(0); i++) {
                  collector.emit( new Values(i));
              }
         }
       }
         小结:Function实际上就是对经过Function函的tuple做一些操作以改变其内容。
    • 比方我们处理一个“mystream”的数据流,它有三个字段各自是[“a”, “b”, “c”] ,数据流中tuple的内容是:
         [1, 2, 3] [4, 1, 6] [3, 0, 8]
    • 我们执行我们的Function:  
     java mystream.each(new Fields("b"), new MyFunction(), new Fields("d")));
         它意思是接收输入的每一个tuple “b”字段得值。把函数结算结果做为新字段“d”追加到每一个tuple后面。然后发射出去。
    • 终于执行结果会是每一个tuple有四个字段[“a”, “b”, “c”, “d”]。每一个tuple的内容变成了:
         [1, 2, 3, 0] [1, 2, 3, 1] [4, 1, 6, 0]
        小结:我们注意到,假设一个function发射多个tuple时。每一个发射的新tuple中仍会保留原来老tuple的数据。


    2.1.2 Filters:过滤操作
    • Filters非常easy,接收一个tuple并决定是否保留这个tuple。

      举个样例,定义一个Filter:

     public class MyFilter extends BaseFilter {
         public boolean isKeep(TridentTuple tuple) {
               return tuple.getInteger(0) == 1 && tuple.getInteger(1) == 2;
         }
       }
    • 如果我们的tuples有这个几个字段 [“a”, “b”, “c”]: 
         [1, 2, 3] [2, 1, 1] [2, 3, 4]
    • 然后执行我们的Filter:
     java mystream.each(new Fields("b", "a"), new MyFilter())。
    • 则终于得到的tuple是 :
         [2, 1, 1]

         说明第一个和第三个不满足条件,都被过滤掉了。


         小结:Filter就是一个过滤器,它决定是否须要保留当前tuple。


    2.1.3 PartitionAggregate
        PartitionAggregate的作用对每一个Partition中的tuple进行聚合。与前面的函数在原tuple后面追加数据不同,PartitionAggregate的输出会直接替换掉输入的tuple。仅数据PartitionAggregate中发射的tuple。以下举例说明:
    • 定义一个累加的PartitionAggregate:
    java mystream.partitionAggregate(new Fields("b"), new Sum(), new Fields("sum"));
    • 如果我们的Stream包括两个字段 [“a”, “b”],各个Partition的tuple内容是:
         ``` Partition 0: [“a”, 1] [“b”, 2]

         Partition 1: [“a”, 3] [“c”, 8]

         Partition 2: [“e”, 1] [“d”, 9] [“d”, 10] ```
    • 输出的内容仅仅有一个字段“sum”,值是:
         ``` Partition 0: [3]

         Partition 1: [11]

         Partition 2: [20] ```

        TridentAPI提供了三个聚合器的接口:CombinerAggregator, ReducerAggregator, and Aggregator.

    我们先看一下CombinerAggregator接口:   
     public interface CombinerAggregator <T> extends Serializable {
             T init(TridentTuple tuple);
             T combine(T val1, T val2);
             T zero();
        }
        CombinerAggregator接口仅仅返回一个tuple,而且这个tuple也仅仅包括一个field。init方法会先运行。它负责预处理每个接收到的tuple。然后再运行combine函数来计算收到的tuples直到最后一个tuple到达。当全部tuple处理完时,CombinerAggregator会发射zero函数的输出,举个样例:
    • 定义一个CombinerAggregator实现来计数:  
     public class CombinerCount implements CombinerAggregator<Integer>{
         @Override
         public Integer init(TridentTuple tuple) {
               return 1;
         }
         @Override
         public Integer combine(Integer val1, Integer val2) {
              
               return val1 + val2;
         }
         @Override
         public Integer zero() {
               return 0;
         }
       }
         小结:当你使用aggregate 方法取代PartitionAggregate时。CombinerAggregator的优点就体现出来了,由于Trident会自己主动优化计算,在网络传输tuples之前做局部聚合。

    我们再看一下ReducerAggregator:
     public interface ReducerAggregator <T> extends Serializable {
             T init();
             T reduce(T curr, TridentTuple tuple);
         }
         ReducerAggregator通过init方法提供一个初始值,然后为每一个输入的tuple迭代这个值,最后生产处一个唯一的tuple输出,以下举例说明:
    • 定义一个ReducerAggregator接口实现技术器的样例:
     public class ReducerCount implements ReducerAggregator<Long>{
         @Override
         public Long init() {
               return 0L;
         }
         @Override
         public Long reduce(Long curr, TridentTuple tuple) {
               return curr + 1;
         }
     }
    最后一个是Aggregator接口,它是最通用的聚合器,它的形式例如以下:
      
      public interface Aggregator<T> extends Operation {
            T init(Object batchId, TridentCollector collector);
            void aggregate(T val, TridentTuple tuple, TridentCollector collector);
            void complete(T val, TridentCollector collector);
       }
        Aggregator接口能够发射含随意数量属性的随意数据量的tuples,而且能够在运行过程中的不论什么时候发射:
    1. init:在处理数据之前被调用,它的返回值会作为一个状态值传递给aggregate和complete方法
    2. aggregate:用来处理每个输入的tuple,它能够更新状态值也能够发射tuple
    3. complete:当全部tuple都被处理完毕后被调用     
        以下举例说明:
    • 定义一个实现来完毕一个计数器:
       public class CountAgg extends BaseAggregator<CountState>{
         static class CountState { long count = 0; }
         @Override
         public CountState init(Object batchId, TridentCollector collector) {
               return new CountState();
         }
         @Override
         public void aggregate(CountState val, TridentTuple tuple, TridentCollector collector) {
              val. count+=1;
         }
         @Override
         public void complete(CountState val, TridentCollector collector) {
              collector.emit( new Values(val. count));
         }
      }
        有时候我们须要同一时候运行多个聚合器。这在Trident中被称作chaining,用法例如以下:
    java mystream.chainedAgg() .partitionAggregate(new Count(), new Fields("count")) .partitionAggregate(new Fields("b"), new Sum(), new Fields("sum")) .chainEnd();
        这点代码会在每一个Partition上执行count和sum函数,终于输出一个tuple:[“count”, “sum”]
    projection:投影操作
         投影操作作用是仅保留Stream指定字段的数据,比方有一个Stream包括例如以下字段: [“a”, “b”, “c”, “d”]
         执行例如以下代码:   
    java mystream.project(new Fields("b", "d"))
        则输出的流仅包括 [“b”, “d”]字段。
    2.2 Repartitioning重定向操作
         重定向操作是怎样在各个任务间对tuples进行分区。分区的数量也有可能改变重定向的结果。

    重定向须要网络传输,以下介绍下重定向函数:

    1. shuffle:通过随机分配算法来均衡tuple到各个分区
    2. broadcast:每一个tuple都被广播到全部的分区。这样的方式在drcp时很实用。比方在每一个分区上做stateQuery
    3. partitionBy:依据指定的字段列表进行划分,详细做法是用指定字段列表的hash值对分区个数做取模运算,确保同样字段列表的数据被划分到同一个分区
    4. global:全部的tuple都被发送到一个分区,这个分区用来处理整个Stream
    5. batchGlobal:一个Batch中的全部tuple都被发送到同一个分区,不同的Batch会去往不同的分区
    6. Partition:通过一个自己定义的分区函数来进行分区,这个自己定义函数实现了 backtype.storm.grouping.CustomStreamGrouping
    2.3 Aggragation聚合操作
         Trident有aggregate和 persistentAggregate方法来做聚合操作。aggregate是独立的执行在Stream的每一个Batch上的,而persistentAggregate则是执行在Stream的全部Batch上并把运算结果存储在state source中。
         执行aggregate方法做全局聚合。

    当你用到 ReducerAggregator或Aggregator时,Stream首先被重定向到一个分区中。然后当中的聚合函数便在这个分区上执行。当你用到CombinerAggregator时,Trident会首先在每一个分区上做局部聚合。然后把局部聚合后的结果重定向到一个分区。因此使用CombinerAggregator会更高效。可能的话我们须要优先考虑使用它。 以下举个样例来说明怎样用aggregate进行全局计数:

    java mystream.aggregate(new Count(), new Fields("count"));
    和paritionAggregate一样,aggregators的聚合也能够串联起来。可是假设你把一个 CombinerAggregator和一个非CombinerAggregator串联在一起,Trident是无法完毕局部聚合优化的。

    2.4 grouped streams
          GroupBy操作是依据特定的字段对流进行重定向的,还有,在一个分区内部,每一个同样字段的tuple也会被Group到一起,以下这幅图描写叙述了这个场景:
    
    
         假设你在grouped Stream上面执行aggregators,聚合操作会执行在每一个Group中而不是整个Batch。

    persistentAggregate也能执行在GroupedSteam上,只是结果会被保存在MapState中。当中的key便是分组的字段。

    当然。aggregators在GroupedStreams上也能够串联。

    2.5 Merge和Joins:
    api的最后一部分便是怎样把各种流汇聚到一起。最简单的方式就是把这些流汇聚成一个流。我们能够这么做:   
    java topology.merge(stream1, stream2, stream3);
    还有一种合并流的方式就是join。

    一个标准的join就像是一个sql,必须有标准的输入,因此,join仅仅针对符合条件的Stream。

    join应用在来自Spout的每个小Batch中。join时候的tuple会包括:  

     1. join的字段,如Stream1中的key和Stream2中的x    
     2. 全部非join的字段,依据传入join方法的顺序,a和b分别代表steam1的val1和val2,c代表Stream2的val1          
         当join的是来源于不同Spout的stream时。这些Spout在发射数据时须要同步,一个Batch所包括的tuple会来自各个Spout。

     

    
    
    
    
    关于Trident State 相关内容请參考【Trident State具体解释】 
    关于TridentAPI实践方面,请參考【Trident API实践】
    
       
    
  • 相关阅读:
    zookeeper简介(二)
    zookeeper简介(一)
    消息队列及常见消息队列介绍
    使用IntelliJ IDEA 和 Maven创建Java Web项目
    Java NIO 缓冲区Buffer(二)缓冲区的创建
    Java NIO 缓冲区Buffer(一)基础学习
    Java NIO使用及原理之--选择器Seclector
    JAVA集合类汇总
    谈谈final、finally、 finalize有什么不同?
    查看SELinux状态:
  • 原文地址:https://www.cnblogs.com/brucemengbm/p/6842621.html
Copyright © 2020-2023  润新知