1.1 Storm(简介)

     Storm是一个实时的可靠地分布式流计算框架。

     具体就不多说了，举个例子，它的一个典型的大数据实时计算应用场景：从Kafka消息队列读取消息（可以是logs,clicks,sensor data）、通过Storm对消息进行计算聚合等预处理、把处理结果持久化到NoSQL数据库或者HDFS做进一步深入分析。

1.2 Trident(简介)

     Trident是对Storm的更高一层的抽象,除了提供一套简单易用的流数据处理API之外，它以batch(一组tuples)为单位进行处理，这样一来，可以使得一些处理更简单和高效。

     我们知道把Bolt的运行状态仅仅保存在内存中是不可靠的，如果一个node挂掉，那么这个node上的任务就会被重新分配，但是之前的状态是无法恢复的。因此，比较聪明的方式就是把storm的计算状态信息持久化到database中，基于这一点，trident就变得尤为重要。因为在处理大数据时，我们在与database打交道时通常会采用批处理的方式来避免给它带来压力，而trident恰恰是以batch groups的形式处理数据，并提供了一些聚合功能的API。

二、Trident API 实践

     Trident其实就是一套API，但现阶段网上关于Trident API中各个函数的用法含义资料不多，下面我就根据一些英文资料和自己的理解，详细介绍一下Trident API各个函数的用法和含义。

2.1 each() 方法

     作用：操作batch中的每一个tuple内容，一般与Filter或者Function函数配合使用。

     下面通过一个例子来介绍each()方法，假设我们有一个FakeTweetsBatchSpout，它会模拟一个Stream，随机产生一个个消息。我们可以通过设置这个Spout类的构造参数来改变这个Spout的batch Size的大小。

2.1.1 Filter类：过滤tuple

     一个通过actor字段过滤消息的Filter：

public static class PerActorTweetsFilter extends BaseFilter {String actor;public PerActorTweetsFilter(String actor) {this.actor = actor;}@Overridepublic boolean isKeep(TridentTuple tuple) {return tuple.getString(0).equals(actor);}
}

   Topology：  

topology.newStream("spout", spout).each(new Fields("actor", "text"), new PerActorTweetsFilter("dave")).each(new Fields("actor", "text"), new Utils.PrintFilter());

     从上面例子看到，each()方法有一些构造参数

• 第一个构造参数：作为Field Selector，一个tuple可能有很多字段，通过设置Field，我们可以隐藏其它字段，仅仅接收指定的字段（其它字段实际还在）。
• 第二个是一个Filter：用来过滤掉除actor名叫"dave"外的其它消息。

2.1.2 Function类：加工处理tuple内容

     一个能把tuple中text内容变成大写的Function：

public static class UppercaseFunction extends BaseFunction {@Overridepublic void execute(TridentTuple tuple, TridentCollector collector) {collector.emit(new Values(tuple.getString(0).toUpperCase()));}
}

     Topology：

topology.newStream("spout", spout).each(new Fields("actor", "text"), new PerActorTweetsFilter("dave")).each(new Fields("text", "actor"), new UppercaseFunction(), new Fields("uppercased_text")).each(new Fields("actor", "text", "uppercased_text"), new Utils.PrintFilter());

    首先，UppercaseFunction函数的输入是Fields("text", "actor")，其作用是把其中的"text"字段内容都变成大写。

  其次，它比Filter多出一个输出字段，作用是每个tuple在经过这个Function函数处理后，输出字段都会被追加到tuple后面，在本例中，执行完Function之后的tuple内容多了一个"uppercased_text"，并且这个字段排在最后面。

2.1.3 Field Selector与project

   我们需要注意的是，上面每个each()方法的第一个Field字段仅仅是隐藏掉没有指定的字段内容，实际上被隐藏的字段依然还在tuple中，如果想要彻底丢掉它们，我们就需要用到project()方法。

   投影操作作用是仅保留Stream指定字段的数据，比如有一个Stream包含如下字段： [“a”, “b”, “c”, “d”]，运行如下代码：

 java mystream.project(new Fields("b", "d"))

     则输出的流仅包含 [“b”, “d”]字段。

2.2 parallelismHint()方法和partitionBy()

