Storm 从入门到精通 第十六讲 Storm 可靠性 - ack 与 fail 及 数据拆分（多Bolt处理），事务不一致

最新推荐文章于 2019-03-29 14:21:05 发布
最新推荐文章于 2019-03-29 14:21:05 发布
阅读量1k 收藏 1
点赞数 2
分类专栏： Storm框架 Storm 从入门到精通 文章标签： Storm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/netcobol/article/details/79814072
版权
Spout是 Storm数据流的入口,在设计拓扑时,一件很重要的事情就是需要考虑消息的可靠性,如果消息不能被处理而丢失是很严重的问题。

以一个传递消息并且实时处理的例子,来说明这个问题。

Message Spout： 发送一批数据， 格式使用逗号分隔， 共计4条Subject，每个Subject 包含两个单词。
private static final String[] Subjects = new String[] { "Groovy,Oracle", "Springboot,Java", "C++,VB","Ruby,Scala" }; 

SplitSubjectBolt：接收Spout 每一个 Subject ，按照逗号分词，通过Global Grouping 发送给下一个Writer bot。

WriteSubjectBolt： 将SplitSubjectBolt分词每个Word 记录到日志中。



1. MessageReliabilityTopology

package com.john.learn.storm.reliability;

import org.apache.storm.Config;
import org.apache.storm.LocalCluster;
import org.apache.storm.topology.TopologyBuilder;
import org.apache.storm.tuple.Fields;

import com.john.learn.storm.reliability.bolt.SplitSubjectBolt;
import com.john.learn.storm.reliability.bolt.WriteSubjectBolt;
import com.john.learn.storm.reliability.spout.MessageSpout;

public class MessageReliabilityTopology {

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

		Config config = new Config();
		config.setNumWorkers(2);
		config.setDebug(false);

		TopologyBuilder topologyBuilder = new TopologyBuilder();

		topologyBuilder.setSpout("MessageSpout", new MessageSpout());

		topologyBuilder.setBolt("SplitSubjectBolt", new SplitSubjectBolt()).shuffleGrouping("MessageSpout");

		topologyBuilder.setBolt("WriteSubjectBolt", new WriteSubjectBolt()).globalGrouping("SplitSubjectBolt");

		LocalCluster localCluster = new LocalCluster();
		localCluster.submitTopology("MessageReliabilityTopology", config, topologyBuilder.createTopology());

		Thread.sleep(20000);

		localCluster.killTopology("MessageReliabilityTopology");
		localCluster.shutdown();
	}
}

2. MessageSpout

package com.john.learn.storm.reliability.spout;

import java.util.Map;

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 MessageSpout extends BaseRichSpout {

	public void nextTuple() {

		if (index >= Subjects.length) {
			return;
		}
		// 第一个参数Message, 第二个 message Id
		collector.emit(new Values(index, Subjects[index]), index);

		System.out.println("[" + Thread.currentThread().getName() + "] " + Subjects[index] + " 消息发送完毕，消息ID:" + index);

		index++;

	}

	public void open(Map config, TopologyContext contexxt, SpoutOutputCollector collector) {

		this.collector = collector;

	}

	public void declareOutputFields(OutputFieldsDeclarer fieldsDeclarer) {

		fieldsDeclarer.declare(new Fields("Index", "Subject"));

	}

	@Override
	public void ack(Object msgId) {

		System.out.println("[" + Thread.currentThread().getName() + "] 消息成功处理，消息ID:" + msgId);

	}

	@Override
	public void fail(Object msgId) {

		System.out.println("[" + Thread.currentThread().getName() + "] 消息处理失败，消息ID:" + msgId);

		System.out.println("[" + Thread.currentThread().getName() + "] 消息重发, 消息ID:" + msgId);
		collector.emit(new Values(msgId, Subjects[(Integer) msgId]), msgId);

		System.out.println("[" + Thread.currentThread().getName() + "] 消息重发完毕, 消息ID:" + msgId);
	}

	@Override
	public void close() {

		// Release Resource

		// 例如： Close File 、 Close database\ Close socket etc.

	}

	private SpoutOutputCollector collector;

	private static final String[] Subjects = new String[] { "Groovy,Oracle", "Springboot,Java", "C++,VB",
			"Ruby,Scala" };

	private int index = 0;

	private static final long serialVersionUID = 1L;
}

通过ack 和 fail 方法 完成异常数据重复发送，增加系统可靠性

3. SplitSubjectBolt

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

import java.util.Map;
import java.util.Random;

import org.apache.storm.shade.org.apache.commons.lang.StringUtils;
import org.apache.storm.task.OutputCollector;
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.BaseRichBolt;
import org.apache.storm.tuple.Fields;

import org.apache.storm.tuple.Tuple;
import org.apache.storm.tuple.Values;

