storm示例之trident

最新推荐文章于 2021-02-25 18:22:32 发布
最新推荐文章于 2021-02-25 18:22:32 发布
阅读量1.4k 收藏 3
点赞数
分类专栏： storm 文章标签： storm trident 事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cjf_wei/article/details/73699805
版权

storm在0.7中引入了事务型拓扑，以满足对消息处理有着极其严格要求的场景，例如某些应用于某些统计场景，当然要求统计量必须是完全精确的，不能多也不能少。你可以联想数据库的事务特性ACID来加深对事务型拓扑的理解。在storm的0.8版本之后，事务性已经被封装到Trident中。trident提供了一套非常成熟的批处理API来批量处理元组，可以对这些元组执行分组(group by)、连接(join)、聚合(aggregation)、运行函数、运行过滤器等，trident还封装了DRPC功能，同样支持DRPC远程调用。本文通过一个示例简介trident拓扑。

trident示例
新建工程，在project中的src/的同级新建lib/文件夹，将storm安装包根目录下的lib/文件夹下的所有jar包拷贝到新建工程的lib/目录下，并在eclipse中选中所有的jar包右键选择build path-> add to build path

Spout
下文的FixedBatchSpout是storm源码中自带的spout，用于向拓扑中发送一个语句，其中setCycle()方法可以设置向拓扑中循环发送语句。

FixedBatchSpout spout = new FixedBatchSpout(new Fields("sentence"), 3, new Values("the cow jumped over the moon"),...);

FixedBatchSpout的参数sentence为输出的字段名，数字3表示将发送的元组最多分为3个Batch进行处理，剩余的参数均为spout待发送的内容列表。
这里强调下参数3是最大的batch，实际的batch还受内容列表大小的限制，这在源码中的emitBatch()方法中得以体现。这里的Batch是指将元组分批处理。每个事务处理一批元组，各批次之间可以并行处理，以提高资源的利用率，减少相关联的事务间的等待。
FixedBatchSpout继承自IBatchSpout，IBatchSpout是一个非事务Spout，每次发送一个Batch元组。
FixedBatchSpout的源码实现如下：

//FixedBatchSpout.java
package org.apache.storm.trident.testing;

import org.apache.storm.Config;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.tuple.Fields;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;

import org.apache.storm.trident.operation.TridentCollector;
import org.apache.storm.trident.spout.IBatchSpout;

public class FixedBatchSpout implements IBatchSpout {

    Fields fields;
    List<Object>[] outputs;
    int maxBatchSize;
    HashMap<Long, List<List<Object>>> batches = new HashMap<Long, List<List<Object>>>();

    public FixedBatchSpout(Fields fields, int maxBatchSize, List<Object>... outputs) {
        this.fields = fields;
        this.outputs = outputs;
        this.maxBatchSize = maxBatchSize;
    }

    int index = 0;
    boolean cycle = false;

    public void setCycle(boolean cycle) {
        this.cycle = cycle;
    }

    @Override
    public void open(Map conf, TopologyContext context) {
        index = 0;
    }

    @Override
    public void emitBatch(long batchId, TridentCollector collector) {
        List<List<Object>> batch = this.batches.get(batchId);
        if(batch == null){
            batch = new ArrayList<List<Object>>();
            if(index>=outputs.length && cycle) {
                index = 0;
            }
            for(int i=0; index < outputs.length && i < maxBatchSize; index++, i++) {
                batch.add(outputs[index]);
            }
            this.batches.put(batchId, batch);
        }
        for(List<Object> list : batch){
            collector.emit(list);
        }
    }

    @Override
    public void ack(long batchId) {
        this.batches.remove(batchId);
    }

    @Override
    public void close() {
    }

    @Override
    public Map<String, Object> getComponentConfiguration() {
        Config conf = new Config();
        conf.setMaxTaskParallelism(1);
        return conf;
    }

    @Override
    public Fields getOutputFields() {
        return fields;
    }

}

批处理API
在Trident中each(),stateQuery()等操作功能类似于Storm拓扑中的BOLT，这些bolt实现对数据的分组，聚合，查询等。

