基于Apache Storm Trident实时计算开发 下

最新推荐文章于 2021-01-30 22:57:13 发布
最新推荐文章于 2021-01-30 22:57:13 发布
阅读量171 收藏
点赞数
分类专栏： 技术文章
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40208605/article/details/105792236
版权

2.5.5 测试生产Kafka消息

如果能看到控制台不断打印输出以下消息，表示日志已经生产到kafka指定的topic中 
2018-12-25 08:17||14.5.1.156||/trident/admin/ttt.html
2018-12-25 08:17||16.1.3.155||/trident/admin/taaa.html
2018-12-25 08:17||16.0.0.155||/trident/admin/att.html
2018-12-25 08:17||13.2.3.157||/trident/admin/katk.html
2018-12-25 08:17||14.2.1.156||/trident/admin/kaka.html
2018-12-25 08:17||10.0.3.155||/trident/admin/akta.html
2018-12-25 08:17||15.3.1.155||/trident/admin/att.html
2018-12-25 08:17||12.3.5.156||/trident/admin/ktaa.html
2018-12-25 08:17||14.3.2.157||/trident/admin/aatt.html
2018-12-25 08:17||15.4.4.156||/trident/admin/taaa.html
2018-12-25 08:17||12.5.0.157||/trident/admin/atka.html
2018-12-25 08:17||13.2.3.156||/trident/admin/tkat.html
2018-12-25 08:17||13.3.0.156||/trident/admin/kaa.html
2018-12-25 08:17||11.0.1.156||/trident/admin/kta.html
2018-12-25 08:17||14.4.3.157||/trident/admin/kttt.html

在kafka中，使用以下命令检测是否能够消费topic中的数据

bin/kafka-console-consumer.sh --zookeeper node-1:2181 --topic visit_url --from-beginning

2.5.6 Trident整合Kafka

导入依赖
千万注意kafka版本号要与安装的版本号一致，否则程序无法运行 
<dependencies>
        <dependency>
            <groupId>org.apache.storm</groupId>
            <artifactId>storm-core</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.storm</groupId>
            <artifactId>storm-kafka</artifactId>
            <version>1.1.1</version>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.kafka</groupId>
                    <artifactId>kafka-clients</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka_2.11</artifactId>
            <version>0.11.0.0</version>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.zookeeper</groupId>
                    <artifactId>zookeeper</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <target>1.8</target>
                    <source>1.8</source>
                </configuration>
            </plugin>
        </plugins>
    </build>

Trident整合Kafka

ZkHosts zkHosts = new ZkHosts("node-1:2181,node-2:2181,node-3:281");
TridentKafkaConfig kafkaConfig = new TridentKafkaConfig(zkHosts, "visit_url");
OpaqueTridentKafkaSpout kafkaSpout = new OpaqueTridentKafkaSpout(kafkaConfig);

2.5.7 防恶意服务器攻击Trident拓扑结构图 
2.5.8 Trident实时程序开发

JedisPoolClient.java，使用Jedis连接池获取jedis连接操作Redis 
package com.itheima.trident;
 
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
 
public class JedisPoolClient {
 
    private static JedisPool pool = null;
 
    static {
        if (pool == null) {
            JedisPoolConfig config = new JedisPoolConfig();
            //控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；
            //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
            config.setMaxTotal(50);
            //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。
            config.setMaxIdle(5);
            //表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；单位毫秒
            //小于零:阻塞不确定的时间,  默认-1
            config.setMaxWaitMillis(1000 * 100);
            //在borrow(引入)一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
            config.setTestOnBorrow(true);
            //return 一个jedis实例给pool时，是否检查连接可用性（ping()）
            config.setTestOnReturn(true);
            pool = new JedisPool(config, "node-1", 6379, 2000);
        }
    }
 
    public static Jedis getJedis() {
        return pool.getResource();
    }
 
    public static void returnResource(Jedis jedis) {
        if (jedis != null) {
            jedis.close();
        }
    }
}

IpWatcherTopology.java，Trident的实现都在这个文件中

package com.itheima.trident;
 
