两个例子(来自Storm实战 构建大数据实时计算)

最新推荐文章于 2022-09-07 11:24:52 发布
最新推荐文章于 2022-09-07 11:24:52 发布
阅读量5.1k 收藏 4
点赞数 2
分类专栏： storm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wust__wangfan/article/details/50517554
版权

例子一：模拟网站计算用户PV(页面浏览量)

        拓扑图如下：

            

1、编写Topology

public class TopoMain {

	public static void main(String[] args) throws AlreadyAliveException, InvalidTopologyException {
		TopologyBuilder builder=new TopologyBuilder();
		
		builder.setSpout("log-reader", new LogReader(),1);
		
		builder.setBolt("log-stat", new LogStat(), 2).fieldsGrouping("log-reader",new Fields("user"));
	   
		builder.setBolt("log-writer", new LogWriter(),1).shuffleGrouping("log-stat");
	    
	    Config config=new Config();
	    config.setNumWorkers(5);
	    StormSubmitter.submitTopology("log-topology", config, builder.createTopology());
	}

}

2、编写spout 

public class LogReader extends BaseRichSpout{

	private SpoutOutputCollector _collector;
	private Random _rand=new Random();
	private int _count=100;
	private String[] _users={"userA","userB","userC","userD","userE"};
	private String[] _urls={"url1","url2","url3","url4","url5"};
	
	@Override
	public void open(Map conf, TopologyContext context,
			SpoutOutputCollector collector) {
		_collector=collector;
	}

	@Override
	public void nextTuple() {
		try {
			Thread.sleep(1000);
			while(_count-->=0)
			{
				_collector.emit(new Values(System.currentTimeMillis(),_users[_rand.nextInt(5)],_urls[_rand.nextInt(5)]));
			}
			
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
	
		declarer.declare(new Fields("time","user","url"));
	}

}


3、编写bolt
 
public class LogStat extends BaseRichBolt{

	private OutputCollector _collector;//注意和SpoutOutputCollector区分
	private Map<String, Integer>_pvMap=new HashMap<String,Integer>();
	
	@Override
	public void prepare(Map stormConf, TopologyContext context,
			OutputCollector collector) {
		_collector=collector;
	}

	@Override
	public void execute(Tuple input) {
		
		String user=input.getStringByField("user");
		
		if(_pvMap.containsKey(user))
		{
			_pvMap.put(user, _pvMap.get(user)+1);
		}
		else {
			_pvMap.put(user, 1);
		}
		//把每个用户的最新PV输出到下一节点
		_collector.emit(new Values(user,_pvMap.get(user)));
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		declarer.declare(new Fields("user","pv"));
	}

}


public class LogWriter extends BaseRichBolt{

