leo

不积跬步,无以至千里。不积小流无,以成江海。

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:
[java] view plain copy
  1. public class MyFunction extends BaseFunction {  
  2.   @Override  
  3.   public void execute(TridentTuple tuple, TridentCollector collector) {  
  4.        for ( int i = 0; i < tuple.getInteger(0); i++) {  
  5.           collector.emit( new Values(i));  
  6.       }  
  7.  }  
     小结:Function实际上就是对经过Function函的tuple做一些操作以改变其内容。
  • 比如我们处理一个“mystream”的数据流,它有三个字段分别是[“a”, “b”, “c”] ,数据流中tuple的内容是:
     [1, 2, 3] [4, 1, 6] [3, 0, 8]
  • 我们运行我们的Function:  
[java] view plain copy
  1. 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很简单,接收一个tuple并决定是否保留这个tuple。举个例子,定义一个Filter:
[java] view plain copy
  1. public class MyFilter extends BaseFilter {  
  2.     public boolean isKeep(TridentTuple tuple) {  
  3.           return tuple.getInteger(0) == 1 && tuple.getInteger(1) == 2;  
  4.     }  
  5.   }  
  • 假设我们的tuples有这个几个字段 [“a”, “b”, “c”]: 
     [1, 2, 3] [2, 1, 1] [2, 3, 4]
  • 然后运行我们的Filter:
[java] view plain copy
  1. 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] view plain copy
  1. 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接口:   
[java] view plain copy
  1. public interface CombinerAggregator <T> extends Serializable {  
  2.         T init(TridentTuple tuple);  
  3.         T combine(T val1, T val2);  
  4.         T zero();  
  5.    }  
    CombinerAggregator接口只返回一个tuple,并且这个tuple也只包含一个field。init方法会先执行,它负责预处理每一个接收到的tuple,然后再执行combine函数来计算收到的tuples直到最后一个tuple到达,当所有tuple处理完时,CombinerAggregator会发射zero函数的输出,举个例子:
  • 定义一个CombinerAggregator实现来计数:  
[java] view plain copy
  1. public class CombinerCount implements CombinerAggregator<Integer>{  
  2.     @Override  
  3.     public Integer init(TridentTuple tuple) {  
  4.           return 1;  
  5.     }  
  6.     @Override  
  7.     public Integer combine(Integer val1, Integer val2) {  
  8.            
  9.           return val1 + val2;  
  10.     }  
  11.     @Override  
  12.     public Integer zero() {  
  13.           return 0;  
  14.     }  
  15.   }  
     小结:当你使用aggregate 方法代替PartitionAggregate时,CombinerAggregator的好处就体现出来了,因为Trident会自动优化计算,在网络传输tuples之前做局部聚合。

我们再看一下ReducerAggregator:
[java] view plain copy
  1. public interface ReducerAggregator <T> extends Serializable {  
  2.         T init();  
  3.         T reduce(T curr, TridentTuple tuple);  
  4.     }  
     ReducerAggregator通过init方法提供一个初始值,然后为每个输入的tuple迭代这个值,最后生产处一个唯一的tuple输出,下面举例说明:
  • 定义一个ReducerAggregator接口实现技术器的例子:
[java] view plain copy
  1. public class ReducerCount implements ReducerAggregator<Long>{  
  2.     @Override  
  3.     public Long init() {  
  4.           return 0L;  
  5.     }  
  6.     @Override  
  7.     public Long reduce(Long curr, TridentTuple tuple) {  
  8.           return curr + 1;  
  9.     }  
  10. }  
最后一个是Aggregator接口,它是最通用的聚合器,它的形式如下:
  
  1. public interface Aggregator<T> extends Operation {  
  2.       T init(Object batchId, TridentCollector collector);  
  3.       void aggregate(T val, TridentTuple tuple, TridentCollector collector);  
  4.       void complete(T val, TridentCollector collector);  
  5.  }  
    Aggregator接口可以发射含任意数量属性的任意数据量的tuples,并且可以在执行过程中的任何时候发射:
  1. init:在处理数据之前被调用,它的返回值会作为一个状态值传递给aggregate和complete方法
  2. aggregate:用来处理每一个输入的tuple,它可以更新状态值也可以发射tuple
  3. complete:当所有tuple都被处理完成后被调用     
    下面举例说明:
  • 定义一个实现来完成一个计数器:
  1.  public class CountAgg extends BaseAggregator<CountState>{  
  2.    static class CountState { long count = 0; }  
  3.    @Override  
  4.    public CountState init(Object batchId, TridentCollector collector) {  
  5.          return new CountState();  
  6.    }  
  7.    @Override  
  8.    public void aggregate(CountState val, TridentTuple tuple, TridentCollector collector) {  
  9.         val. count+=1;  
  10.    }  
  11.    @Override  
  12.    public void complete(CountState val, TridentCollector collector) {  
  13.         collector.emit( new Values(val. count));  
  14.    }  
  15. }  
    有时候我们需要同时执行多个聚合器,这在Trident中被称作chaining,使用方法如下:
  1. 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”]
     运行如下代码:   
  1. 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进行全局计数:
  1. 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的最后一部分便是如何把各种流汇聚到一起。最简单的方式就是把这些流汇聚成一个流。我们可以这么做:   
  1. 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。 
阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/oh_Mourinho/article/details/52953740
个人分类: storm
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