Spark Streaming：DStream的transformationy及output操作

最新推荐文章于 2023-08-13 20:53:35 发布
最新推荐文章于 2023-08-13 20:53:35 发布
阅读量294 收藏
点赞数 1
分类专栏： Spark 文章标签： Spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiaojiao521765146514/article/details/87619808
版权

updateStateByKey

updateStateByKey操作允许您在使用新的信息持续更新时保持任意状态

public class UpdateStateByKeyWordCount {

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

		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("UpdateStateByKeyWordCount");

		JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(5));

		// 1.开启checkpoint机制 长期保存一份key的state的话，那么spark
		// streaming是要求必须用checkpoint的，以便于在内存数据丢失的时候，可以从checkpoint中恢复数据
		jsc.checkpoint("hdfs://spark1:9000/checkpoint");

		HashMap<String, String> kafkaParams = new HashMap<String, String>();
		kafkaParams.put("metadata.broker.list", "spark1:9092,spark2:9092,spark3:9092");

		Set<String> topics = new HashSet<String>();
		topics.add("WordCount");

		JavaPairInputDStream<String, String> lines = KafkaUtils.createDirectStream(jsc, String.class, String.class, StringDecoder.class, StringDecoder.class, kafkaParams, topics);

		lines.flatMap(new FlatMapFunction<Tuple2<String, String>, String>() {

			private static final long serialVersionUID = 1L;

			@Override
			public Iterator<String> call(Tuple2<String, String> t) throws Exception {
				return Arrays.asList(t._2.split(" ")).iterator();
			}
		}).mapToPair(new PairFunction<String, String, Integer>() {

			private static final long serialVersionUID = 1L;

			@Override
			public Tuple2<String, Integer> call(String t) throws Exception {
				return new Tuple2<String, Integer>(t, 1);
			}
		}).updateStateByKey(new Function2<List<Integer>, Optional<Integer>, Optional<Integer>>() {

			private static final long serialVersionUID = 6739658684229224595L;

			/**
			 * values:相当于是这个batch中,这个key的新的值,可能有多个吧。 state:指的是这个key之前的状态
			 */
			@Override
			public Optional<Integer> call(List<Integer> values, Optional<Integer> state) throws Exception {
				Integer newValue = 0;
				// 判断state是否存在
				if (state.isPresent()) {
					newValue = state.get();
				}
				// 将本次新出现的值，都累加到newValue上去
				for (Integer value : values) {
					newValue += value;
				}

				return Optional.of(newValue);
			}
		}).print();

		jsc.start();

		jsc.awaitTermination();

		jsc.close();

	}

}

使用到updateStateByKey要开启checkpoint机制

transform

将DStream 转换为一个个底层的RDD ；从而实现将DStream中的RDD到其他类型RDD的任意操作

public class TransformBlacklist {

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

		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("KafkaDirectWordCount");

		JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(5));

		jssc.checkpoint("hdfs://spark1:9000/checkpoint");

		HashMap<String, String> kafkaParams = new HashMap<String, String>();
		kafkaParams.put("metadata.broker.list", "spark1:9092,spark2:9092,spark3:9092");

		Set<String> topics = new HashSet<String>();
		topics.add("WordCount");

		JavaPairInputDStream<String, String> adsClickLogDStream = KafkaUtils.createDirectStream(jssc, String.class, String.class, StringDecoder.class, StringDecoder.class, kafkaParams, topics);

		// 模拟的黑名单RDD
		List<Tuple2<String, Boolean>> blacklist = new ArrayList<Tuple2<String, Boolean>>();
		blacklist.add(new Tuple2<String, Boolean>("tome", true));

		JavaPairRDD<String, Boolean> blacklistRDD = jssc.sparkContext().parallelizePairs(blacklist);

		adsClickLogDStream.filter(new Function<Tuple2<String, String>, Boolean>() {

			private static final long serialVersionUID = -7235497847013109561L;

			@Override
			public Boolean call(Tuple2<String, String> v1) throws Exception {
				if (v1._2.split(" ").length > 1) {
					return true;
				}
				return false;
			}
		}).mapToPair(new PairFunction<Tuple2<String, String>, String, String>() {

			private static final long serialVersionUID = -3077988541495338394L;

			@Override
			public Tuple2<String, String> call(Tuple2<String, String> t) throws Exception {
				return new Tuple2<String, String>(t._2.split(" ")[1], t._2);
			}
		}).transform(new Function<JavaPairRDD<String, String>, JavaRDD<String>>() {

			private static final long serialVersionUID = 1L;

			@Override
			public JavaRDD<String> call(JavaPairRDD<String, String> userAdsClickLogRDD) throws Exception {

				return userAdsClickLogRDD.leftOuterJoin(blacklistRDD).filter(new Function<Tuple2<String, Tuple2<String, Optional<Boolean>>>, Boolean>() {

					private static final long serialVersionUID = 1989422109385197246L;

					@Override
					public Boolean call(Tuple2<String, Tuple2<String, Optional<Boolean>>> v1) throws Exception {
						if (v1._2._2.isPresent() && v1._2._2.get()) {
							return false;
						}
						return true;
					}
				}).map(new Function<Tuple2<String, Tuple2<String, Optional<Boolean>>>, String>() {

					private static final long serialVersionUID = 2131045968786323938L;

					@Override
					public String call(Tuple2<String, Tuple2<String, Optional<Boolean>>> v1) throws Exception {
						return v1._2._1();
					}
				});
			}
		}).mapToPair(new PairFunction<String, String, Integer>() {

			private static final long serialVersionUID = 3905589286163712170L;

			@Override
			public Tuple2<String, Integer> call(String t) throws Exception {
				return new Tuple2<String, Integer>(t, 1);
			}

		}).updateStateByKey(new Function2<List<Integer>, Optional<Integer>, Optional<Integer>>() {

			private static final long serialVersionUID = 1L;

			@Override
			public Optional<Integer> call(List<Integer> v1, Optional<Integer> state) throws Exception {

				Integer newValue = 0;

				if (state.isPresent()) {
					newValue = state.get();
				}

				for (Integer value : v1) {
					newValue += value;
				}

				return Optional.of(newValue);
			}
		}).print();

		jssc.start();
		jssc.awaitTermination();
		jssc.close();

	}
}

window滑动窗口

Spark Streaming提供了滑动窗口操作的支持，从而让我们可以对一个滑动窗口内的数据执行计算操作。每次掉落在窗口内的RDD的数据，会被聚合起来执行计算操作，然后生成的RDD，会作为window DStream的一个RDD
在这里插入图片描述
网官图中所示，就是对每三秒钟的数据执行一次滑动窗口计算，这3秒内的3个RDD会被聚合起来进行处理，然后过了两秒钟，又会对最近三秒内的数据执行滑动窗口计算。所以每个滑动窗口操作，都必须指定两个参数，窗口长度以及滑动间隔，而且这两个参数值都必须是batch间隔的整数倍。

Spark-Streaming对滑动窗口支持的转换操作：

