Storm 从入门到精通 第二十一讲 Storm DRPC 之 官方复杂示例 TiwtterReachTopology

最新推荐文章于 2024-08-10 08:47:35 发布
最新推荐文章于 2024-08-10 08:47:35 发布
阅读量723 收藏
点赞数
分类专栏： Storm框架 Storm 从入门到精通 文章标签： Storm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/netcobol/article/details/79837021
版权

1. 示例需求

解决在微博、论坛进行转发帖子的时候， 是对URL进行转发,分析给粉丝(关注我的人),那么每一个人的粉丝(关注者可能会有重复的情况),需求就是统计一下帖子(URL)的转发人数

2. 解决方案

实现步骤如下:
   第一：获取当前转发帖子的人。 GetTweetersBolt
   第二：获取当前人的粉丝(关注者)。GetFollowersBolt
   第三：进行粉丝去重。PartialUniquerBatchBolt
   第四：统计人数。CountAggregatorBatchBlot
   第五：最后使用DRPC远程调用 Topology返回执行结果 TiwtterReachTopology

3. 代码示例

TiwtterReachTopology

package com.john.learn.storm.drpc.reach;

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

import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.LocalDRPC;
import org.apache.storm.StormSubmitter;
import org.apache.storm.drpc.LinearDRPCTopologyBuilder;
import org.apache.storm.generated.AlreadyAliveException;
import org.apache.storm.generated.AuthorizationException;
import org.apache.storm.generated.InvalidTopologyException;
import org.apache.storm.logging.ThriftAccessLogger;
import org.apache.storm.tuple.Fields;

import com.john.learn.storm.drpc.reach.bolt.CountAggregatorBatchBlot;
import com.john.learn.storm.drpc.reach.bolt.GetFollowersBolt;
import com.john.learn.storm.drpc.reach.bolt.GetTweetersBolt;
import com.john.learn.storm.drpc.reach.bolt.PartialUniquerBatchBolt;

import clojure.main;

public class TiwtterReachTopology {

  public static Map<String, String> URLS_DB = new HashMap<>();

  // 模拟Who转发了URL
  public static Map<String, List<String>> TWEETERS_DB = new HashMap<String, List<String>>();

  // 模拟转发人员的粉丝人员
  public static Map<String, List<String>> FOLLOWERS_DB = new HashMap<String, List<String>>();

  /**
   * 初始化数据， 实际数据应该保存在Database / Mongon / Redis， 这里仅仅模拟学习
   */
  static {

     URLS_DB.put("1", "www.tiwtter.com");
     URLS_DB.put("2", "engineering.twitter.com/blog/5");
     URLS_DB.put("3", "tech.backtype.com/blog/123");

     TWEETERS_DB.put("1", Arrays.asList("sally", "bob", "tim", "george", "nathan"));
     TWEETERS_DB.put("2", Arrays.asList("adam", "david", "sally", "nathan"));
     TWEETERS_DB.put("3", Arrays.asList("tim", "mike", "john"));

     FOLLOWERS_DB.put("george", Arrays.asList("alice","adam", "jim", "chris", "jai"));
     FOLLOWERS_DB.put("sally", Arrays.asList("bob", "tim", "alice", "adam", "jim", "chris", "jai"));
     FOLLOWERS_DB.put("bob", Arrays.asList("tim", "nathan", "jim", "mary", "david", "vivian"));
     FOLLOWERS_DB.put("tim", Arrays.asList("alex"));
     FOLLOWERS_DB.put("nathan",
          Arrays.asList("sally", "bob", "adam", "harry", "chris", "vivian", "emily", "jordan"));
     FOLLOWERS_DB.put("adam", Arrays.asList("david", "carissa"));
     FOLLOWERS_DB.put("mike", Arrays.asList("john", "bob"));
     FOLLOWERS_DB.put("john", Arrays.asList("alice", "nathan", "jim", "mike", "bob"));

  }

  public TiwtterReachTopology(String functionName) {

     config = new Config();

     linearDRPCTopologyBuilder = new LinearDRPCTopologyBuilder(functionName);
     linearDRPCTopologyBuilder.addBolt(new GetTweetersBolt(), 3);
     linearDRPCTopologyBuilder.addBolt(new GetFollowersBolt(), 12).shuffleGrouping();
     linearDRPCTopologyBuilder.addBolt(new PartialUniquerBatchBolt(), 6)
          .fieldsGrouping(new Fields("Id", "Follower"));
     linearDRPCTopologyBuilder.addBolt(new CountAggregatorBatchBlot(), 3).fieldsGrouping(new Fields("Id"));
  }