TridentState wordCounts = topology.newStream("spout1", spout) 
    .parallelismHint(16)
    .each(new Fields("sentence"),new Split(), new Fields("word"))
    .groupBy(new Fields("word"))
    .persistentAggregate(new MemoryMapState.Factory(),new Count(), new Fields("count"))
    .parallelismHint(16);

TridentState对象在本例中代表了所有单词的统计，用于对外提供给DRPC服务进行查询。
newStream():newStream方法在拓扑中创建一个新的数据流以便从输入源中读取数据
parallelismHint():设置并行处理的数量
each()配合运行函数(或过滤器):
例如：each(new Fields(“sentence”),new Split(), new Fields(“word”)) //对每个输入的sentence”字段”，调用Split()函数进行处理,并生成新的字段word
例如：each(new Fields(“sentence”),new MyFilter()) //对每个输入的sentence”字段”，调用MyFilter()函数进行过滤
groupBy():分组操作，按特定的字段进行分组
persistentAggregate():聚合函数，persistentAggregate实现的是将数据持久到特定的存储介质中
stateQuery():提供对已生成的TridentState对象的查询
过滤器
FilterNull的实现如下

public class FilterNull extends BaseFilter {
    @Override
    public boolean isKeep(TridentTuple tuple) {
        for(Object o: tuple) {
            if(o==null) return false;
        }
        return true;
    }
}

完整的示例代码

//TridentWordCount.java
package org.apache.storm.starter.trident;

import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.LocalDRPC;
import org.apache.storm.StormSubmitter;
import org.apache.storm.generated.StormTopology;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Values;
import org.apache.storm.trident.TridentState;
import org.apache.storm.trident.TridentTopology;
import org.apache.storm.trident.operation.BaseFunction;
import org.apache.storm.trident.operation.TridentCollector;
import org.apache.storm.trident.operation.builtin.Count;
import org.apache.storm.trident.operation.builtin.FilterNull;
import org.apache.storm.trident.operation.builtin.MapGet;
import org.apache.storm.trident.operation.builtin.Sum;
import org.apache.storm.trident.testing.FixedBatchSpout;
import org.apache.storm.trident.testing.MemoryMapState;
import org.apache.storm.trident.tuple.TridentTuple;

public class TridentWordCount {

    public static class Split extends BaseFunction {
    @Override
        public void execute(TridentTuple tuple, TridentCollector collector) {
            String sentence = tuple.getString(0);
            for (String word : sentence.split(" ")) {
                collector.emit(new Values(word));
            }
        }
    }

    public static StormTopology buildTopology(LocalDRPC drpc) {
        FixedBatchSpout spout = new FixedBatchSpout(new Fields("sentence"), 3, new Values("the cow jumped over the moon"),
            new Values("the man went to the store and bought some candy"), new Values("four score and seven years ago"),
            new Values("how many apples can you eat"), new Values("to be or not to be the person"));
        spout.setCycle(true);

        TridentTopology topology = new TridentTopology();
        TridentState wordCounts = topology.newStream("spout1", spout) //newStream方法在拓扑中创建一个新的数据流以便从输入源(FixedBatchSpout)中读取数据
            .parallelismHint(16)
            .each(new Fields("sentence"),new Split(), new Fields("word")) //each(),对每个输入的sentence"字段"，调用Split()函数进行处理
            .groupBy(new Fields("word"))
            .persistentAggregate(new MemoryMapState.Factory(),new Count(), new Fields("count"))
            .parallelismHint(16);

        topology.newDRPCStream("words", drpc) //以words作为函数名，对应于drpc.execute("words", "cat the dog jumped")中的words名
            .each(new Fields("args"), new Split(), new Fields("word"))//对于输入参数args，使用Split()方法进行切分,并以word作为字段发送
            .groupBy(new Fields("word"))//对word字段进行重新分区，保证相同的字段落入同一个分区
            .stateQuery(wordCounts, new Fields("word"), new MapGet(), new Fields("count"))
            .each(new Fields("count"),new FilterNull())//使用FilterNull()方法过滤count字段的数据(过滤没有统计到的单词)
            .aggregate(new Fields("count"), new Sum(), new Fields("sum"));

        return topology.build();
    }