import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.generated.StormTopology;
import org.apache.storm.kafka.ZkHosts;
import org.apache.storm.kafka.trident.OpaqueTridentKafkaSpout;
import org.apache.storm.kafka.trident.TridentKafkaConfig;
import org.apache.storm.shade.org.apache.commons.lang.StringUtils;
import org.apache.storm.trident.TridentTopology;
import org.apache.storm.trident.operation.BaseAggregator;
import org.apache.storm.trident.operation.BaseFunction;
import org.apache.storm.trident.operation.TridentCollector;
import org.apache.storm.trident.tuple.TridentTuple;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Values;
import redis.clients.jedis.Jedis;
 
import java.nio.charset.Charset;
 
public class IpWatcherTopology {
    public static void main(String[] args) {
 
        // 配置ZooKeeper集群地址
        ZkHosts zkHosts = new ZkHosts("node-1:2181,node-2:2181,node-3:281");
        // 设置Kafka配置，指定消费的url
        TridentKafkaConfig kafkaConfig = new TridentKafkaConfig(zkHosts, "visit_url");
        // 创建KafkaSpout
        OpaqueTridentKafkaSpout kafkaSpout = new OpaqueTridentKafkaSpout(kafkaConfig);
 
        // 创建TridentTopology
        TridentTopology tridentTopology = new TridentTopology();
        // 基于KafkaSpout创建Trident流
        tridentTopology.newStream("event", kafkaSpout)
                // 指定对输入的bytes字段进行SplitFunc运行，并生成ip字段和url的tuple
                .each(new Fields("bytes"), new SplitFunc(), new Fields("ip", "url"))
                // 按照ip、url进行分组
                .groupBy(new Fields("ip", "url"))
                // 对分组内的数据进行聚合运行，输出ip1、url1、count（注意：输出的field不能和输入的field名称一致
                .aggregate(new Fields("ip", "url"), new SumAggregate(), new Fields("ip1", "url1", "count"))
                // 统计后的ip、url、计数保存到redis中
                .each(new Fields("ip1", "url1", "count"), new RedisFunc(), new Fields("ip:url", "totalCount"))
                // 检查ip、url是否访问异常，如果出现异常放入黑名单
                .each(new Fields("ip:url", "totalCount"), new CheckIpFunc(), new Fields());
 
        StormTopology stormTopology = tridentTopology.build();
 
        LocalCluster localCluster = new LocalCluster();
        localCluster.submitTopology("ipWatcher", new Config(), stormTopology);
    }
 
    /**
     * 切割消息，获取到IP和URL
     */
    private static class SplitFunc extends BaseFunction {
        @Override
        public void execute(TridentTuple tuple, TridentCollector collector) {
            String message = new String(tuple.getBinary(0), Charset.forName("utf-8"));
            String[] fields = message.split("\\|\\|");
 
            if(fields.length >= 3) {
                System.out.println(fields[1]);
                collector.emit(new Values(fields[1], fields[2]));
            }
        }
    }
 
    /**
     * 聚合计算
     */
    private static class SumAggregate extends BaseAggregator<SumAggregate.IpCount> {
 
        /**
         * 用来保存分组的中间结果
         */
        static class IpCount {
            String ip;
            String url;
            long count;
        }
 
        @Override
        public IpCount init(Object batchId, TridentCollector collector) {
            return new IpCount();
        }
 
        // aggregate会被调用多次，每一个组内的数据都会被用于计算
        @Override
        public void aggregate(IpCount ipCount, TridentTuple tuple, TridentCollector collector) {
            if(StringUtils.isNotBlank(ipCount.ip)) {
                ipCount.count += 1;
            }
            else {
                ipCount.ip = tuple.getString(0);
                ipCount.url = tuple.getString(1);
                ipCount.count = 1;
            }
        }
 
        // 聚合计算完后，需要将数据发送给下游
        @Override
        public void complete(IpCount ipCount, TridentCollector collector) {
            collector.emit(new Values(ipCount.ip, ipCount.url, ipCount.count));
        }
    }
 
    private static class RedisFunc extends BaseFunction {
        @Override
        public void execute(TridentTuple tuple, TridentCollector collector) {
            // 从Jedis连接池中获取Jedis连接
            Jedis jedis = JedisPoolClient.getJedis();
            jedis.select(0);
 
            String key = tuple.getString(0) + ":" + tuple.getString(1);
 
            if(jedis.exists(key)) {
                jedis.incrBy(key, tuple.getLong(2));
            }
            else {
                // 设置监听60秒
                jedis.setex(key, 60, tuple.getLong(2).toString());
            }
 
            String newCount = jedis.get(key);
            JedisPoolClient.returnResource(jedis);
 
            collector.emit(new Values(key, Long.parseLong(newCount)));
        }
    }
 