  public LocalDRPC submitLocal() {

     LocalDRPC drpc = new LocalDRPC();

     LocalCluster cluster = new LocalCluster();

     cluster.submitTopology("TiwtterReachTopology", config, linearDRPCTopologyBuilder.createLocalTopology(drpc));

     return drpc;

  }

  public void submitRemote() {

     config.setNumWorkers(3);

     // Server Mode
     try {

       StormSubmitter.submitTopology("TiwtterReachTopology", config,
            linearDRPCTopologyBuilder.createRemoteTopology());

     } catch (Exception e) {

       throw new RuntimeException(e);
     }
  }

  private LinearDRPCTopologyBuilder linearDRPCTopologyBuilder;

  private Config config;

  public static void main(String[] args) {

     TiwtterReachTopology tiwtterReachTopology = new TiwtterReachTopology("TiwtterReach");

     if (args == null || args.length == 0) {

       LocalDRPC localDRPC = tiwtterReachTopology.submitLocal();

       System.out.println("Please input a free flag to start reach function");
       
       System.out.println("Reach Count :" + localDRPC.execute("TiwtterReach", "foo.com/blog/1"));

       System.exit(1);

     }
     
     tiwtterReachTopology.submitRemote();
     

  }

}

 注意： 如下Code 中 分组非常重要。

linearDRPCTopologyBuilder = new LinearDRPCTopologyBuilder(functionName);

 linearDRPCTopologyBuilder.addBolt(new GetTweetersBolt(), 3);
 linearDRPCTopologyBuilder.addBolt(new GetFollowersBolt(), 12).shuffleGrouping();
 linearDRPCTopologyBuilder.addBolt(new PartialUniquerBatchBolt(), 6)
          .fieldsGrouping(new Fields("Id", "Follower"));

  linearDRPCTopologyBuilder.addBolt(new CountAggregatorBatchBlot(), 3).fieldsGrouping(new Fields("Id"));

 问题： 对于红色部分，如果将fieldsGrouping(new Fields("Id", "Follower")) 修改成 fieldsGrouping(new Fields("Id")) 可以么？

不可以，导致所有ID 都在一个Blot Executor 中计算，由于 Followers Set 保存所有Follower完成去重， 导致OOM风险，同时也没有充分利用分布式。如果系统注册人员海量，Followers也会海量，必须增加PartialUniquerBatchBolt 的 并行度增加计算速度，降低OOM风险。

Bolt

GetTweetersBolt

package com.john.learn.storm.drpc.reach.bolt;

import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.storm.task.OutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.base.BaseRichBolt;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Tuple;
import org.apache.storm.tuple.Values;

import com.john.learn.storm.drpc.reach.TiwtterReachTopology;

public class GetTweetersBolt extends BaseRichBolt {

  /**
   * 
   */
  private static final long serialVersionUID = 1L;

  @Override
  public void prepare(Map stormConf, TopologyContext context, OutputCollector collector) {
     this.collector = collector;
  }

  @Override
  public void execute(Tuple input) {

     try {

       Object requestId = input.getValue(0);
       String url = input.getString(1);

       System.out.println("GetTweetersBolt URL:" + url);

       String urlId = getUrlId(url);

       System.out.println("GetTweetersBolt urlId:" + urlId);

       if (urlId == null) {

          return;
       }

       List<String> tweetters = TiwtterReachTopology.TWEETERS_DB.get(urlId);

       System.out.println("GetTweetersBolt tweetters:" + tweetters);

       if (tweetters == null) {

          return;
       }

       for (String teewtter : tweetters) {
          
          //发送消息必须携带 Tuple，用于异常处理
          collector.emit(input, new Values(requestId, teewtter));
       }

     } finally {
       //如果使用BaseRichBolt 必须手动提交Ack / Fail 
       //如果BaseBasicBolt，ack 自动调用的，这里必须注意，否则导致 Bolt 如果return 时， 
       //下一个Blot无法获取数据 
       collector.ack(input);
     }
  }