	private FileWriter writer=null;
	@Override
	public void prepare(Map stormConf, TopologyContext context,
			OutputCollector collector) {
		// TODO 自动生成的方法存根
		try {
			writer=new FileWriter("/"+this);
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}

	@Override
	public void execute(Tuple input) {
		try {
			writer.write(input.getStringByField("user")+" : "+input.getIntegerByField("pv"));
			writer.write("\n");
			writer.flush();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
	}
}
对结果分析：

        结果会输出最新的PV，如userA: 1, userB:1, userA:2, userA:3.................



例子二、改进上面的例子,让最终结果每个用户只输出一次页面访问量

       
1、topology

       

public class TopoMain {

	public static void main(String[] args) throws AlreadyAliveException, InvalidTopologyException {
		TopologyBuilder builder=new TopologyBuilder();
		
		builder.setSpout("log-reader", new LogReader(),1);
		
		//流log负责输出日志，采用字段分组；流stop告诉下游输出完毕，全局广播这个tuple
		builder.setBolt("log-stat", new LogStat(), 2).fieldsGrouping("log-reader", "log", new Fields("user")).allGrouping("log-reader", "stop");
	    
		builder.setBolt("log-writer", new LogWriter(),1).shuffleGrouping("log-stat");
	    
	    Config config=new Config();
	    config.setNumWorkers(5);
	    StormSubmitter.submitTopology("log-topology", config, builder.createTopology());
	}
}

2、spout 

public class LogReader extends BaseRichSpout{

	private SpoutOutputCollector _collector;
	private Random _rand=new Random();
	private int _count=100;
	private String[] _users={"userA","userB","userC","userD","userE"};
	private String[] _urls={"url1","url2","url3","url4","url5"};
	
	@Override
	public void open(Map conf, TopologyContext context,
			SpoutOutputCollector collector) {
		_collector=collector;
	}

	@Override
	public void nextTuple() {
		try {
			Thread.sleep(1000);
			while(_count-->=0)
			{
				if(_count==0)
				{
					//发送""发给下流bolt
					_collector.emit("stop", new Values(""));
				}
				_collector.emit("log",new Values(System.currentTimeMillis(),_users[_rand.nextInt(5)],_urls[_rand.nextInt(5)]));
			}
			
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}
	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		declarer.declareStream("log",new Fields("time","user","url"));
		declarer.declareStream("stop", new Fields("flag"));
	}

}

3、bolt 

public class LogStat extends BaseRichBolt{

	private OutputCollector _collector;//注意和SpoutOutputCollector区分
	private Map<String, Integer>_pvMap=new HashMap<String,Integer>();
	
	@Override
	public void prepare(Map stormConf, TopologyContext context,
			OutputCollector collector) {
		_collector=collector;
	}

	@Override
	public void execute(Tuple input) {
		String streamId=input.getSourceStreamId();
		if(streamId.equals("log"))
		{
			String user=input.getStringByField("user");
			if(_pvMap.containsKey(user))
			{
				_pvMap.put(user, _pvMap.get(user)+1);
			}
			else {
				_pvMap.put(user, 1);
			}
		}
		if(streamId.equals("stop"))
		{
			//从map取数据发送
			Iterator<Entry<String,Integer>> it=_pvMap.entrySet().iterator();
			
			while(it.hasNext())
			{
				Entry<String,Integer> entry=it.next();
				_collector.emit(new Values(entry.getKey(),entry.getValue()));
			}
		}
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		declarer.declare(new Fields("user","pv"));
	}

}
public class LogWriter extends BaseRichBolt{

	private FileWriter writer=null;
	@Override
	public void prepare(Map stormConf, TopologyContext context,
			OutputCollector collector) {
		// TODO 自动生成的方法存根
		try {
			writer=new FileWriter("/"+this);
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}

	@Override
	public void execute(Tuple input) {
		try {
			writer.write(input.getStringByField("user")+" : "+input.getIntegerByField("pv"));
			writer.write("\n");
			writer.flush();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
	}
}

例三、模拟一个简化的电子商务网站来实时计算来源成交效果



1、topology

public class TopoMain {

	public static void main(String[] args) throws AlreadyAliveException, InvalidTopologyException {
		TopologyBuilder builder=new TopologyBuilder();
		
		builder.setSpout("log-vspout", new VSpout(),1);
		builder.setSpout("log-bspout", new BSpout(),1);
		
		//定义两个流名称，分别为visit和business
		builder.setBolt("log-merge", new LogMergeBolt(),2).fieldsGrouping("log-vspout",
				"visit",new Fields("user")).fieldsGrouping("log-bspout","business",new 
						Fields("user"));
		
		builder.setBolt("log-stat", new LogStatBolt(),2).fieldsGrouping("log-merge",new
				Fields("srcid"));
		
		builder.setBolt("log-writer", new LogWriter()).globalGrouping("log-stat");
		
		Config conf=new Config();
		
		//实时计算不需要可靠消息，故关闭acker节省通信资源
		conf.setNumAckers(0);
		//设置独立java进程数，一般设置为同spout和bolt的总tasks数量相等或更多，使得每个task
		//都运行在独立的Java进程中，以避免多个task集中在一个jvm里运行产
		//生GC(垃圾回收机制)瓶颈
		conf.setNumWorkers(8);
		StormSubmitter.submitTopology("ElectronicCom_Top", conf, builder.createTopology());
	}

}

2、spout 

public class BSpout extends BaseRichSpout{

	private SpoutOutputCollector _collector;
	private String[] _users={"userA","userB","userC","userD","userE"};
	private String[] _pays={"100","200","300","400","200"};
	private int count=5;
	@Override
	public void open(Map conf, TopologyContext context,
			SpoutOutputCollector collector) {
		_collector=collector;
	}

	@Override
	public void nextTuple() {
		for(int i=0;i<count;i++)
		{
			try {
				Thread.sleep(1500);//停顿时间长一些，使得流量日志先于成交日志到达下游的LogMergeBolt组件
				_collector.emit("business", new Values(System.currentTimeMillis(),_users[i],_pays[i]));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
		}
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		declarer.declareStream("business", new Fields("time","user","pay"));
	}
	
}

 
public class VSpout extends BaseRichSpout{

	private SpoutOutputCollector _collector;
	private String[] _users={"userA","userB","userC","userD","userE"};
	private String[] _srcid={"s1","s2","s3","s1","s1"};
	private int count=5;
	@Override
	public void open(Map conf, TopologyContext context,
			SpoutOutputCollector collector) {
		_collector=collector;
	}

	@Override
	public void nextTuple() {
		for(int i=0;i<count;i++)
		{
			try {
				Thread.sleep(1000);
				_collector.emit("visit", new Values(System.currentTimeMillis(),_users[i],_srcid[i]));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
		}
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		declarer.declareStream("visit", new Fields("time","user","srcid"));
	}
	
}

3、bolt 

public class LogMergeBolt extends BaseRichBolt{

	private  OutputCollector _collector;
	//暂时存储用户的访问日志记录
	private HashMap<String, String> srcMap;
	@Override
	public void prepare(Map stormConf, TopologyContext context,
			OutputCollector collector) {
		_collector=collector;
		if(srcMap==null)
		{
			srcMap=new HashMap<String, String>();
		}
	}

	@Override
	public void execute(Tuple input) {
		String streamID=input.getSourceStreamId();
		if(streamID.equals("visit"))
		{
			String user=input.getStringByField("user");
			String srcid=input.getStringByField("srcid");
			srcMap.put(user, srcid);
		}
		if(streamID.equals("business"))
		{
			String user=input.getStringByField("user");
			String pay=input.getStringByField("pay");
			String srcid=srcMap.get(user);
			
			if(srcid!=null)
			{
				_collector.emit(new Values(user,pay,srcid));
				srcMap.remove(user);
			}
			else {
				//一般只有成交日志先于流量日志才会发生
			}
		}
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		declarer.declare(new Fields("user","srcid","pay"));
	}

}

 
public class LogStatBolt extends BaseRichBolt{

	private  OutputCollector _collector;
	private HashMap<String, Long> srcpay;
	
	@Override
	public void prepare(Map stormConf, TopologyContext context,
			OutputCollector collector) {
		_collector=collector;
		if(srcpay==null)
		{
			srcpay=new HashMap<String, Long>();
		}
	}

	@Override
	public void execute(Tuple input) {
		String pay=input.getStringByField("pay");
		String srcid=input.getStringByField("srcid");
		
		if(srcpay.containsKey(srcid))
		{
			srcpay.put(srcid, srcpay.get(srcid)+Long.parseLong(pay.trim()));
		}
		else {
			srcpay.put(srcid, Long.parseLong(pay.trim()));
		}
		_collector.emit(new Values(srcid,srcpay.get(srcid)));
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		declarer.declare(new Fields("srcid","pay"));
	}
}
public class LogWriter extends BaseRichBolt{
	private HashMap<String, Long> counts=null;
	
	private FileWriter writer=null;
	@Override
	public void prepare(Map stormConf, TopologyContext context,
			OutputCollector collector) {
		// TODO 自动生成的方法存根
		this.counts=new HashMap<String, Long>();
		try {
			writer=new FileWriter("/"+this);
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}

	@Override
	public void execute(Tuple input) {
		// TODO 自动生成的方法存根
		String srcid=input.getStringByField("srcid");
		Long pay=input.getLongByField("pay");
		counts.put(srcid, pay);
	}
	
	@Override
	public void declareOutputFields(OutputFieldsDeclarer declarer) {
		// TODO 自动生成的方法存根
		
	}
	@Override
	public void cleanup() {
		// TODO 自动生成的方法存根
		Iterator<Entry<String,Long>> it=counts.entrySet().iterator();
		
		while(it.hasNext())
		{
			Entry<String,Long> entry=it.next();
			try {
				writer.write(entry.getKey()+" : "+entry.getValue());
				writer.write("\n");
				writer.flush();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

}

fan_rockrock
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Storm调优(optimiaze)
07-03 4073
在充分了解节点计算机硬件资源的情况下进行Storm运行性能的调优。 Storm运行性能调优主要是从以下几个方面： (1)代码层面，这得看程序编写者的功力了。 (2)并行度层面，分为： setNumWorkers取值； kafkaSpout取值（假设是从Kafka中读取数据）； Bolt取值； shuffleGrouping和fieldsGrouping的选择等。 1. se
java strom实例_storm 入门教程+简单实例
weixin_39527163的博客
03-04 727
写在前面:本篇博客主要介绍 storm 基本概念和一个简单实例,storm版本1.0.2storm基本概念storm的集群架构storm 是一个主从架构,一个主节点,n个从节点,主节点和从节点之间通过zk集群来进行交互, (这张图是盗的......)简述一下集群搭建:1,解压并且修改 storm.yaml,并且scp到其他节点机器上2,在主节点启动 nimbus服务,ui界面服务和logviewe...
Storm之——Storm2.0.0配置详解
冰河的专栏
08-10 4186
转载请注明出处：https://blog.csdn.net/l1028386804/article/details/99126674 Storm2.0.0中defaults.yaml文件的配置如下（链接为：https://github.com/apache/storm/blob/v2.0.0/conf/defaults.yaml）： # Licensed to the Apache Soft...
Storm1.1.0<控制台输出指定Log信息>
Gpwner的博客
07-03 3125
写storm的时候，有的时候控制台会输出很多很多的“INFO”信息，造成自己写的System.out.println之类的信息会被冲刷掉，做接下来的配置能够有效地输出指定Log信息。参考：https://logging.apache.org/log4j/2.x/manual/configuration.html在classpath下新建一个log4j2.xml文件，里面填充一下内容：<?xml ve
记录日志的工具类LogWriter
javaACMer的专栏
09-10 4058
一个工具类 用来记录日志的： class LogWriter { // 可以写作配置：true写文件; false输出控制台 private static boolean fileLog = true; private static String logFileName = "/home/yzx/yzx/elong/sysout.log"; public static
storm杂记+性能调优
weixin_30593443的博客
07-07 499
1、默认情况下： 1个supervisor节点启动4个worker进程。 每一个topology默认占用一个worker进程。 每个worker会启动executor。 每个executor默认启动一个task。 2、并行度 什么是并行度？在 Storm 的设定里，并行度大体分为3个方面： 一个 topology 指定多少个 worker 进程并行运行； 一个 wo...
Storm实战构建大数据实时计算
03-29
Storm官方网站有段简介 ...Storm是一个免费并开源的分布式实时计算系统。利用Storm可以很容易做到可靠地处理无限的数据流，像Hadoop批量处理大数据一样，Storm可以实时处理数据。Storm简单，可以使用任何编程语言。
Storm 实战：构建大数据实时计算完整版
05-19
《Storm实战：构建大数据实时计算 》是一本系统并且具有实践指导意义的Storm工具书和参考书，对Storm整个技术体系进行了全面的讲解，不仅包括对基本概念、特性的介绍，也涵盖了一些原理说明。 实战性很强，各章节都...
《Storm实战构建大数据实时计算》PDF
09-01
《Storm实战构建大数据实时计算》是一本专注于大数据领域实时处理技术的专著，主要围绕Apache Storm这一开源流处理系统展开。这本书深入浅出地讲解了如何利用Storm进行实时数据流的处理，为读者揭示了大数据实时计算...
storm一个简单实例
06-26
storm的第一个简单的实例，适合初学storm的人理解和学习，已经在storm集群中跑通。注释是自己写的方便理解
storm+kafka源码示例
04-15
压缩包里有一个topology类的文件，主要是kafkaspout类的配置和调用方法，另包含需要的kafkaspouot的jar包。
Storm的WordCount实例
03-19
Storm的WordCount实例。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
实时计算框架之二：Storm之入门实例
风马牛
03-04 5779
预备、开火、瞄准…… 1 总结与提升 自1月份来，可谓是浮浮荡荡，一波三折呀。 先是参加了公司组织的创意马拉松大赛，虽说24小时内完成了作品，但是自己感觉上效果很差，自然成绩也是不高。通过这24小时持续的奋斗以及后来的各种产品描述等环节，发现了开发上的许多缺点。首先，对我们的产品进行了深入的认识和了解，也在产品之上，发现了更多可以发展走向成功的点子，这是我觉得最棒的一点；其次，短时间
页面访问量统计实例
Java 之 道
09-01 6962
import java.io.IOException; import java.io.PrintWriter; import javax.servlet.ServletContext; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import ja
Storm：最火的流式处理框架
weixin_33697898的博客
02-18 277
伴随着信息科技日新月异的发展，信息呈现出爆发式的膨胀，人们获取信息的途径也更加多样、更加便捷，同时对于信息的时效性要求也越来越高。举个搜索场景中的例子，当一个卖家发布了一条宝贝信息时，他希望的当然是这个宝贝马上就可以被卖家搜索出来、点击、购买啦，相反，如果这个宝贝要等到第二天或者更久才可以被搜出来，估计这个大哥就要骂娘了。再举一个推荐的例子，如果用户昨天在淘宝上买了一双袜子，今天想买一副泳镜去游泳...
Storm实战
weixin_33918357的博客
03-24 106
需求： spout输出一些手机品牌小写名称，第一个bolt将手机名称转成大写，第二个bolt在手机名称的后面再追加上时间。 项目目录： 导入相关的jar包。 RandomWordSpout.java： package com.darrenchan.storm; import java.util.Map; import java.util.Random; import...
浅谈实时计算
最新发布
阿甘兄
09-07 3091
浅谈实时计算，概念、Flink技术以及常见的解决方案参考。
strom-1.1.0模拟单词统计功能，Spout编写，Bolt编写，TopologyDriver编写，本地模式运行，集群模式运行，集群模式下看输出结果
涂作权的博客
06-20 773
统计文本中的单词出现的频率，其中文本内容如下： 创建项目项目结构如下： 创建pom.xml，代码如下：<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-insta
Storm入门：大数据实时分析指南
"Storm入门.pdf 是一本介绍大数据实时分析工具Storm的入门教程..."Storm入门.pdf" 是一个适合初学者的详细指南，涵盖了从基础知识到实战技巧的全面内容，对于想要进入实时大数据处理领域的开发者来说是一份宝贵的资源。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值