Storm 从入门到精通 第六讲 Storm 示例 之 第一个简单实例

最新推荐文章于 2022-07-18 15:44:46 发布
原创 最新推荐文章于 2022-07-18 15:44:46 发布 · 1.3k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Storm

本文介绍了一个基于Apache Storm的简单流处理实例，通过Spout组件发送流行编程语言名称，随后使用Bolt组件进行打印和文件记录操作。该示例涵盖了Topology构建、Spout与Bolt的实现、Stream Grouping配置等内容。

1. 第一个简单例子： Spout 将随机发送目前流行的编程语言， Console 输出 及 使用 File 保存出现的语言日志。



2. Topology 流程图


3. 程序结构



4. 程序示例

1. PrintWriterSpout： fieldsDeclarer.declare(new Fields("PrintWord"));

package com.john.learn.storm.ch01.spout;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import org.apache.storm.spout.SpoutOutputCollector;
import org.apache.storm.task.TopologyContext;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.base.BaseRichSpout;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Values;
public class PrintWriterSpout extends BaseRichSpout {
    private static final long serialVersionUID = 1L;
    @Override
    public void open(Map config, TopologyContext context, SpoutOutputCollector collector) {
         this.spoutOutputCollector = collector;
    }
    @Override
    public void nextTuple() {
         if (!init) {
             init = true;
             try {
                 Thread.sleep(5000);
             } catch (InterruptedException e) {
             }
         }
         String selectWord = PrintWords[RANDOM.nextInt(PrintWords.length)];
         // 发射一个Word数值
         this.spoutOutputCollector.emit(new Values(selectWord));
    }
    @Override
    public void declareOutputFields(OutputFieldsDeclarer fieldsDeclarer) {
         // 定义emit values中数值名称，即字段名称，这里叫做PrintWord
         // 用于下一个组件获取数值通过Field Name 类似于 HttpRequest getParameter(String name)
         // Refer to PrintBolt 中tuple.getStringByField("PrintWord")
         fieldsDeclarer.declare(new Fields("PrintWord"));
    }
    private SpoutOutputCollector spoutOutputCollector;
    private static final String[] PrintWords = new String[10];
    private static final Random RANDOM = new Random(System.currentTimeMillis());
    private static boolean init = false;
    static {
         PrintWords[0] = "Java";
         PrintWords[1] = "C";
         PrintWords[2] = "Php";
         PrintWords[3] = "VB";
         PrintWords[4] = "Python";
         PrintWords[5] = "Scala";
         PrintWords[6] = "Groovy";
         PrintWords[7] = "Go";
         PrintWords[8] = "Javascript";
         PrintWords[9] = "Clojure";
    }
}
 

2. PrintBolt：  outputFieldsDeclarer.declare(new Fields("WriteWord"));

package com.john.learn.storm.ch01.bolt;

import org.apache.storm.shade.org.eclipse.jetty.util.log.Log;
import org.apache.storm.topology.BasicOutputCollector;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.base.BaseBasicBolt;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Tuple;
import org.apache.storm.tuple.Values;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PrintBolt extends BaseBasicBolt {

	private static final long serialVersionUID = 1L;

	@Override
	public void execute(Tuple tuple, BasicOutputCollector basicOutputCollector) {

		String printWord = tuple.getStringByField("PrintWord");

		Logger.info("【Print】 " + printWord);

		// 传递给下一个Bolt
		basicOutputCollector.emit(new Values(printWord));

	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer) {

		outputFieldsDeclarer.declare(new Fields("WriteWord"));

	}

	private static final Logger Logger = LoggerFactory.getLogger(PrintBolt.class);

}

3. WriterBolt

package com.john.learn.storm.ch01.bolt;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