转化简述
window(windowLength,slideInterval)返回一个新的DStream ，它是基于窗口的源Dstream的batches 集合
countByWindow(windowLength,slideInterval)返回数据流的滑动窗口中的元素的数量
reduceByWindow(func,windowLength,slideInterval)在一个滑动间隔内，使用函数func 聚合元素，产生新的氮元素的流。这个func必须是联合交替的，才能正确的并行处理数据。
reduceByKeyAndWindow(func,windowLength,slideInterval, [numTasks])当kv 键值对的数据流，返回一个新的kv键值对的新数据流，新数据流每个key通过 给定的reduce 函数func 在一个窗口内进行值得聚合。需要注意的： 这个使用spark默认并行数量（local模式的话是2 ，cluster模式的话取决于 配置参数 spark.default.parallelism）进行分组。你可以传入一个可选的参数 numTasks 参数设置一个不同的task的数量
reduceByKeyAndWindow(func, invFunc, windowLength, slideInterval、[numTasks])比上面的reduceByKeyAndWindow 更有效的一个版本，能够在之前window的reduce 值 加上当前窗口计算reduce的值 。这个实现是通过reducing 新进入到窗口的数据，反向reducing 离开窗口的老数据。举个例子，随着窗口的滑动，对key的统计值进行加减。然后这个只适用于可以逆转的函数。也就是说，这些reduce的函数，有一个相关的逆向的函数。注意： 这个操作必须设置 checkpointing。
countByValueAndWindow (windowLength, slideInterval, [numTasks])当kv键值对的数据流被调用的时候，返回一个新的kv键值对的数据流。就像 reduceByKeyAndWindow ，reduce的task的数量是可以通过配置修改的。
/**
 * 热点搜索词滑动统计，每隔10秒钟，统计最近60秒钟的搜索词的搜索频次，并打印出排名最靠前的3个搜索词以及出现次数
 * 
 */
public class WindowHotWord {

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

		LogManager.getRootLogger().setLevel(Level.ERROR);

		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("UpdateStateByKeyWordCount");

		JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(5));

		// 1.开启checkpoint机制 长期保存一份key的state的话，那么spark
		// streaming是要求必须用checkpoint的，以便于在内存数据丢失的时候，可以从checkpoint中恢复数据
		jsc.checkpoint("hdfs://spark1:9000/checkpoint");

		HashMap<String, String> kafkaParams = new HashMap<String, String>();
		kafkaParams.put("metadata.broker.list", "spark1:9092,spark2:9092,spark3:9092");

		Set<String> topics = new HashSet<String>();
		topics.add("WordCount");

		JavaPairInputDStream<String, String> searchLogsDStream = KafkaUtils.createDirectStream(jsc, String.class, String.class, StringDecoder.class, StringDecoder.class, kafkaParams, topics);

		searchLogsDStream.mapToPair(new PairFunction<Tuple2<String, String>, String, Integer>() {

			private static final long serialVersionUID = 1L;

			@Override
			public Tuple2<String, Integer> call(Tuple2<String, String> searchLog) throws Exception {
				return new Tuple2<String, Integer>(searchLog._2.split(" ")[1], 1);
			}
		}).reduceByKeyAndWindow(new Function2<Integer, Integer, Integer>() {

			private static final long serialVersionUID = -974658511061140165L;

			/**
			 * 每隔10秒钟，将最近60秒的数据，作为一个窗口，进行内部的RDD的聚合
			 */
			@Override
			public Integer call(Integer v1, Integer v2) throws Exception {
				return v1 + v2;
			}

		}, Durations.seconds(60) // 窗口长度，这里是60秒
				, Durations.seconds(10) // 滑动间隔，这里是10秒
		/**
		 * 执行transformToPair操作，因为，一个窗口，就是一个60秒钟的数据，会变成一个RDD
		 */
		).transformToPair(new Function<JavaPairRDD<String, Integer>, JavaPairRDD<String, Integer>>() {

			private static final long serialVersionUID = 1L;

			@Override
			public JavaPairRDD<String, Integer> call(JavaPairRDD<String, Integer> searchWordCountsRDD) throws Exception {

				List<Tuple2<String, Integer>> hogSearchWordCounts = searchWordCountsRDD.mapToPair(new PairFunction<Tuple2<String, Integer>, Integer, String>() {

					private static final long serialVersionUID = 1L;

					@Override
					public Tuple2<Integer, String> call(Tuple2<String, Integer> t) throws Exception {
						return new Tuple2<Integer, String>(t._2, t._1);
					}
				}).sortByKey(false).mapToPair(new PairFunction<Tuple2<Integer, String>, String, Integer>() {

					private static final long serialVersionUID = 1L;

					@Override
					public Tuple2<String, Integer> call(Tuple2<Integer, String> t) throws Exception {
						return new Tuple2<String, Integer>(t._2, t._1);
					}
				}).take(3);

				for (Tuple2<String, Integer> wordCount : hogSearchWordCounts) {
					System.out.println(wordCount._1 + ": " + wordCount._2);
				}

				return searchWordCountsRDD;
			}
		}).print();

		jsc.start();

		jsc.awaitTermination();

		jsc.close();
	}

}