  private String getUrlId(String url) {

     for (Map.Entry<String, String> entry : TiwtterReachTopology.URLS_DB.entrySet()) {

       if (entry.getValue().equalsIgnoreCase(url)) {

          return entry.getKey();
       }
     }

     return null;
  }

  @Override
  public void declareOutputFields(OutputFieldsDeclarer declarer) {

     declarer.declare(new Fields("Id", "Tweetter"));
  }

  private OutputCollector collector;

}

注意：这里采用BaseRichBlot，必须手动调用ack或fail 方法，否则 当URL不存在时直接return （每个emit任何数据），导致Topology流程堵塞，无法启动下个Bolt-GetFollowersBolt任务处理，导致DRPC超时，务必小心使用BaseRichBlot

但如果我们使用BaseBasicBolt，不需要ack了，因为execute方法后，自动操作ack，这就是与BaseRichBlot最大区别。


GetFollowersBolt

package com.john.learn.storm.drpc.reach.bolt;

import java.util.List;
import java.util.Map;

import org.apache.storm.task.OutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.base.BaseRichBolt;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Tuple;
import org.apache.storm.tuple.Values;

import com.john.learn.storm.drpc.reach.TiwtterReachTopology;

public class GetFollowersBolt extends BaseRichBolt {

  /**
   * 
   */
  private static final long serialVersionUID = 1L;

  @Override
  public void prepare(Map stormConf, TopologyContext context, OutputCollector collector) {

     this.collector = collector;
  }

  @Override
  public void execute(Tuple input) {

     try {

       Long requestId = input.getLong(0);
       String tweeter = input.getString(1);

       List<String> followers = TiwtterReachTopology.FOLLOWERS_DB.get(tweeter);

       if (followers == null || followers.isEmpty()) {

          return;
       }
       
       for (String follower : followers) {
          
          //发送消息必须携带 Tuple，用于异常处理
          collector.emit(input, new Values(requestId, follower));
       }

     } finally {

       // 如果使用BaseRichBolt 必须手动提交Ack / Fail
       // 如果BaseBasicBolt，ack 自动调用的，这里必须注意，否则导致 Bolt 如果return 时，
       // 下一个Blot无法获取数据 ，同时 finishBatch 无法知道处理完毕
       collector.ack(input);
     }

  }

  @Override
  public void declareOutputFields(OutputFieldsDeclarer declarer) {

     declarer.declare(new Fields("Id", "Follower"));
  }

  private OutputCollector collector;
}

注意：这里采用BaseRichBlot，必须手动调用ack或fail 方法，否则PartialUniquerBatchBolt 无法知道Id已经处理完毕，导致无法调用finishBatch。

PartialUniquerBatchBolt

package com.john.learn.storm.drpc.reach.bolt;

import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.apache.storm.coordination.BatchOutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.BasicOutputCollector;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.base.BaseBasicBolt;
import org.apache.storm.topology.base.BaseBatchBolt;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Tuple;
import org.apache.storm.tuple.Values;

public class PartialUniquerBatchBolt extends BaseBatchBolt<Object> {

  private static final long serialVersionUID = 1L;

  @Override
  public void prepare(Map conf, TopologyContext context, BatchOutputCollector collector, Object id) {
     this.requestId = id;
     this.collector = collector;

  }

  @Override
  public void execute(Tuple tuple) {

     String follower = tuple.getString(1);
     // 已经完成统计记录，不需统计了
     if (followers.contains(follower)) {
       return;
     }
     followers.add(tuple.getString(1));
  }

  @Override
  public void finishBatch() {

     collector.emit(new Values(requestId, followers.size()));

  }

  @Override
  public void declareOutputFields(OutputFieldsDeclarer declarer) {

     declarer.declare(new Fields("Id", "FollowerCount"));
  }

  private BatchOutputCollector collector;

  // 保存Reach URL的到达者，避免重复
  private Set<String> followers = new HashSet<>();

  private Object requestId;

}

CountAggregatorBatchBlot

package com.john.learn.storm.drpc.reach.bolt;

import java.util.Map;

import org.apache.storm.coordination.BatchOutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.base.BaseBatchBolt;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Tuple;
import org.apache.storm.tuple.Values;

public class CountAggregatorBatchBlot extends BaseBatchBolt<Object> {

  /**
   * 
   */
  private static final long serialVersionUID = 1L;