    private static class CheckIpFunc extends BaseFunction {
        @Override
        public void execute(TridentTuple tuple, TridentCollector collector) {
            Long totalCount = tuple.getLong(1);
 
            if(totalCount > 5) {
                Jedis jedis = JedisPoolClient.getJedis();
                jedis.select(1);
 
                String ip = tuple.getString(0).split(":")[0];
 
                if(!jedis.exists(ip)) {
                    jedis.setex(ip, 1800, "1");
                    System.out.println(ip + "加入黑名单");
                }
                JedisPoolClient.returnResource(jedis);
            }
        }
    }
}

2.5.9 测试

启动Redis，直接运行Trident，可以看到程序不断在redis中写入数据。 

db0中存放的是所有ip访问的url次数数据

db1中存放的黑名单，也就是“监狱”

2.6 关于Trident的并行度设置

Trident的并行度可以在每一个Stream的操作后设置它的并行度数量：

parallelismHint(4)

这个配置就表示需要几个executor来执行这个Stream操作，而每个executor就对应一个线程。而关于worker的设置，和storm保持一致，在config中可以设置worker的数量。

config.setNumWorkers(2);

以下代码是设置trident的并行度：

package com.itheima.trident;
 
import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.generated.StormTopology;
import org.apache.storm.kafka.ZkHosts;
import org.apache.storm.kafka.trident.OpaqueTridentKafkaSpout;
import org.apache.storm.kafka.trident.TridentKafkaConfig;
import org.apache.storm.shade.org.apache.commons.lang.StringUtils;
import org.apache.storm.trident.TridentTopology;
import org.apache.storm.trident.operation.BaseAggregator;
import org.apache.storm.trident.operation.BaseFunction;
import org.apache.storm.trident.operation.TridentCollector;
import org.apache.storm.trident.tuple.TridentTuple;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Values;
import redis.clients.jedis.Jedis;
 
import java.nio.charset.Charset;
 
public class IpWatcherTopology {
    public static void main(String[] args) {
 
        // 配置ZooKeeper集群地址
        ZkHosts zkHosts = new ZkHosts("node-1:2181,node-2:2181,node-3:281");
        // 设置Kafka配置，指定消费的url
        TridentKafkaConfig kafkaConfig = new TridentKafkaConfig(zkHosts, "visit_url");
        // 创建KafkaSpout
        OpaqueTridentKafkaSpout kafkaSpout = new OpaqueTridentKafkaSpout(kafkaConfig);
 
        // 创建TridentTopology
        TridentTopology tridentTopology = new TridentTopology();
        // 基于KafkaSpout创建Trident流
        tridentTopology.newStream("event", kafkaSpout).parallelismHint(2)
                // 指定对输入的bytes字段进行SplitFunc运行，并生成ip字段和url的tuple
                .each(new Fields("bytes"), new SplitFunc(), new Fields("ip", "url")).parallelismHint(2)
                // 按照ip、url进行分组
                .groupBy(new Fields("ip", "url"))
                // 对分组内的数据进行聚合运行，输出ip1、url11、count（注意：输出的field不能和输入的field名称一致
                .aggregate(new Fields("ip", "url"), new SumAggregate(), new Fields("ip1", "url1", "count")).parallelismHint(2)
                // 统计后的ip、url、计数保存到redis中
                .each(new Fields("ip1", "url1", "count"), new RedisFunc(), new Fields("ip:url", "totalCount")).parallelismHint(4)
                // 检查ip、url是否访问异常，如果出现异常放入黑名单
                .each(new Fields("ip:url", "totalCount"), new CheckIpFunc(), new Fields()).parallelismHint(2);
 
        StormTopology stormTopology = tridentTopology.build();
 
        Config config = new Config();
        config.setNumWorkers(3);
 
        LocalCluster localCluster = new LocalCluster();
        localCluster.submitTopology("ipWatcher", , stormTopology);
    }

这里一共设置了12个线程，3个worker。

3. 总结

​        通过本次Trident的案例，我们可以看到，Trident编程要比Storm简洁很多，而且它是以Batch为单位来对数据进行处理，这样大大提高了执行效率，也减少了程序编写的复杂度。但是我们也发现了不足的地方，每一个Stream操作，都要实现自定义的方法，这种方式对比Spark Streaming体验就要差很多了。不过，优点是，它是基于Java编写的，对于熟悉Java开发的同学，或者与Java库的对接会更加友好。

以下为编写Trident程序的要点：

