其他分享
首页 > 其他分享> > 【Storm】Trident API和概念(Operation类)

【Storm】Trident API和概念(Operation类)

作者:互联网

原文链接:https://blog.csdn.net/suifeng3051/article/details/38752631

一、Trident Spout

ITridentSpout:是最通用的spout,可以支持事务或者不透明事务定义;

IBatchSpout:一个非事务spout;

IPartitionedTridentSpout:分区事务spout,从数据源(kafka集群)读分区数据;

IOpaquePartitionedTridentSpout:不透明分区事务spout,从数据源读分区数据;

1、ITridentSpout

(1)ITridentSpout<T> 接口类,有2个内部接口类BatchCoordinatorEmitter,4个方法

(2)BatchCoordinator<X> 接口类,有4个方法

(3)Emitter<X>接口类,有3个方法

2、IBatchSpout

IBatchSpout接口,FixedBatchSpout类实现了IBatchSpout接口。IBatchSpout有6个方法;

3、IPartitionedTridentSpout

(1)IPartitionedTridentSpout<Partitions,Partition extends ISpoutPartition,T>,拥有2个类和4个方法

(2)IPartitionedTridentSpout.Coordinator<Partitions>,Partitions是自定义的类;getPartitionsForBatch是返回当前数据源的所有分区;

(3)IPartitionedTridentSpout.Emitter<Partitions,Partition extends ISpoutPartition,X>,入参是partitions集合,自定义的partition要继承ISpoutPartition类;getOrderedPartitions获得下一个分区;refreshPartitions是如果有新增分区,刷新分区;

4、IOpaquePartitionedTridentSpout

(1)IOpaquePartitionedTridentSpout<Partitions,Partition extends ISpoutPartition,M>

(2)IOpaquePartitionedTridentSpout.Coordinator<Partitions>

(3)IOpaquePartitionedTridentSpout.Emitter<Partitions,Partition extends ISpoutPartition,M>

二、Trident Bolt

唯一显性Bolt接口:ITridentBatchBolt,但很少用;

Trident编程的特点就是Stream

Trident的topology会被编译成尽可能搞笑的Storm topology,只有在需要对数据进行repartition的时候(如groupby或者shuffle)才会把tuple通过network发送出去,如果你有一个trident如下:

被编译成storm topology如下

三、Trident概念之Operation

所有的类和接口在 storm.trident.operation 包

Trident API可以分为Spout操作和Bolt操作,对于Bolt操作提供常见的流数据分析操作。
Bolt Trident提供了五种类型的操作:

  1. Apply Locally: 本地分区操作(Partition-local operations),所有操作应用在本地节点数据上,不会产生网络传输     
  2. Repartitioning: 重分区操作,数据流重定向,单纯的改变数据流向,不会改变数据内容,这部分会有网络传输
  3. Aggragation: 聚合操作,会有网络传输
  4. Grouped streams: 流分组操作操作
  5. 合并(meger)和连接(join)操作

小结:上面提到了Trident实际上是通过把函数应用到每个节点的Batch上的数据以实现并行,而应用的这些函数就是TridentAPI,下面我们就具体介绍一下TridentAPI的各种操作。 

Trident五种操作详解

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

3.1.1 Functions: 函数操作

函数的作用是接收一个tuple(需指定接收tuple的哪个字段),输出0个或多个tuples。输出的新字段值会被追加到原始输入tuple的后面,如果一个function不输出tuple,那就意味这这个tuple被过滤掉了,下面举例说明:

定义一个Function:

public class MyFunction extends BaseFunction{
	
	private static final long serialVersionUID = 1L;

	/**
     * 在每个元组上面执行该逻辑函数,并且发射0个或多个元组
     *
     * @param tuple     传入的元组
     * @param collector 用于发射元组的收集器实例
     */
	@Override
	public void execute(TridentTuple tuple, TridentCollector collector) {
		// 接收第一个field
		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]

我们将每个元组都经过以下MyFunction操作:

//将每个tuple的字段"b"应用于MyFunction,并且产生新字段"d"追加到原tuple的字段中
mystream.each(new Fields("b"),new MyFunction(),new Fields('d'))

它意思是接收输入的每个tuple “b”字段得值,把函数结算结果做为新字段“d”追加到每个tuple后面,然后发射出去。

最终运行结果会是每个tuple有四个字段[“a”, “b”, “c”, “d”],每个tuple的内容变成了:

//[1,2,3]的emit,其中0和1是新字段“d”
[1, 2, 3, 0]
[1, 2, 3, 1]

//[4,1,6]的emit,其中0是新字段“d”
[4, 1, 6, 0]

//[3,0,8],b列是0,不满足需求,过滤掉了