    public static void main(String[] args) throws Exception {
        Config conf = new Config();
        conf.setMaxSpoutPending(20);
        if (args.length == 0) {
            LocalDRPC drpc = new LocalDRPC();
            LocalCluster cluster = new LocalCluster();
            cluster.submitTopology("wordCounter", conf, buildTopology(drpc));
            for (int i = 0; i < 100; i++) {
                System.out.println("DRPC RESULT: " + drpc.execute("words", "cat the dog jumped"));
                Thread.sleep(1000);
            }
        } else {
            conf.setNumWorkers(3);
            StormSubmitter.submitTopologyWithProgressBar(args[0], conf, buildTopology(null));
        }
    }
}

将代码打成jar包，提交storm拓扑，可以通过storm日志 ./storm/logs/workers-artifacts/* 观察实时的统计；
也可以通过DRPC，远程查询相关字段的统计
DRPC客户端 查询

import backtype.storm.utils.DRPCClient;

public class TestDRPC {

    public static void main(String[] args) throws Exception{
        // TODO Auto-generated method stub
        DRPCClient client = new DRPCClient("localhost",3772);//3772是drpc对外默认的服务端口
        System.out.println("DRPC result:" + client.execute("words", "the man storm"));
    }
}

storm会切分查询列表”the man storm”（each(new Fields(“args”), new Split(), new Fields(“word”))），并通过stateQuery进行查询

最后，基于trident API可以实现函数功能(例如Split)，过滤器(例如FilterNull())，分区聚合(例如persistentAggregate)，状态查询(例如stateQuery)，投影,重新分组，合并，连接等。具体可以参考相关接口，文献[1]中也有相关简介。

1.赵必夏,程丽明. 从零开始学Storm(第二版).清华大学出版社,2016.

cjf_wei
关注
专栏目录
利用Trident topology实现预测疾病暴发的实例完整实例源码
01-21
利用Trident topology实现预测疾病暴发的实例完整实例源码，具体详情参见博文：http://blog.csdn.net/l1028386804/article/details/79120204
Storm_Trident
08-18
storm_Trident例子
Trident API概述
xqy1522的专栏
01-19 4794
Storm Trident的核心数据模型是一批一批被处理的“流”，“流”在集群的分区在集群的节点上，对“流”的操作也是并行的在每个分区上进行。   Trident有五种对“流”的操作： 1.      不需要网络传输的本地批次运算 2.      需要网络传输的“重分布”操作，不改变数据的内容 3.      聚合操作，网络传输是该操作的一部分 4.      “流”分组（grouby
storm-[5]-Trident实例
hjw199089的博客
05-12 1043
翻译学习《storm分布式实时计算模式》 检测某地区的疾病突发 1-Topoloy OutbreakDetectionTopology中处理函数拓扑： [6]Trident实例 > image2017-5-12 15:40:21.png" height="250" src="https://wiki.sankuai.com/download/attachments/8
Storm Trident示例partitionAggregate
nickta的专栏
03-23 405
partitionAggregate是针对于每个partition，而不是每个batch,对每个partition当中的tuple做聚合省略部分代码，省略部分可参考：https://blog.csdn.net/nickta/article/details/79666918FixedBatchSpout spout = new FixedBatchSpout(new Fields("user", "...
Storm:使用 Apache Storm 的示例
06-22
此存储库专用于 Apache Storm 项目和代码示例。 关于风暴 要了解有关 Storm 的更多信息，最好阅读 Storm 官方网页上的。 这是一个很好的指南，并且有一些非常好的链接。 它也不长且易于理解。 运行示例 在做任何事情...
storm之TridentFilter使用示例代码.zip
最新发布
12-28
Storm的核心概念之一是Trident，这是一个高容错、低延迟的数据处理模型。本篇将深入探讨TridentFilter在Apache Storm中的应用，通过提供的示例代码帮助理解其工作原理和使用方法。 Trident是Storm中的一个高级API，...
storm-trident-example
07-03
风暴三叉戟示例 Clojure 库旨在......好吧，那部分取决于您。 用法 整我 执照 版权所有 :copyright: 2014 FIXME 根据 Eclipse 公共许可证分发 1.0 版或（由您选择）任何更高版本。
storm-trident-examples:三叉戟API
07-02
这个项目是 Storm's Trident 的游乐场。 在这个项目中，您可以找到我用于柏林的 Trident hackaton @ Big Data Beers #4 的指南： : 在 Demo.java 文件中。 您还可以在示例子包中找到我解释的概念的说明性示例。 ...
Storm Trident+DRPC实例
Nougats的博客
05-27 479
需求Trident实现用户使用浏览器统计 通过DRPC查看结果开发过程实现IBatchSpout批量读取日志文件 public class MyBatchSpout implements IBatchSpout { Fields fields; HashMap<Long, List<List<Object>>> batches = new HashMap(); public
Strom的trident小例子
weixin_34082695的博客
11-13 78
上代码: 1 public class TridentFunc { 2 3 /** 4 * 类似于普通的bolt 5 */ 6 public static class MyFunction extends BaseFunction{ 7 @Override 8 ...
trident demo 1
Frank的博客
07-20 681
做几个storm的小程序来练手，买了一本Storm的书，但是书中的代码运行都报错，实在是心累啊。这本书出版较早，所用的storm和zookeeper的版本都较早，所以出现了一些方法已经不存在的问题。在我的艰难探索下，纠正了很多。书中的例子涉及内容很多，有kafka的，Cassandra的，Tina的，openfire的，等等等等。简直就是百科全书啊，与其说是Storm的书，倒不如是介绍各种流行技术的
storm mysql trident_storm trident实战 trident state
weixin_29292535的博客
01-30 132
一、认识storm tridenttrident可以理解为storm批处理的高级抽象,提供了分组、分区、聚合、函数等操作,提供一致性和恰好一次处理的语义。1)元祖被作为batch处理2)每个batch的元祖都被指定唯一的一个事物id,如果因为处理失败导致batch重发,也和保证和重发前一样的事物id3)数据更新操作严格有序,比如batch1必须在batch2之前被成功处理,且如果batch1失败了...
Storm官方提供的trident单词计数的例子
weixin_33859844的博客
04-06 172
上代码: 1 public class TridentWordCount { 2 public static class Split extends BaseFunction { 3 @Override 4 public void execute(TridentTuple tuple, TridentCollector collector) { 5 ...
4.storm中的拓扑示例(进程/线程/任务)
爱[黎姿]的程序员
12-11 559
下面定义一个名为 mytopology 的拓扑,由一个 Spout 组件(BlueSpout)、两个 Bolt 组件 (GreenBolt 和 YellowBolt)共 3 个组件构成。 Config conf = new Config();  conf.setNumWorkers(2);  // 使用两个工作进程 topologyBui
java操作storm_Storm Trident
weixin_35227213的博客
02-25 325
Trident是Storm的延伸。像Storm一样，Trident也是由Twitter开发的。开发Trident的主要原因是在Storm之上提供高级抽象以及有状态流处理和低延迟分布式查询。Trident使用喷嘴和螺栓，但这些底层组件在执行前由Trident自动生成。Trident具有功能，过滤器，连接，分组和聚合。Trident处理流作为一系列被称为交易的批次。通常，这些小批量的大小将取决于数千或...
jstorm源码之TridentTopology
xixihaha_123的专栏
03-16 286
在jstorm中对应TridentTopology的源码如下，TridentTopology的主要作用是用来创建trident的 一、一般使用的方式如下 // 1、创建一个topology对象 TridentTopology topology = new TridentTopology(); // 2、设置相关参数： each分片、group by分组、聚合aggregate // 返...
[Trident] Storm Trident 教程，state详解、trident api详解及实例
qi49125的博客
03-09 961
英文原址：https://github.com/nathanmarz/storm/wiki/Trident-tutorial----------------Trident是在storm基础上，一个以realtime 计算为目标的高度抽象。 它在提供处理大吞吐量数据能力的同时，也提供了低延时分布式查询和有状态流式处理的能力。 如果你对Pig和Cascading这种高级批量处理工具很了解的话，那么应该...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值