  @Override
  public void prepare(Map conf, TopologyContext context, BatchOutputCollector collector, Object id) {
     this.requestId = id;
     this.collector = collector;
  }

  @Override
  public void execute(Tuple tuple) {

     reachCount += tuple.getInteger(1);
  }

  @Override
  public void finishBatch() {

     collector.emit(new Values(this.requestId, this.reachCount));
  }

  @Override
  public void declareOutputFields(OutputFieldsDeclarer declarer) {

     declarer.declare(new Fields("Id", "ReachCount"));
  }

  private Object requestId;

  private BatchOutputCollector collector;

  private int reachCount;

}

运行结果：

public static void main(String[] args) {

		TiwtterReachTopology tiwtterReachTopology = new TiwtterReachTopology("TiwtterReach");

		if (args == null || args.length == 0) {

			LocalDRPC localDRPC = tiwtterReachTopology.submitLocal();

			System.out.println("Please input a free flag to start reach function");

			for (String id : URLS_DB.keySet()) {
				System.out.println("The URL " + URLS_DB.get(id) + "Reach Count :"
						+ localDRPC.execute("TiwtterReach", URLS_DB.get(id)));
			}

			System.exit(1);

			return;
		}

		tiwtterReachTopology.submitRemote();

	}

netcobol
关注
专栏目录
Storm的DRPC
Zonzereal的博客
01-14 3206
Storm drpc  1.DRPC介绍 Storm是一个分布式实时处理框架,它支持以DRPC方式调用.可以理解为Storm是一个集群,DRPC提供了集群中处理功能的访问接口.其实即使不通过DRPC，而是通过在Topoloye中的spout中建立一个TCP/HTTP监听来接收数据，在最后一个Bolt中将数据发送到指定位置也是可以的。而DPRC则是Storm提供的一套开发组建，使用DRPC可以极
Storm 实战入门
robinjun的专栏
09-28 2525
Storm 入门 (wuchangjun) 摘要     互联网从诞生的第一时间起，对世界的最大的改变就是让信息能够实时交互，从而大大加速了各个环节的效率。正因为大家对信息实时响应、实时交互的需求，软件行业除了个人操作系统之外，数据库（更精确的说是关系型数据库）应该是软件行业发展最快、收益最为丰厚的产品了。记得十年前，很多银行别说实时转 账，连实时查询都做不到，但是数据库和高速网络改变了
Storm DRPC 介绍（1）
笔尖的痕的专栏
10-09 1034
1. DRPC介绍 1.Storm是一个分布式实时处理框架,它支持以DRPC方式调用.可以理解为Storm是一个集群,DRPC提供了集群中处理功能的访问接口. 其实即使不通过DRPC，而是通过在Topoloye中的spout中建立一个TCP/HTTP监听来接收数据，在最后一个Bolt中将数据发送到指定位置也是可以的。这是后话，后面再进行介绍。而DPRC则是Storm提供的一套开发组建，使用
DRPC：轻量级gRPC替代方案
最新发布
gitblog_00042的博客
08-10 410
DRPC：轻量级gRPC替代方案 drpcdrpc is a lightweight, drop-in replacement for gRPC项目地址:https://gitcode.com/gh_mirrors/dr/drpc 项目介绍 DRPC，即Drop-in, lightweight gRPC replacement，是一个轻量级的gRPC替代方案。它旨在提供与gRPC相同的功能，但更...
Storm-Starter分析————ReachTopology
徐玄清的专栏
04-05 945
模型较为简单： 线性结构：GetTweeters—————GetFollowers————PartialUniquer—————CountAggregator 以上全部为bolt节点，最开始由drpc.execute("reach", url)发起 此处有疑问1： 两处fieldsGrouping中的new Fields中不管是仅写“id”还是如图红圈部分一样写上上一个declar
Storm-drpc
dark
09-25 460
Getting Started with Storm storm实战构建大数据实时计算 DRPC拓扑 分布式远程过程调用（DRPC），它利用Storm的分布式特性执行远程过程调用（RPC）。对每一次函数调用，Storm集群上运行的拓扑接收调用方法名称和参数作为输入流，经过一系列的计算，最终将计算结果作为输出流返回发射出去。 LinearDRPCTopologyBuilder LinearDR...
storm之drpc操作demo示例.zip
12-28
总结来说，"storm之drpc操作demo示例"是一个很好的学习资源，它涵盖了Storm DRPC的核心概念和实践操作，对于想要在实时计算项目中运用Storm DRPC功能的开发者来说，极具参考价值。通过实际操作这个示例，你将能够...
storm DRPC简单例程
06-18
"storm DRPC简单例程" 指的是使用Apache Storm分布式实时计算系统中的DRPC（Distributed Remote Procedure Calls）功能的一个基础示例。DRPC允许用户在Storm集群上执行分布式远程过程调用，使得在分布式环境中进行高...
Storm流计算项目：1号店电商实时数据分析系统-30.项目2-省份销售排行-Top N展示优化和项目开发思路总结.pptx
11-25
在该项目的第二个阶段，即【项目2-省份销售排行】，主要任务是实现省份销售额的Top N展示，并对整个项目的开发思路进行总结。 1. **Top N展示优化**： - 在这个阶段，重点是优化Top N（例如Top 5）省份的销售数据...
大数据技术之_17_Storm学习_Storm 概述+Storm 基础知识+Storm 集群搭建+Storm 常用 API+Storm 分组策略和并发度
黑泽君
04-13 1004
大数据技术之_17_Storm学习_Storm 概述+Storm 基础知识+Storm 集群搭建+Storm 常用 API+Storm 分组策略和并发度
Storm的drpc应用
05-16
这是storm中drpc应用的一个例子。
Storm: DRPC
术业有专攻
03-17 157
                       https://storm.apache.org/documentation/Distributed-RPC.html https://github.com/mithunsatheesh/php-drpc http://php.sabscape.com/blog/?p=482