2.2.1 parallelismHint()

     指定Topology的并行度，即用多少线程执行这个任务。我们可以稍微改一下我们的Filter，通过打印当前任务的partitionIndex来区分当前是哪个线程。

Filter：

public static class PerActorTweetsFilter extends BaseFilter {private int partitionIndex;private String actor;public PerActorTweetsFilter(String actor) {this.actor = actor;}@Overridepublic void prepare(Map conf, TridentOperationContext context) {this.partitionIndex = context.getPartitionIndex();}@Overridepublic boolean isKeep(TridentTuple tuple) {boolean filter = tuple.getString(0).equals(actor);if(filter) {System.err.println("I am partition [" + partitionIndex + "] and I have kept a tweet by: " + actor);}return filter;}
}

Topology：

topology.newStream("spout", spout).each(new Fields("actor", "text"), new PerActorTweetsFilter("dave")).parallelismHint(5).each(new Fields("actor", "text"), new Utils.PrintFilter());

     如果我们指定执行Filter任务的线程数量为5，那么最终的执行结果会如何呢？看一下我们的测试结果：

I am partition [4] and I have kept a tweet by: dave
I am partition [3] and I have kept a tweet by: dave
I am partition [0] and I have kept a tweet by: dave
I am partition [2] and I have kept a tweet by: dave
I am partition [1] and I have kept a tweet by: dave

     我们可以很清楚的发现，一共有5个线程在执行Filter。

     如果我们想要2个Spout和5个Filter怎么办呢？如下面代码所示，实现很简单。

topology.newStream("spout", spout).parallelismHint(2).shuffle().each(new Fields("actor", "text"), new PerActorTweetsFilter("dave")).parallelismHint(5).each(new Fields("actor", "text"), new Utils.PrintFilter());

2.2.2 partitionBy()和重定向操作(repartitioning operation)

     我们注意到上面的例子中用到了shuffle()，shuffle()是一个重定向操作。那什么是重定向操作呢？重定向定义了我们的tuple如何被route到下一处理层，当然不同的层之间可能会有不同的并行度，shuffle()的作用是把tuple随机的route下一层的线程中，而partitionBy()则根据我们的指定字段按照一致性哈希算法route到下一层的线程中，也就是说，如果我们用partitionBy()的话，同一个字段名的tuple会被route到同一个线程中。

     比如，如果我们把上面代码中的shuffle()改成partitionBy(new Fields("actor"))，猜一下结果会怎样？

I am partition [2] and I have kept a tweet by: dave
I am partition [2] and I have kept a tweet by: dave
I am partition [2] and I have kept a tweet by: dave
I am partition [2] and I have kept a tweet by: dave

     测试结果正如我们上面描述的那样，相同字段的tuple被route到了同一个partition中。

重定向操作有如下几种：

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 聚合(Aggregation)

     

     我们前面讲过，Trident的一个很重要的特点就是它是以batch的形式处理tuple的。我们可以很容易想到的针对一个batch的最基本操作应该就是聚合。Trident提供了聚合API来处理batches，来看一个例子：

2.3.1 Aggregator:

public static class LocationAggregator extends BaseAggregator<Map<String, Integer>> {@Overridepublic Map<String, Integer> init(Object batchId, TridentCollector collector) {return new HashMap<String, Integer>();}@Overridepublic void aggregate(Map<String, Integer> val, TridentTuple tuple, TridentCollector collector) {String location = tuple.getString(0);val.put(location, MapUtils.getInteger(val, location, 0) + 1);}@Overridepublic void complete(Map<String, Integer> val, TridentCollector collector) {collector.emit(new Values(val));}
}

 Topology:

topology.newStream("spout", spout).aggregate(new Fields("location"), new LocationAggregator(), new Fields("location_counts")).each(new Fields("location_counts"), new Utils.PrintFilter());

     这个aggregator很简单：计算每一个batch的location的数量。通过这个例子我们可以看到Aggregator接口：

• init():当刚开始接收到一个batch时执行
• aggregate():在接收到batch中的每一个tuple时执行
• complete():在一个batch的结束时执行

     我们前面讲过aggregate()方法是一个重定向方法，因为它会随机启动一个单独的线程来进行这个聚合操作。

     下面我们来看一下测试结果：