import org.apache.storm.shade.org.eclipse.jetty.util.log.Log;
import org.apache.storm.topology.BasicOutputCollector;
import org.apache.storm.topology.OutputFieldsDeclarer;
import org.apache.storm.topology.base.BaseBasicBolt;
import org.apache.storm.tuple.Fields;
import org.apache.storm.tuple.Tuple;
import org.apache.storm.tuple.Values;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class WriterBolt extends BaseBasicBolt {

	private static final long serialVersionUID = 1L;

	@Override
	public void execute(Tuple tuple, BasicOutputCollector basicOutputCollector) {

		try {
			
			String writeWord = tuple.getStringByField("WriteWord");

			if (writer == null) {
				
				File file = getFile();
				
				file.getParentFile().mkdirs();

				writer = new FileWriter(file, false);
			}
			
			Logger.info("【Write 】 " + writeWord);
			
			writer.write(writeWord);
			writer.write("\n");
			writer.flush();

		} catch (IOException e) {

		}

	}

	private File getFile() {

		if (System.getProperty("os.name").toLowerCase().contains("windows")) {

			return new File("C:/Storm/WriterBolt/" + this);
		}

		return new File("/user/local/temp/" + this);
	}

	@Override
	public void declareOutputFields(OutputFieldsDeclarer outputFieldsDeclarer) {

	}

	private static final Logger Logger = LoggerFactory.getLogger(WriterBolt.class);

	private Writer writer;

}

4. BoltGroupType

package com.john.learn.storm.ch01.topology;

public enum BoltGroupType {

  FieldsGrouping, ShuffleGrouping, AllGrouping,GlobalGrouping;
}

5. PrintWriterTopology 

package com.john.learn.storm.ch01.topology;

import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.StormSubmitter;
import org.apache.storm.generated.AlreadyAliveException;
import org.apache.storm.generated.AuthorizationException;
import org.apache.storm.generated.InvalidTopologyException;
import org.apache.storm.topology.BoltDeclarer;
import org.apache.storm.topology.TopologyBuilder;
import org.apache.storm.tuple.Fields;

import com.john.learn.storm.ch01.bolt.PrintBolt;
import com.john.learn.storm.ch01.bolt.WriterBolt;
import com.john.learn.storm.ch01.spout.PrintWriterSpout;

public class PrintWriterTopology {

	public static class PrintWriterTopologyBuilder {

		public PrintWriterTopologyBuilder(String topologyName) {

			printWriterTopology = new PrintWriterTopology(topologyName);
		}

		public void setNumWorkers(int numWorkers) {

			printWriterTopology.setNumWorkers(numWorkers);
		}

		public void setDebug(boolean debug) {

			printWriterTopology.setDebug(debug);
		}

		public void setSpout(int parallelismSize) {
			hasSpout = true;
			printWriterTopology.setSpout(parallelismSize, parallelismSize * 1);
		}

		public void setPrintBolt(int parallelismSize, int numTasks) {
			hasPrintBolt = true;
			printWriterTopology.setPrintBolt(parallelismSize, numTasks);
		}

		public void setWriterBolt(int parallelismSize, int numTasks, BoltGroupType boltGroupType) {
			this.hasWriterBolt = true;
			printWriterTopology.setWriterBolt(parallelismSize, numTasks, boltGroupType);

		}

		protected void setWriterBolt(int parallelismSize, int numTasks) {

			setWriterBolt(parallelismSize, numTasks, BoltGroupType.ShuffleGrouping);
		}

		public PrintWriterTopology createTopology() {

			if (!this.hasSpout) {
				throw new RuntimeException("Please set spout!");
			}

			if (!this.hasPrintBolt) {
				throw new RuntimeException("Please set hasPrintBolt!");
			}

			if (!this.hasWriterBolt) {
				throw new RuntimeException("Please set hasWriterBolt!");
			}

			return printWriterTopology;
		}

		private PrintWriterTopology printWriterTopology;

		private boolean hasSpout = false;

		private boolean hasPrintBolt = false;

		private boolean hasWriterBolt = false;

	}

	protected PrintWriterTopology(String topologyName) {

		this.topologyName = topologyName;
	}

	protected void setNumWorkers(int numOfWorker) {

		this.config.setNumWorkers(numOfWorker);
	}

	protected void setDebug(boolean debug) {

		config.setDebug(debug);
	}

	protected void setSpout(int parallelismSize, int numTasks) {

		topologyBuilder.setSpout("PrintWriterSpout", new PrintWriterSpout(), parallelismSize).setNumTasks(numTasks);
	}

	protected void setPrintBolt(int parallelismSize, int numTasks) {

		topologyBuilder.setBolt("PrintBolt", new PrintBolt(), parallelismSize).setNumTasks(numTasks)
				.shuffleGrouping("PrintWriterSpout");
	}