  • 设计整合外部输入源的SPOUT

  • 设计Trident的Topology

  • 设计每一个Stream操作的输入和输出

  • 设计每个Stream操作的处理函数（记住：这个函数是在处理每一个batch的时候，不断被调用的）

我是楠楠
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Apache Storm-2.0.0 Trident 新版
麦田里的守望者-蒋中洲【相信相信的力量】
06-27 508
Storm Trident 作者：jiangzz 电话：15652034180 微信：jiangzz_wx 微信公众账号：jiangzz_wy 百知教育 Trident是一个高级抽象，用于在Storm之上进行实时计算。它允许您无缝混合高吞吐量（每秒数百万条消息），有状态流处理和低延迟分布式查询。如果您熟悉Pig或Cascading等高级批处理工具，Trident的概念将非常熟悉 - Trident...
Java小白必学：基于Apache Storm Trident实时计算开发！
qq_41293655的博客
02-22 205
1. 概述Apache Storm是一个经典的分布式流式计算编程框架，但编写程序比较麻烦。通常，一个基本的基于Storm的流式计算程序需要有以下几个部分：一个Spout、若干个Bolt、一个Topology。Spout和Bolt程序编写，以及Topology的编排不是太友好。今天，我要介绍的是，基于Storm的更高层次的抽象——Trident。它的API要比Storm更加简洁，而且支持迭代计算，不需要反复的创建Bolt来进行操作。 2. 主要内容 2.1 Trident程序架构 简单解释下上图： 1. T.
Apache Storm 官方文档 —— Trident State
weixin_34202952的博客
04-01 96
原文链接 译者：魏勇 Trident 中含有对状态化（stateful）的数据源进行读取和写入操作的一级抽象封装工具。这个所谓的状态（state）既可以保存在拓扑内部（保存在内存中并通过 HDFS 来实现备份），也可以存入像 Memcached 或者 Cassandra 这样的外部数据库中。而对于 Trident API 而言，这两种机制并没有任何...
基于Apache Storm Trident实时计算开发 上
qq_40208605的博客
06-18 295
1. 概述Apache Storm是一个经典的分布式流式计算编程框架，但编写程序比较麻烦。通常，一个基本的基于Storm的流式计算程序需要有以下几个部分：一个Spout、若干个Bolt、一个Topology。Spout和Bolt程序编写，以及Topology的编排不是太友好。今天，我要介绍的是，基于Storm的更高层次的抽象——Trident。它的API要比Storm更加简洁，而且支持迭代计算，不需要反复的创建Bolt来进行操作。 2. 主要内容 2.1 Trident程序架构 简单解释下上图： 1....
storm mysql trident_Storm入门（十三）Storm Trident 教程
weixin_39914752的博客
01-30 92
英文原址：https://github.com/nathanmarz/storm/wiki/Trident-tutorial----------------Trident是在storm基础上，一个以realtime 计算为目标的高度抽象。 它在提供处理大吞吐量数据能力的同时，也提供了低延时分布式查询和有状态流式处理的能力。 如果你对Pig和Cascading这种高级批量处理工具很了解的话，那么应该...
Storm Trident实战之计算网站PV.rar
05-20
在大数据处理领域，Apache Storm是一个实时计算框架，它允许开发者处理和分析连续的数据流。而Trident是Storm的一个高级API，提供了可靠且精确一次的消息处理语义，常用于大规模实时数据处理任务，如日志分析、网站...
Storm:使用 Apache Storm 的示例
06-22
在本地模式下运行拓扑意味着您的代码在模拟的 Storm 集群上运行，而在分布式模式下运行意味着您的代码在实时 Storm 集群上运行。 本地模式 TODO：添加一些关于在本地模式下运行事物的注释 分布式模式 要以分布式...
Storm Trident API 使用详解.docx
05-20
Storm Trident API 是 Apache Storm 框架中用于构建实时大数据处理应用程序的关键组件。它的核心概念是"Stream"，一种无界的数据序列，它被分割成一系列批次（Batch），以便在分布式环境中进行并行处理。Trident API...
apache-storm-2.1.0.tar.gz
11-13
Apache Storm是大数据处理领域的一个重要工具，它是一个分布式实时计算系统。这个名为"apache-storm-2.1.0.tar.gz"的压缩包包含了Apache Storm的2.1.0版本，这是一个非源码的发行版，意味着它包含了编译后的二进制...
KafkaStormES:这是从Kafka中读取并在Elastic Search中建立索引的简单Apache Storm Trident拓扑
04-28
卡夫卡风暴这是从Kafka中读取并在Elastic Search中建立索引的简单Apache Storm Trident拓扑。 ##运行此Storm拓扑所需的设置### 1）Zookeeper。 Download from ...
storm-kafka实时趋势分析
01-23
storm-kafka实时趋势分析，通用性很强，稍微改动可以使用多种场景
storm安装包 apache-storm-1.2.1 2
04-25
apache-storm-1.2.1 2,安装包，帮助不能下载的同学apache-storm-1.2.1 2,安装包，帮助不能下载的同学apache-storm-1.2.1 2,安装包，帮助不能下载的同学apache-storm-1.2.1 2,安装包，帮助不能下载的同学apache-storm-1.2.1 2,安装包，帮助不能下载的同学apache-storm-1.2.1 2,安装包，帮助不能下载的同学
java kmeans聚合算法
04-21
比如给出1千个坐标，求出这1千个坐标的重心点。 本人从pascal算法转成java
Storm-Trident State
dark
10-15 310
《从零开始学Storm》 apachecn/storm-doc-zh
Storm-Trident实践
dark
10-15 492
apachecn/storm-doc-zh 本文主要是将之前学习的Trident做一个总结，由于Trident的资料相对较少，排坑过程中相对艰难（也可能是我打开的方式不对orz），本文主要将Trident API的各种实现给罗列了一下，主要分为如下几个部分： 概述： 讲述需求 Trident实现WordCount RedisState实践 Trident DRPC 实践 TridentKaf...
Apache Storm集群架构
ItStar
12-06 463
Apache Storm的主要亮点是，它是一个容错，快速，没有“单点故障”（SPOF）分布式应用程序。我们可以根据需要在多个系统中安装Apache Storm，以增加应用程序的容量。让我们看看Apache Storm集群如何设计和其内部架构。下图描述了集群设计。Apache Storm有两种类型的节点，Nimbus（主节点）和Supervisor（工作节点）。Nimbus是Apache Storm
[Trident] Storm Trident 教程，state详解、trident api详解及实例
qi49125的博客
03-09 942
英文原址：https://github.com/nathanmarz/storm/wiki/Trident-tutorial----------------Trident是在storm基础上，一个以realtime 计算为目标的高度抽象。 它在提供处理大吞吐量数据能力的同时，也提供了低延时分布式查询和有状态流式处理的能力。 如果你对Pig和Cascading这种高级批量处理工具很了解的话，那么应该...
使用storm trident消费kafka消息
zjbagb的博客
01-06 4693
一、前言     storm通过保证数据至少被处理一次来保证数据的完整性,由于元祖可以重发,对于一些需要数据精确的场景,可以考虑用storm trident实现。     传统的事物型拓扑中存在几种bolt：  1.1 BasicBolt    这是最基本的Bolt,BasicBolt每次只能处理一个tuple,而且必须等前一个tuple成功处理后下一个tuple才能继续处理,显然效率不高
Storm中Trident框架详解
蔡政洁的博客
12-31 1309
目录一、Storm Trident概述及特性二、TridentTopology与StormToplogy三、TridentTopology的可靠性机制详解四、Storm Trident API讲解 一、Storm Trident概述及特性 Trident是在storm基础上，一个以realtime 计算为目标的高度抽象。 它在提供处理大吞吐量数据能力的同时，也提供了低延时分布式查询和有状态流式处理的能力。好比 Mapreduce框架的Pig，Trident是Storm提供的基于基本API开发的高级框架。Tr
Apache Storm: 实时计算系统详解与实战应用
Apache Storm 是一款强大的分布式实时计算系统，由创业公司 BackType 在 2011 年开发。该系统的发展历程始于 Twitter 收购 BackType 后，同年 8 月，storm 被正式开源，初始版本为 "storm0.5.0"，标志着实时处理领域...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值