Storm 分布式远程过程调用(DRPC)
人不风流枉少年
03-09 498
一：服务器端 1. 在Nimbus主节点中配置drpc.servers conf/storm.yaml drpc.servers: - "127.0.0.1" 2.启动drpc服务 ./bin/storm drpc & 3. storm-drpc-server 3.1 pom.xml <dependencies> <dependency> &l...
【六】storm的DRPC
Sid小杰的博客
06-12 390
一、RPC1.概述        远程过程调用协议，Remote Procedure Call。序列化的速度会 影响RPC的性能。常用的序列化：avro、thrift(hive、spark有用到这个)2.基于hadoop的RPC实现代码演示3.stormDRPC（分布式RPC）概述官网DRPC介绍充分利用storm的计算能力实现高密度的计算。storm的topology接收函数参数作为输入，调用函...
storm DRPC指南
jediael_lu的专栏
08-02 1787
storm DRPC指南@(STORM)[storm]storm DRPC指南 一什么是DRPC 二LocalDPRC的例子 三RemoteDRPC将DPRC拓扑提交至集群 1启动DRPC服务器 2准备storm拓扑代码并提交 3使用客户端发起请求 使用DRPC访问hbase有问题因为storm集群上的hbase jar包还是098的有些类找不到先解决这个 （一）什么是DRPC先看一个经典的图：
6.Storm-DRPC
Willson_L的博客
11-02 372
6.1 DRPC 介绍 分布式RPC（Distributed RPC，DRPC） Storm 里面引入 DRPC 主要是利用 storm 的实时计算能力来并行优化 cpu 密集型的计算任务。DRPC 的 storm Topology 以函数的参数流作为输入，而把这些函数调用的返回值作为 Topology 的输出流。 DRPC 其实不能算是 storm 本身的一个特性，他是通过组合 storm...
Storm DRPC【分布式RPC】概述
不清不慎的博客
09-07 1064
一、什么是RPC？ RPC（Remote Procedure Call）—远程过程调用，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。 RPC采用客户机/服务器模式。请求程序...
storm 的一个drpc例子(值得一看)
每天积累一点，一年后你会发现，自己变化很大
01-17 929
2012-11-26 18:461465人阅读评论(0)收藏举报 [java] view plaincopyprint? public static void initConnectDB(){          primaryKey = "id";          rdbmsUrl = "jdbc:mysql://hadoop/DB" ;          rdb
Storm大数据入门指南：从基础到实战
"Getting Started with Storm中文版是一本由韩飞翻译的指南，旨在帮助读者入门Apache Storm，一个强大的分布式实时计算系统。该书适合对大数据处理和实时流处理有兴趣的学习者，特别关注于如何在Storm中构建和管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值