import com.john.learn.storm.reliability.dice.DiceUtils;

public class SplitSubjectBolt extends BaseRichBolt {

	public void execute(Tuple tuple) {

		String subject = tuple.getStringByField("Subject");
		Integer index = tuple.getIntegerByField("Index");

		try {

			String[] words = StringUtils.splitByWholeSeparator(subject, ",");

			for (String word : words) {

				// 故意导致系统异常，测试Storm 容错性
				if (failed && "Java".equals(word)) {

					throw new RuntimeException("Failed Message Word:" + word);
				}

				// 发送消息必须携带 Tuple，用于异常处理
				collector.emit(tuple, new Values(index, word));

				System.out.println("[" + Thread.currentThread().getName() + "] 成功发送单词到下一个Strom Bolt:" + word + " 第"
						+ index + "行数据！");

			}

			// 手工标记成功
			collector.ack(tuple);

		} catch (Throwable e) {

			System.out.println(
					"[" + Thread.currentThread().getName() + "] 失败发送单词到下一个Strom Bolt:Java第" + index + "行数据！开启重新发送！");
			if (DiceUtils.isSmall()) {  // DiceUtils.isSmall() 随机模拟Bug修复

				// 失败已经处理完毕
				failed = false;
			}
			// 手工标记失败
			collector.fail(tuple);
		}
	}

	public void prepare(Map config, TopologyContext context, OutputCollector collector) {

		this.collector = collector;
	}

	public void declareOutputFields(OutputFieldsDeclarer fieldsDeclarer) {

		fieldsDeclarer.declare(new Fields("Index", "Word"));
	}

	private OutputCollector collector;

	private boolean failed = true;

	private static final long serialVersionUID = 1L;
}

4. WriteSubjectBolt

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

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.Map;
import java.util.Random;

import org.apache.storm.shade.org.apache.commons.lang.StringUtils;
import org.apache.storm.task.OutputCollector;
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.BaseRichBolt;
import org.apache.storm.tuple.Fields;

import org.apache.storm.tuple.Tuple;
import org.apache.storm.tuple.Values;

import com.john.learn.storm.reliability.dice.DiceUtils;
import com.john.learn.storm.reliability.storage.DatabaseSimulatorDataStorage;

public class WriteSubjectBolt extends BaseRichBolt {

	public void prepare(Map config, TopologyContext context, OutputCollector collector) {

		this.collector = collector;

		File file = new File("C:\\Storm\\MessageReliabilityBolt\\message.txt");

		file.getParentFile().mkdirs();

		try {

			writer = new FileWriter(file);

		} catch (IOException e) {

			e.printStackTrace();
		}
	}

	public void declareOutputFields(OutputFieldsDeclarer fieldsDeclarer) {

	}

	public void execute(Tuple tuple) {

		String word = tuple.getStringByField("Word");
		Integer index = tuple.getIntegerByField("Index");

		String marker = "WriteSubjectBolt.Success." + index + "." + word;

		try {

//			if (DatabaseSimulatorDataStorage.getInstance().isSuccess(marker)) {
//				// 手工标记成功
//				collector.ack(tuple);
//				return;
//			}

			// 故意导致系统异常，测试Storm 容错性
			if (failed && "Java".equals(word)) {

				int i = 1 / 0;
			}

			writer.write(word);
			writer.write("\r\n");
			writer.flush();

			System.out.println("[" + Thread.currentThread().getName() + "] 成功写入文件:" + word + " 第" + index + "行数据！");

			// 手工标记成功
			collector.ack(tuple);

			//记录成功标志
			//DatabaseSimulatorDataStorage.getInstance().markSuccess(marker);

		} catch (Throwable e) {

			System.out.println("[" + Thread.currentThread().getName() + "] 写入文件失败:" + word + " 第" + index + "行数据！");

			// 失败已经处理完毕

			if (DiceUtils.isSmall()) {
				failed = false;
			}
			// 手工标记失败
			collector.fail(tuple);
		}
	}

	@Override
	public void cleanup() {

		try {
			writer.close();
		} catch (Exception e) {

		}
	}

	private OutputCollector collector;

	private boolean failed = true;

	private Writer writer = null;

	private static final long serialVersionUID = 1L;
}

5. DiceUtils

package com.john.learn.storm.reliability.dice;

import java.util.Random;

import clojure.main;

public class DiceUtils {

	public static int dice() {

		return random.nextInt(6) + 1;
	}

	public static boolean isSmall() {

		return dice() < 4;
	}

	private static Random random = new Random();
	
	public static void main(String[] args) {
		System.out.println(DiceUtils.isSmall());
	}
}

运行结果说明：

1.  4组Subject 待发送， 每个Subject 由两个词组成。