[{USA=3, Spain=1, UK=1}]
[{USA=3, Spain=2}]
[{France=1, USA=4}]
[{USA=4, Spain=1}]
[{USA=5}]

     我们可以看到打印的结果，其中每一条的和都是5，这是因为我们的Spout的每个batch中tuple数量设置的是5，所以每个线程的计算结果也会是5。 除此之外，Trident还提供了其它两个Aggregator接口: CombinerAggregator, ReducerAggregator,具体使用方法请参考Trident API。

2.3.2 partitionAggregate():

     如果我们将上面的Topology稍微改造一下，猜一下结果会是如何？

topology.newStream("spout", spout).partitionBy(new Fields("location")).partitionAggregate(new Fields("location"), new LocationAggregator(), new Fields("location_counts")).parallelismHint(3).each(new Fields("location_counts"), new Utils.PrintFilter());

     我们一起来分析一下，首先partitionBy()方法将tuples按其location字段重定向到下一处理逻辑，而且相同location字段的tuple一定会被分配到同一个线程中处理。其次，partitionAggregate()方法，注意它与Aggregate不同，它不是一个重定向方法，它仅仅是对当前partition上的各个batch执行聚合操作。因为我们根据location进行了重定向操作，测试数据一共有4个location，而当前一共有3个partition，因此可以猜测我们的最终测试结果中，有一个partition会处理两个location的batch，最终测试结果如下：

[{France=10, Spain=5}]
[{USA=63}]
[{UK=22}]

     需要注意的是，partitionAggregate虽然也是聚合操作，但与上面的Aggregate完全不同，它不是一个重定向操作。

2.4 groupBy

     我们可以看到上面几个例子的测试结果，其实我们通常想要的是每个location的数量是多少，那该怎么处理呢？看下面这个Topology：

topology.newStream("spout", spout).groupBy(new Fields("location")).aggregate(new Fields("location"), new Count(), new Fields("count")).each(new Fields("location", "count"), new Utils.PrintFilter());

     我们先看一下执行的结果：

...
[France, 25]
[UK, 2]
[USA, 25]
[Spain, 44]
[France, 26]
[UK, 3]
...

     上面这段代码计算出了每个location的数量，即使我们的Count函数没有指定并行度。这就是groupBy()起的作用，它会根据指定的字段创建一个GroupedStream，相同字段的tuple都会被重定向到一起，汇聚成一个group。groupBy()之后是aggregate，与之前的聚合整个batch不同，此时的aggregate会单独聚合每个group。我们也可以这么认为，groupBy会把Stream按照指定字段分成一个个stream group，每个group就像一个batch一样被处理。

     不过需要注意的是，groupBy()本身并不是一个重定向操作，但如果它后面跟的是aggregator的话就是，跟的是partitionAggregate的话就不是。

三、总结 

     Storm是一个实时流计算框架，Trident是对storm的一个更高层次的抽象，Trident最大的特点以batch的形式处理stream。

     一些最基本的操作函数有Filter、Function，Filter可以过滤掉tuple，Function可以修改tuple内容，输出0或多个tuple，并能把新增的字段追加到tuple后面。

     聚合有partitionAggregate和Aggregator接口。partitionAggregate对当前partition中的tuple进行聚合，它不是重定向操作。Aggregator有三个接口：CombinerAggregator, ReducerAggregator，Aggregator，它们属于重定向操作，它们会把stream重定向到一个partition中进行聚合操作。

     重定向操作会改变数据流向，但不会改变数据内容，重定向操会产生网络传输，可能影响一部分效率。而Filter、Function、partitionAggregate则属于本地操作，不会产生网络传输。

     GroupBy会根据指定字段，把整个stream切分成一个个grouped stream，如果在grouped stream上做聚合操作，那么聚合就会发生在这些grouped stream上而不是整个batch。如果groupBy后面跟的是aggregator，则是聚合操作，如果跟的是partitionAggregate，则不是聚合操作。

     上面所以的例子都可以在github上找到： https://github.com/pereferrera/trident-hackaton/