output操作

DStream中的所有计算，都是由output操作触发的，比如print()。如果没有任何output操作，那么，压根儿就不会执行定义的计算逻辑。

此外，即使你使用了foreachRDD output操作，也必须在里面对RDD执行action操作，才能触发对每一个batch的计算逻辑。否则，光有foreachRDD output操作，在里面没有对RDD执行action操作，也不会触发任何逻辑。

OutputMeaning
print打印每个batch中的前10个元素，主要用于测试，或者是不需要执行什么output操作时，用于简单触发一下job。
saveAsTextFile(prefix, [suffix])将每个batch的数据保存到文件中。每个batch的文件的命名格式为：prefix-TIME_IN_MS[.suffix]
saveAsObjectFile同上，但是将每个batch的数据以序列化对象的方式，保存到SequenceFile中。
saveAsHadoopFile同上，将数据保存到Hadoop文件中。
foreachRDD最常用的output操作，遍历DStream中的每个产生的RDD，进行处理。可以将每个RDD中的数据写入外部存储，比如文件、数据库、缓存等。通常在其中，是针对RDD执行action操作的，比如foreach。
public class ConnectionPool {

	static LinkedList<Connection> connectionQueue;

	static {
		try {
			Class.forName("com.mysql.jdbc.Driver");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	public synchronized static Connection getConnection() {
		if (connectionQueue == null) {
			connectionQueue = new LinkedList<Connection>();
			for (int i = 0; i < 2; i++) {
				try {
					Connection conn = DriverManager.getConnection("jdbc:mysql://spark1:3306/test", "", "");
					connectionQueue.push(conn);
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
		}
		return connectionQueue.poll();
	}

	public static void returnConnection(Connection conn) {
		connectionQueue.push(conn);
	}
}

public class PersistWordCount {

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

		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("PersistWordCount");

		JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(5));

		jsc.checkpoint("hdfs://spark1:9000/checkpoint");

		HashMap<String, String> kafkaParams = new HashMap<String, String>();
		kafkaParams.put("metadata.broker.list", "spark1:9092,spark2:9092,spark3:9092");

		Set<String> topics = new HashSet<String>();
		topics.add("WordCount");

		JavaPairInputDStream<String, String> lines = KafkaUtils.createDirectStream(jsc, String.class, String.class, StringDecoder.class, StringDecoder.class, kafkaParams, topics);

		lines.flatMap(new FlatMapFunction<Tuple2<String, String>, String>() {

			private static final long serialVersionUID = 1L;

			@Override
			public Iterator<String> call(Tuple2<String, String> t) throws Exception {
				return Arrays.asList(t._2.split(" ")).iterator();
			}
		}).mapToPair(new PairFunction<String, String, Integer>() {

			private static final long serialVersionUID = 1L;

			@Override
			public Tuple2<String, Integer> call(String t) throws Exception {
				return new Tuple2<String, Integer>(t, 1);
			}
		}).updateStateByKey(new Function2<List<Integer>, Optional<Integer>, Optional<Integer>>() {

			private static final long serialVersionUID = 6739658684229224595L;

			@Override
			public Optional<Integer> call(List<Integer> values, Optional<Integer> state) throws Exception {
				Integer newValue = 0;
				if (state.isPresent()) {
					newValue = state.get();
				}
				for (Integer value : values) {
					newValue += value;
				}

				return Optional.of(newValue);
			}
		}).foreachRDD(new VoidFunction<JavaPairRDD<String, Integer>>() {

			private static final long serialVersionUID = 1824829383618695238L;

			@Override
			public void call(JavaPairRDD<String, Integer> t) throws Exception {
				t.foreachPartition(new VoidFunction<Iterator<Tuple2<String, Integer>>>() {

					private static final long serialVersionUID = -7675359490340250314L;

					@Override
					public void call(Iterator<Tuple2<String, Integer>> wordCounts) throws Exception {
						Connection conn = ConnectionPool.getConnection();
						Tuple2<String, Integer> wordCount;
						while (wordCounts.hasNext()) {
							wordCount = wordCounts.next();
							Statement stmt = conn.createStatement();
							stmt.executeUpdate("insert into wordcount(word,count) values ('" + wordCount._1 + "'," + wordCount._2 + ")");
						}
						ConnectionPool.returnConnection(conn);
					}
				});
			}
		});

		jsc.start();
		jsc.awaitTermination();
		jsc.close();
	}
}

与Spark SQL结合使用

/**
 * 与Spark SQL整合使用，top3热门商品实时统计
 */
public class Top3HotProduct {

	public static void main(String[] args) throws InterruptedException {
		SparkConf conf = new SparkConf().setMaster("local[*]").setAppName("UpdateStateByKeyWordCount");

		JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(5));

		jsc.checkpoint("hdfs://spark1:9000/checkpoint");

		HashMap<String, String> kafkaParams = new HashMap<String, String>();
		kafkaParams.put("metadata.broker.list", "spark1:9092,spark2:9092,spark3:9092");

		Set<String> topics = new HashSet<String>();
		topics.add("WordCount");

		JavaPairInputDStream<String, String> productClickLogsDStream = KafkaUtils.createDirectStream(jsc, String.class, String.class, StringDecoder.class, StringDecoder.class, kafkaParams, topics);

		productClickLogsDStream.mapToPair(new PairFunction<Tuple2<String, String>, Tuple2<String, String>, Integer>() {

			private static final long serialVersionUID = 1L;

			@Override
			public Tuple2<Tuple2<String, String>, Integer> call(Tuple2<String, String> t) throws Exception {
				String[] productClickLogSplited = t._2.split(" ");
				return new Tuple2<Tuple2<String, String>, Integer>(new Tuple2<String, String>(productClickLogSplited[2], productClickLogSplited[1]), 1);
			}
		}).reduceByKeyAndWindow(new Function2<Integer, Integer, Integer>() {

			private static final long serialVersionUID = 1L;

			@Override
			public Integer call(Integer v1, Integer v2) throws Exception {
				return v1 + v2;
			}
		}, Durations.seconds(60), Durations.seconds(10)).foreachRDD(new VoidFunction<JavaPairRDD<Tuple2<String, String>, Integer>>() {

			private static final long serialVersionUID = -3482150543623000714L;

			@Override
			public void call(JavaPairRDD<Tuple2<String, String>, Integer> t) throws Exception {

				JavaRDD<Row> categoryProductCountRowRDD = t.map(new Function<Tuple2<Tuple2<String, String>, Integer>, Row>() {

					private static final long serialVersionUID = 4064805100943824158L;

					@Override
					public Row call(Tuple2<Tuple2<String, String>, Integer> v1) throws Exception {
						return RowFactory.create(v1._1._1, v1._1._2, v1._2);
					}
				});

				List<StructField> structFields = new ArrayList<StructField>();
				structFields.add(DataTypes.createStructField("category", DataTypes.StringType, true));
				structFields.add(DataTypes.createStructField("product", DataTypes.StringType, true));
				structFields.add(DataTypes.createStructField("click_count", DataTypes.IntegerType, true));

				SparkSession spark = SparkSession.builder().config(categoryProductCountRowRDD.context().conf()).getOrCreate();

				spark.createDataFrame(categoryProductCountRowRDD, DataTypes.createStructType(structFields)).createOrReplaceTempView("product_click_log");

				spark.sql(
						"SELECT category,product,click_count "
						+ "FROM ("
							+ "SELECT "
								+ "category,"
								+ "product,"
								+ "click_count,"
								+ "row_number() OVER (PARTITION BY category ORDER BY click_count DESC) rank "
							+ "FROM product_click_log"  
						+ ") tmp "
						+ "WHERE rank<=3").show();
			}
		});

		jsc.start();
		jsc.awaitTermination();
		jsc.close();
	}
}
焦焦^_^
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark学习笔记：DStream的transformation操作概览
lrxcmwy2的博客
09-16 745
DStream的transformation操作概览 一.Spark Streaming开发步骤 创建输入DStream，如将Flume、Kafka、HDFS和Socket等作为数据源 对输入DStream进行转换操作 对转换后的DStream进行输出操作，比如存储到DBMS中 二.DStream分类 Input DStream，是最原始最初的DStream，它是依据不同的数据源创建的，...
DStream中transform的理解误区与应用
qq_27639777的博客
05-06 2328
文章目录简介理解上的误区transform vs Transformationtransform中有RDD的action操作transform在每个batch批次间隔间被调用实际应用 简介 DStream中的transform操作允许运行任何 RDD-to-RDD 函数。它能够被用来应用任何没在 DStream API 中提供的 RDD 操作。它和DStream其他普通的Transformatio...
Vector - CAPL - CAN消息自动化设置
车载网络测试
05-15 1182
CAPL对于CAN&CANFD报文的设置、检查、发送等控制函数介绍
【CANoe之CAPL基础学习_函数用法2】
最新发布
汽车控制器系统开发、Vil测试、Hil测试、Mil测试、EMS电喷系统标定与开发、热管理系统标定
08-13 867
【CAPL】【CANoe之CAPL基础学习_函数用法】
带你玩转车载测试——CAPL入门篇五：CAPL常用库函数介绍（一）
靓仔小哥
07-24 1981
（2）向CAN总线输出错误帧，可以采用output和canOutputErrorFrame函数，同时可以通过canGetErrorFrameCount函数来返回CAN通道的总错误帧数量。如：当按下按键‘a’时，CAN控制器复位；（1）canGetBusLoad：返回CAN通道的负载率百分比，如下图1所示：当按下按键‘a’时，write窗口输出当前的总线负载率；（4）output函数不仅可以向总线发送错误帧，还能发送任意报文，如下图3所示：当定时器触发后，报文0x100被发送到总线上；
Spark（23）：SparkStreaming之DStream转换
yang_shibiao的博客
07-13 330
DStream 上的操作与 RDD 的类似，分为 Transformations（转换）和 Output Operations（输出）两种，此外转换操作中还有一些比较特殊的原语，如：updateStateByKey()、transform()以及各种 Window 相关的原语。
Spark Streaming入门 - 数据处理api - transformToPair
小哇
04-28 365
大白话理解：每个流式的Dstream，其实底层也是通过rdd来操作，transform就是将Dstream转成rdd，就可以和其他的普通的rdd做各种运算操作1 新建zidian.txt文件 24##少林寺欲将功夫融入足球培训运动员 25##北京警方捣毁侵害公民信息团伙抓获299人 26##北京发布雷电黄色预警傍晚至夜间将有大到暴雨 27##聚划算成清仓专用问题产品充斥 28##七夕前夜英仙座流星雨助兴我国处于最佳观测区 30##报告称中国取代英国成世界第5大常规武器出口国 2在158.158.4..
HBase-SparkStreaming:从HBase表读取并写入HBase表的简单Spark Streaming项目
05-13
HBase-SparkStreaming 从HBase表读取并写入HBase表的简单Spark Streaming项目 #Prereqs运行 创建一个要写入的hbase表：a）启动hbase shell $ hbase shell b）创建表create'/ user / chanumolu / sensor'，{NAME =>'...
SparkStreaming：大规模流式数据处理的新贵
02-26
本文阐释了SparkStreaming的架构及编程模型，并结合实践对其核心技术进行了深入的剖析，给出了具体的应用场景及优化方案。提到SparkStreaming，我们不得不说一下BDAS（BerkeleyDataAnalyticsStack），这个伯克利大学...
SparkStreaming:https的代码
04-28
SparkStreaming 运行集群 ./sbin/start-master.sh 运行工作进程 ./bin/spark-class org.apache.spark.deploy.worker.Worker spark://linuxmint-virtual-machine:7077 --cores 4 --memory 2G 运行TCP服务器 java -cp...
【SparkStreaming篇02】SparkStreaming之Dstream创建1
08-04
通过SparkStream创建Dstream，计算WordCount代码实现//1.初始化Spark配置信息val conf = new SparkConf()
Spark Streaming（三）：DStream的transformation操作
liuxiangke0210的专栏
11-01 416
收藏链接：https://www.jb51.net/article/163065.htm 1、updateStateByKey 作用 可以让我们为每个key维护一份state，并持续不断的更新该state； 使用 1、首先，要定义一个state，可以是任意的数据类型； 2、其次，要定义state更新函数——指定一个函数如何使用之前state和新值来更新state； ...
Transform算子-使用Java开发
扛着锄头的码农
05-13 260
Transform算子-使用Java开发 Logger.getLogger("org").setLevel(Level.WARN); SparkConf conf = new SparkConf(); conf.setMaster("local[2]").setAppName("WordBlock"); JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(
【Spark】Spark Streaming（二）—— DStream Transformation操作
beautiful_huang的博客
03-24 229
本节主要内容 本节部分内容来自官方文档：http://spark.apache.org/docs/latest/streaming-programming-guide.html DStream Transformation操作 1. Transformation操作 Transformation Meaning map(func) 对DStream中的各个元素进...
sparkStreaming之transform的细节
weixin_42307036的博客
12-30 3860
val socketLineDStream: ReceiverInputDStream[String] = streamingContext.socketTextStream('linux1', 8888) // TODO Driver中执行一次 // 例如val a = 1 在Driver中只执行一次 // 首先看一下DStream的其他Transformations（转换）操作 socketLineDStream.map({ case x => { // TODO Exec
CAN总线error frame
抬头仰望天空，低头脚踏实地
06-10 3904
出现error frame的情况有以下几种： √ 位错误（Bit Check Error） 发送器在发送比特流的同时也对发出的比特流采样回收，若送出的bit与所期待的bit不合，则会检测到一个Bit Check Error； √ 位填充错误（Bit Stuff Error） 在需要执行位编码规则的位流序列中检测到第6个连续的极性相同的位序流时，则检测到一个Bit Stuff Error； √ CRC 错误（CRC Error） 发送端送出的CRC序...
第一章：Spark Streaming 实时计算
08-17
1.Spark Streaming：大数据实时计算介绍2.Spark Streaming：DStream基本工作原理3.Spark Streaming：StreamingContext详解技能点4.Spark Streaming：输入DStream和Receiver详解5.Spark Streaming：DStream的transformation操作概览
Spark修炼之道（进阶篇）——Spark入门到精通：第十一节 Spark Streaming—— DStream Transformation操作...
weixin_34378922的博客
11-25 175
本节主要内容 本节部分内容来自官方文档：http://spark.apache.org/docs/latest/streaming-programming-guide.html DStream Transformation操作 1. Transformation操作 Transformation Meaning ...
Spark之SparkStreaming案例-transform
chbxw
05-03 8991
Transform 操作transform操作允许将任意RDD到RDD函数应用于DStream。 它可用于应用任何未在DStream API中公开的RDD操作。 例如，将数据流中的每个批处理与其他数据集相结合的功能不会直接暴露在DStream API中。 但是，您可以轻松地使用transform来执行此操作。 这使得非常强大的可能性。 例如，可以通过将输入数据流与预先计算的垃圾信息（也可以用Spar
4.spark streaming：实时wordcount程序开发
04-06
Spark Streaming是一个可以对实时数据进行流处理的框架。实时处理是指对在流中不断生成的数据进行即时处理和分析，将所需的信息提取出来。在Spark Streaming中，可以通过类似于批处理的方式对实时数据进行处理和分析...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值