	protected void setWriterBolt(int parallelismSize, int numTasks, BoltGroupType boltGroupType) {

		BoltDeclarer boltDeclarer = topologyBuilder.setBolt("WriterBolt", new WriterBolt(), parallelismSize)
				.setNumTasks(numTasks);

		if (boltGroupType == BoltGroupType.FieldsGrouping) {

			boltDeclarer.fieldsGrouping("PrintBolt", new Fields("WriteWord"));

			return;
		}

		if (boltGroupType == BoltGroupType.AllGrouping) {

			boltDeclarer.allGrouping("PrintBolt");

			return;
		}

		if (boltGroupType == BoltGroupType.GlobalGrouping) {

			boltDeclarer.globalGrouping("PrintBolt");

			return;
		}

		boltDeclarer.shuffleGrouping("PrintBolt");
	}

	public void submitTopology() {
		try {
			StormSubmitter.submitTopology(topologyName, config, topologyBuilder.createTopology());
		} catch (AlreadyAliveException | InvalidTopologyException | AuthorizationException e) {

			e.printStackTrace();
		}
	}

	public void submitTopologyOnLocal() {

		localCluster = new LocalCluster();
		localCluster.submitTopology(topologyName, config, topologyBuilder.createTopology());
	}

	public void killTopology() {

		localCluster.killTopology(topologyName);
		localCluster.shutdown();
	}

	private Config config = new Config();

	private TopologyBuilder topologyBuilder = new TopologyBuilder();

	private LocalCluster localCluster;

	private String topologyName;
}

6. PrintWriterToplogyOnSimpleConfig

package com.john.learn.storm.ch01.topology;


import com.john.learn.storm.ch01.topology.PrintWriterTopology.PrintWriterTopologyBuilder;


public class PrintWriterToplogyOnSimpleConfig {


	public static void main(String[] args) throws InterruptedException {


		PrintWriterTopologyBuilder printWriterTopologyBuilder = new PrintWriterTopologyBuilder("PrintWriterTopology1");
		printWriterTopologyBuilder.setNumWorkers(1);
		printWriterTopologyBuilder.setSpout(1);
		printWriterTopologyBuilder.setPrintBolt(1, 1);
		printWriterTopologyBuilder.setWriterBolt(1, 1);

		PrintWriterTopology printWriterTopology = printWriterTopologyBuilder.createTopology();

		printWriterTopology.submitTopologyOnLocal();

		Thread.sleep(20000);

		printWriterTopology.killTopology();
	}
}


运行： 默认并行度都是1， StreamGrouping 是 Shuffle 随机模式

Print： 1一个worker 1一个 Executor


WriteBolt

、