2. 发送4个Subject

 

程序片段：MessageSpout


3. Split bolt 中 Java 分词导致系统异常，需要重新发送。但注意：

"Springboot,Java" 中 Springboot 成功发送个WriterBolt。 Java 导致 整个"Springboot,Java"  subject 重新发送，即Springboot必将出现重复处理，没有实现弱事务一致性。



程序片段：SplitSubjectBolt


3. WriteSubjectBolt  中仅仅成功写入 Springboot 没有 Java， 但随后 Subject （Springboot,Java） 由于 Failed， 将重新从Spout发送。








4. 重发流程：


    Subject数据 共计 4个 其中 2,3, 0 索引的数据成功发送完毕。 对于1号索引 "Springboot, Java" 由于系统异常，重复发送
    第一次error：[Thread-19-SplitSubjectBolt-executor[2 2]] 失败发送单词到下一个Strom Bolt:Java第1行数据！开启重新发送！
    出现 Spout （1）的重复， 然后 Split 成功接收到数据，发送给 Writer Bolt （2）
    但由于Writer 写入 Java 异常 （3），导致数据"Springboot, Java" 再次从 Spout 重新发送（4）。
    然后 Split 成功接收到数据，发送给 Writer Bolt （5）， 由于通过Dice随机修复失败 （6）！DiceUtils.isSmall() 导致Spout重发(7)
     然后 Split 成功接收到数据，发送给 Writer Bolt （8），这次 WriterBolt 成功写入 Java (9), 最终任务处理成功！（10）


    由于 "Springboot,Java" 数据在Split Bolt 拆分成2个独立事务，Springboot必将出现重复处理，没有实现弱事务一致性。 即文件中写入多个Sprintboot
   


C:\Storm\MessageReliabilityBolt\message.txt


随后讲解如下确保数据一致性，避免重复处理。