 小结:我们注意到,如果一个function发射多个tuple时,每个发射的新tuple中仍会保留原来老tuple的数据。

3.1.2 Filters:过滤操作

Filters很简单,接收一个tuple并决定是否保留这个tuple。举个例子,定义一个Filter:

public class MyFilter extends BaseFilter{

	@Override
	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:

mystream.each(new Fields("b", "a"), new MyFilter());

则最终得到的tuple是:

[2, 1, 1]

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

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

3.1.3 PartitionAggregate
    PartitionAggregate的作用对每个Partition中的tuple进行聚合,与前面的函数在原tuple后面追加数据不同,PartitionAggregate的输出会直接替换掉输入的tuple,仅数据PartitionAggregate中发射的tuple。下面举例说明:
定义一个累加的PartitionAggregate:

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, Aggregator.

CombinerAggregator操作

CombinerAggregator只返回单个tuple,并且这个tuple只包含一个Field。每个元组首先都经过init函数进行预处理,然后在执行combine函数来计算接受到的tuple,直到最后一个tuple到达。如果分区内没有tuple,则会通过zero函数发射结果。

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操作

ReducerAggregator通过init方法提供一个初始值,然后每个输入的tuple迭代这个值,最后产生一个唯一的tuple输出。

public interface ReducerAggregator<T> extends Serializable {
    T init();
    T reduce(T curr, TridentTuple tuple);
}

比如同样使用RecuerAggregator来实现计数器:


 public class ReducerCount implements ReducerAggregator<Long>{
     @Override
     public Long init() {
           return 0L;
     }
     @Override
     public Long reduce(Long curr, TridentTuple tuple) {
           return curr + 1;
     }
 }

Aggregator操作

执行聚合操作最通用的接口就是Aggregator了,它能够发射任意数量的元组,每个元组可以包含任意数量的字段。

public interface Aggregator<T> extends Operation {
    T init(Object batchId, TridentCollector collector);
    void aggregate(T state, TridentTuple tuple, TridentCollector collector);
    void complete(T state, TridentCollector collector);
}

它的执行流程是:

  1. 在处理Batch之前调用init方法,它返回一个聚合的状态值,传递给aggregate和complete方法。
  2. 为批处理分区中的每个tuple调用aggregate方法,此方法可以更新状态值,也可以发射元组。
  3. 当aggregator处理完Batch分区的所有元组后调用complete方法。

使用Aggregator来实现计数器:

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));
    }
}
projection 投影操作

projection操作用于只保留指定的字段,比如元组有字段["a","b","c","d"],通过以下投影操作,输出流只会包含["c","d"]。

mystream.projection(new Fields("c","d"));

3.2 Repartition 重分区操作

Repartition操作运行一个函数来改变元组在任务之间的分布,调整分区数也可能会导致Repartition操作。重分区操作会引发网络传输。下面是重分区的相关函数:

3.3 Aggragation 聚合操作

Trident提供了aggregate和persistentAggregate方法,aggregate运行在每个batch中,而persistentAggregate将聚合所有Batch,并将结果保存在一个状态源上。
我们前面讲的aggregate、CombinerAggregator和ReducerAggregator运行在patitionAggregation上是本地分区操作。如果直接作用于流上,则是对全局进行聚合。
在对全局流进行聚合时,Aggregator和ReducerAggregator会首先重分区到一个单分区,然后在该分区上执行聚合函数。而CombinerAggregator则会首先聚合每个分区,然后重分区到单个分区,在网络传输中完成聚合操作。所以我们应该尽量用CombinerAggregator,因为它更加高效。

mystream.aggregate(new Count(),new Fields("count"));

3.4 grouped streams 流分组操作

GroupBy操作是根据特定的字段对流进行重定向的,还有,在一个分区内部,每个相同字段的tuple也会被Group到一起,下面这幅图描述了这个场景:

如果你在grouped Stream上面运行aggregators,聚合操作会运行在每个Group中而不是整个Batch。persistentAggregate也能运行在GroupedSteam上,不过结果会被保存在MapState中,其中的key便是分组的字段。
     当然,aggregators在GroupedStreams上也可以串联。

3.5 合并(meger)和连接(join)操作

Trident可以允许我们将不同流组合在一起,通过TridentTopology.merge()方法操作。

//合并流会以第一个流的输出字段来命名
topology.mege(stream1,stream2,stream3);

另一种合并流的方式是连接,类似于SQL那样的连接,要求输入是有限的。所以Trident的join只适用于来自Spout的每个小Bath之间。
比如有一个流包含["key1","val1","val2"],另一个流包含["key2","val1","val2"],通过以下连接操作:

//Trident需要join之后的流重新命名,因为输入流可能存在重复 字段。
​mystream.join(stream1,new Fields("key1"),stream2,new Fields("key2"),new Fields("key","a","b","c","d"))

 

标签:tuple,分区,Trident,API,new,操作,Operation,public
来源: https://blog.csdn.net/u014028317/article/details/100712816