Flink保姆级教程,超详细,教学集成多个第三方工具(从入门到精通)
最新发布
Oz_Mood的博客
04-02 1万+
Flink 允许你通过实现接口来创建自定义数据源。// 定义一个自定义数据源Thread.sleep(1000) // 模拟数据生成延迟// 创建执行环境// 添加自定义数据源// 打印数据流// 启动 Flink 作业以上示例展示了如何在 Scala 中使用 Flink DataStream API 来从不同的数据源获取数据。每个示例都包含了创建数据流的代码和对数据流进行操作的注释。这些示例可以作为构建更复杂 Flink 流处理作业的起点。
Storm入门案例
qq_45453185的博客
08-04 460
1.Storm单机模式 Storm提供了单机开发模式，即使没有Storm集群也可以在本地java环境中进行开发测试。 2.入门案例 a.需求 利用Storm实现实时的单词统计 b.分析需求 想要开发一个Spout需要写一个类实现 IComponent接口 和 ISpout接口，实现相应方法。 直接实现这两个接口需要实现的方法比较多，可以选择继承BaseRichSpout默认实现类，此类已经实现过如上两个接口，并将大部分方法做了默认空实现，只需继承...
Storm 简单示例
01-23
Storm 简单示例，电子书中的一个例子，入门可以参考下！！！！
storm 示例demo
01-05
简单的storm入门示例，从0到1让你清楚的理解storm.下面是代码示例： import backtype.storm.topology.BasicOutputCollector; import backtype.storm.topology.OutputFieldsDeclarer; import backtype.storm.topology.base.BaseBasicBolt; import backtype.storm.tuple.Fields; import backtype.storm.tuple.Tuple; import backtype.storm.tuple.Values; public class WordNormalizer extends BaseBasicBolt { public void cleanup() {} /** * The bolt will receive the line from the * words file and process it to Normalize this line * * The normalize will be put the words in lower case * and split the line to get all words in this */ public void execute(Tuple input, BasicOutputCollector collector) { String sentence = input.getString(0); String[] words = sentence.split(" "); for(String word : words){ word = word.trim(); if(!word.isEmpty()){ word = word.toLowerCase(); collector.emit(new Values(word)); } } } /** * The bolt will only emit the field "word" */ public void declareOutputFields(OutputFieldsDeclarer declarer) { declarer.declare(new Fields("word")); } }
storm入门到精通
12-29
01.Storm基础知识、02.Storm集群安装-1-new 、03.Storm集群安装-2、04.starter打包运行测试、05.Storm配置文件配置项讲解。。。。。。15集全
storm_简单的例子
子龙修仙的博客
12-06 382
写一个简单的topology，spout处理各单词，第一组bolt给各单词后面添加!!!，然后汇聚到同一个bolt并记录所有的单词及个数。 新建一个java项目，HelloStorm。新建一个lib文件夹。将storm0.9.5的lib全拷进去。并全Add to build path。 新建三个包：com.gary.topology、com.gary.spout、com.gary.bolt...
Storm 入门示例
做个简单的程序员
09-16 613
功能描述 从数据中随机选取语句（ChooseSpout） 将句子中的单词分开（SplitSentence） 统计单词（WordCount） ----------------------------------------- 项目采用 maven构建 pom.xml <project xmlns="http://maven.apache.org/POM/4.0.0"
storm之WordCount示例Java代码.zip
12-28
本压缩包提供的"storm之WordCount示例Java代码"是针对Storm的一个经典入门教程，展示了如何使用Java语言实现一个简单的WordCount程序。这个程序的主要目标是统计文本数据流中的单词出现次数。 首先，我们需要理解...
storm之TridentFilter使用示例代码.zip
12-28
Storm的核心概念之一是Trident，这是一个高容错、低延迟的数据处理模型。本篇将深入探讨TridentFilter在Apache Storm中的应用，通过提供的示例代码帮助理解其工作原理和使用方法。 Trident是Storm中的一个高级API，...
storm之集成kafka操作示例代码.zip
12-28
3. **Storm-Kafka Integration**：为了将Storm与Kafka结合，我们需要使用Storm的Kafka Spout，这是一个特殊的spout，可以从Kafka主题中读取数据。Spout会连接到Kafka集群，订阅特定的主题，并持续地将新产生的消息...
Java入门级Storm代码示例：简单易懂的项目实践
关于标题中提到的“超级简单入门的Storm的Java代码demo”，这个示例项目应该是一个非常基础的Storm应用，它演示了如何创建一个简单的Topology，并使用Spout和Bolt来处理数据流。这个示例可能包含以下几个部分： 1. ...
Storm 上手 demo 例子 演示
04-19
Storm demo 例子 案例
storm一个简单实例
06-26
storm的第一个简单的实例，适合初学storm的人理解和学习，已经在storm集群中跑通。注释是自己写的方便理解
storm 入门例子
易水寒
06-22 845
TopologiesThe logic for a realtime application is packaged into a Storm topology. A Storm topology is analogous to a MapReduce job. One key difference is that a MapReduce job eventually finishes, wher...
Storm示例程序
weixin_44911248的博客
07-18 758
Storm示例程序
Storm之——简单编程案例
冰河的专栏
10-24 7397
一、案例概述 今天，就带着大家一起来实现一个简单的Storm实例，这个实例很简单，实现以下功能： 我们定义一个数组，比如：String[] words = {"iphone","xiaomi","mate","sony","sumsung","moto","meizu"};  通过Strom不断输出类似输出以下的结果： IPHONE_itisok XIAOMI_itisok MATE_i
Trident API概述
xqy1522的专栏
01-19 4881
Storm Trident的核心数据模型是一批一批被处理的“流”，“流”在集群的分区在集群的节点上，对“流”的操作也是并行的在每个分区上进行。   Trident有五种对“流”的操作： 1.      不需要网络传输的本地批次运算 2.      需要网络传输的“重分布”操作，不改变数据的内容 3.      聚合操作，网络传输是该操作的一部分 4.      “流”分组（grouby
关于storm简单程序的例子
qq_42935519的博客
12-13 148
关于storm简单程序的例子 storm框架
【Twitter Storm系列之三】 storm简单实例分析
Jonathan.Wei的专栏
12-18 7021
Storm实时流计算系统实例讲解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值