netcobol
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【预研】Storm C++ Wrapper demo的单机版本实现
aganlengzi的专栏
11-23 902
基础知识思考整理 http://blog.csdn.net/aganlengzi/article/details/53261391 主要是参照[1][2][3]实现一个C++写的WordCountTopology的demo并成功运行，记录一下。
并发控制-事务的调度、数据不一致问题（更新丢失、脏读、不可重复读）、非串行调度的的可串行化
最新发布
Watermelon_Mr的博客
07-01 1157
比如在事务T1和T2的非串行调度中，事务T1读取了缓冲区中数据对象X之后，将X值减少50并将X值写入缓冲区，假设X的初值为100，此时缓冲区中的数据X的结果就是50，随后事务T2读取了事务T1对X的更新结果并进行计算，即事务T2读取的X值为50，但事务T1在完成之前发生了故障，事务T1撤销回滚，将X的值恢复为事务T1开始时的初值，即100，这样事务T2读取的是夭折事务T1对X的中间更新结果值50，是脏数据，并在此基础上对X进行了更新，使数据库处于不一致状态，9、但不同事务对同一数据对象的读写操作是冲突的。
如何解决事务操作中状态不一致的现象？
samdyli先生的专栏-wx:lisamdy
09-06 2633
昨天，一个同学问了一个关于事务处理的一个问题。问题的情景是，有一个机柜分里n层，每一层放里一些设备。现在有两个线程，分别对机柜里面的设备做操作。操作之前先检查数据库中设备是不是已经被占用，如果被占用则不去操作，没有被占用则去占用被在设备的置标志位。伪代码描述处理过程如下： if(getStateFromDbByDeviceId(DeviceId)){ 占用设备.... setStat
Storm C++
05-25 1391
本文列出了自己使用C++编写Storm运行案例时遇到的问题，以及大致思路
在Strom中使用C++开发Bolt总结
jmppok的专栏
11-19 8307
1.Storm简介 Storm是Twitter开源的一套并行处理系统，网站主页：https://github.com/nathanmarz/storm/wiki 其思想与Hadoop类似，但也与Hadoop有本质区别：Hadoop主要偏重批处理,Storm主要面向实时处理， 与Storm类似的系统还有Puma 、S4等。 2.为什么使用C++开发Storm Bolt Sto
storm利用ack保证数据的可靠性源码
10-10
总的来说，Storm的ack机制是其可靠数据处理的核心，通过精细控制tuple的生命周期、故障恢复和超时重试，保证了数据在流处理中的完整性。理解并有效利用这一机制对于构建高效、可靠的实时数据处理系统至关重要。在...
Storm事务性拓扑详解教程.docx
11-05
在分布式流处理系统Apache Storm中，事务性拓扑是一个关键特性，它允许开发人员构建能够保证数据完整性和一致性的实时处理应用。事务性拓扑在Storm 0.7.0版本中引入，解决了消息可能被重复处理的问题，这对于那些...
02、Storm入门到精通storm3-1.pptx
11-30
5. **可靠性保证**: Storm通过`Ack机制`确保数据不丢失。当一个Bolt处理完一个Tuple后，它会发送一个确认（Ack），如果某个Bolt在处理过程中失败，Storm会重新调度处理，直到成功。此外，如果任务失败，Storm会自动...
Storm中spout和bolt之间发送和接收数据的java源代码实例
11-05
在Apache Storm分布式流处理框架中，Spout和Bolt是两个核心组件，它们协同工作以处理实时数据流。本篇文章将深入探讨Spout和Bolt之间的数据交互，并提供相关的Java源代码实例，帮助你理解这一过程。 首先，让我们...
大数据分析架构师顶级培训课程storm课程 Trident理论与应用 Trident基础理论与实战 共35页.pptx
06-02
### 大数据开发高级就业指导课程——Storm及Trident理论与实战 #### 一、Storm并发机制 在Storm中，为了提高数据处理的性能和效率，设计了一套完整的并发机制。这一机制涉及到Topology的组件配置、并发度设置等多...
C/C++实现对STORM运行信息查看及控制的方法
12-26
本文所述程序实例主要实现在后端应用服务器上实时获取STORM集群的运行信息和topology相关的提交和控制。对此，通过对STORM UI和CMD源码的分析，得出可以通过其thrift接口调用实现这些功能。先下载一个thrift库进行编码和安装。关于thrift可以参见这个地方。安装完成后，从STORM源码中将storm.thrift拷贝到thrift目录下。输入: hrift -gen cpp storm.thrift 会得到一个gen-cpp目录，里面就是thrift先关脚本的C++实现。我们先看storm.thrift文件接口： service Nimbus { //TOPOLO
Storm 从入门到精通 第十七讲 Storm 可靠性 - ack 与 fail 及 事务一致性
John,hao的专栏
04-04 525
上一章，讲解ack 与 fail的使用， 到由于数据拆分到多个Bolt 导致数据事务不一致性问题，如何解决呢？1. 使用Batch 处理，比较简单，但无法享受分布式计算带来的好处，高性能。2. 手工记录 成功数据 （Message Id + Data ID） 避免重复。程序代码：DatabaseSimulatorDataStoragepackage com.john.learn.storm.rel...
【七】storm的ack和fail机制代码演示
Sid小杰的博客
06-11 915
package com.sid.bigdata.storm.sum; import java.util.Map; import org.apache.storm.Config; import org.apache.storm.LocalCluster; import org.apache.storm.spout.SpoutOutputCollector; import org.apache.s...
Storm流之多个Bolt聚合到一个Bolt
Simon的博客
04-19 3093
Storm流之多个Bolt聚合到一个Bolt 一、       案例Demo             基于分发案例，将MinBolt、MidBolt、MaxBolt聚合到TotalBolt 二、       FenFaTopology代码 package com.test.csdn; import org.apache.storm.Config; import org.apache...
Storm缓存对象的传递（多个bolt共同操作同一个缓存）
从一点一滴做起
03-29 1210
问题： 最近项目中遇到要在Bolt A 中添加缓存cache，在Bolt B中删除缓存cache的需求。 思路： 两个思路 在拓扑(Topology)中创建一个缓存，将创建的缓存以构造函数传参的形式传递进去。 在上游的Bolt，也就是Bolt A中创建一个缓存，并在该类中添加get方法。 第一种思路（构造函数传参：实验证明不可用） 原因：storm的prepare中会对对象进行序列...
storm spout，bolt超时处理和fail处理
linux_ja的专栏
02-08 2543
如果toplogy在debug模式下，如果发现__tick打印，则是ack超时导致的，如果打印__ack_fail打印则是消息fail导致的 分别对应的变量backtype.storm.SYSTEM_TICK_STREAM_ID = "__tick"; (def ACKER-FAIL-STREAM-ID "__ack_fail")
Storm可靠的Bolt与不可靠的Bolt
lavimer
04-26 3411
Storm可以保证每个Spout发射的消息会被所有的Bolt完全处理。这是设计时要考虑的因素，这意味着程序员将决定Bolt是否需要保证消息处理。 可靠Bolt的execute()方法如下： @Override public void execute(Tuple input) { String sentence = input.getString(0); for (String wor
Storm入门学习随记
weixin_30249203的博客
04-08 218
推荐慕课网视频：http://www.imooc.com/video/10055 另外，关于Storm并发度，已经整理到另一篇博客中，希望对读者有所帮助。 请参考：http://www.cnblogs.com/quchunhui/p/8271349.html ====Storm的起源。 Storm是开源的、分布式、流式计算系统 什么是分布式呢？就是将一个任务拆解给多...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值