Spark Streaming编程实例

最新推荐文章于 2022-08-23 19:20:50 发布
最新推荐文章于 2022-08-23 19:20:50 发布
阅读量271 收藏
点赞数
文章标签： hadoop spark flume
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wAwT13zA/article/details/108126664
版权
pom文件
<?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-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wang</groupId>
    <artifactId>spark_streaming</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <encoding>UTF-8</encoding>
        <scala.version>2.11.8</scala.version>
        <spark.version>2.2.0</spark.version>
        <hadoop.version>2.7.1</hadoop.version>
        <scala.compat.version>2.11</scala.compat.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-flume_2.11</artifactId>
            <version>2.2.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-kafka-0-10_2.11</artifactId>
            <version>2.2.0</version>
        </dependency>



    </dependencies>
    <build>
        <sourceDirectory>src/main/scala</sourceDirectory>
        <!--<testSourceDirectory>src/test/scala</testSourceDirectory>-->
        <plugins>
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.2.2</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                        <configuration>
                            <args>
                                <arg>-dependencyfile</arg>
                                <arg>${project.build.directory}/.scala_dependencies</arg>
                            </args>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.4.3</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <filters>
                                <filter><artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                            <transformers>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass></mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>


</project>
案例一：使用Spark Streaming统计HDFS文件的词频
package com.wang.mytest

import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.DStream
import org.apache.spark.streaming.{Seconds, StreamingContext}

object HDFSInputDstreamDemo extends App {
  private val conf: SparkConf = new SparkConf().setMaster("local[2]").setAppName("test01")
  private val ssc = new StreamingContext(conf,Seconds(5))

  private val lines: DStream[String] = ssc.textFileStream("hdfs://hadoop1:9000/data")
  private val wordcounts: DStream[(String, Int)] = lines.flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_)
  wordcounts.print()

  ssc.start()
  ssc.awaitTermination()

}

从linux传入数据hdfs dfs -put courses.txt /data/，数据如下

hadoop hdfs mapreduce hbase hive zookeeper
spark spark core spark sql spark ml spark streaming
redis mongodb cassandra 
mysql oracle
python java shell linux

结果：

-------------------------------------------
Time: 1597912120000 ms
-------------------------------------------
(hive,1)
(python,1)
(cassandra,1)
(mapreduce,1)
(zookeeper,1)
(mysql,1)
(oracle,1)
(mongodb,1)
(linux,1)
(java,1)
...
案例二：使用Spark Streaming处理带状态的数据

需求：计算到目前为止累计词频的个数
分析：DStream转换操作包括无状态转换和有状态转换
无状态转换：每个批次的处理不依赖于之前批次的数据
有状态转换：当前批次的处理需要使用之前批次的数据
updateStateByKey属于有状态转换，可以跟踪状态的变化
实现要点
定义状态：状态数据可以是任意类型
定义状态更新函数：参数为数据流之前的状态和新的数据流数据

package com.wang.mytest

import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.{Seconds, StreamingContext}

object UpdateStateByKeyDemo extends App {
  private val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("test02")
  private val ssc = new StreamingContext(conf,Seconds(5))

  private val input: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop1",44444)
  private val resl: DStream[(String, Int)] = input.flatMap(_.split(" ")).map((_,1))
	//做一个checkpoint检查点，负责检查之前的结果，放入缓存
  ssc.checkpoint("src\\data\\ck1")
	
  def updateFunc(currentValue:Seq[Int],preValue:Option[Int]) = {
    val currsum:Int = currentValue.sum
    val pre:Int = preValue.getOrElse(0)
    Some(currsum+pre)
  }

//updateStateByKey 可以跟踪状态的变化
  private val state: DStream[(String, Int)] = resl.updateStateByKey(updateFunc)
  state.print()

  ssc.start()
  ssc.awaitTermination()
}

结果：

(spark,2)
(world,1)
(hello,4)
(test,1)
案例三：Spark Streaming整合Spark SQL

需求：使用Spark Streaming +Spark SQL完成WordCount
分析：将每个RDD转换为DataFrame

package com.wang.mytest

import org.apache.spark.SparkConf
import org.apache.spark.sql.SparkSession
import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
import org.apache.spark.streaming.{Seconds, StreamingContext}

object SparkSQLSparkStreamingDemo extends App {
  private val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("test03")
  private val ssc = new StreamingContext(conf,Seconds(5))
  private val spark: SparkSession = SparkSession.builder().config(conf).getOrCreate()
  private val inputDstream: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop1",9999)
  val wordDstream = inputDstream.flatMap(_.split(" "))
  import spark.implicits._

  wordDstream.foreachRDD(
    rdd => {
      if (rdd.count()!=0) {
        val df1 = rdd.map(x=>WordCount(x)).toDF()
        df1.createOrReplaceTempView("tb_word")
        spark.sql(
          """
            |select name,count(*) from tb_word group by name
          """.stripMargin
        ).show()
      }
    }
  )
  ssc.start()
  ssc.awaitTermination()

}

case class WordCount(name:String)

数据

hello test hello spark

结果

+-----+--------+
| name|count(1)|
+-----+--------+
|hello|       2|
|spark|       1|
| test|       1|
+-----+--------+
案例四：Spark Streaming整合Flume

方式一：flume的sink使用avro来给spark stream推送数据

  1. 编写
package com.wang.mytest

import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.ReceiverInputDStream
import org.apache.spark.streaming.flume.{FlumeUtils, SparkFlumeEvent}
import org.apache.spark.streaming.{Seconds, StreamingContext}

object SparkFlumePushDemo extends App {
  private val conf: SparkConf = new SparkConf().setMaster("local[2]").setAppName("flumeDemo01")
  private val ssc = new StreamingContext(conf,Seconds(5))

  private val flumeStream: ReceiverInputDStream[SparkFlumeEvent] = 
  //使用FlumeUtils.createStream来接受avroSink push的数据
  FlumeUtils.createStream(ssc,"hadoop1",55555)
  flumeStream.map(x=>new String(x.event.getBody.array()).trim)
    .flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).print()
  ssc.start()
  ssc.awaitTermination()
}

打胖包，将jar包放到linux中（随便放哪）
在这里插入图片描述
编写flume的conf文件
vi stream-flume.conf

a1.sources = s1
a1.channels = c1
a1.sinks = k1

a1.sources.s1.type = netcat
a1.sources.s1.bind = hadoop1
a1.sources.s1.port = 44444
a1.sources.s1.channels = c1

a1.channels.c1.type = memory
a1.channels.c1.capacity = 1000

# AvroSink向Spark(55555)推送数据
# 使用push  createStream
a1.sinks.k1.type = avro
a1.sinks.k1.hostname = hadoop1
a1.sinks.k1.port = 55555
a1.sinks.k1.channel = c1

启动flume

flume-ng agent --name a1 --conf conf/ --conf-file /opt/soft/flume160/conf/job/stream-flume.conf -Dflume.root.logger=INFO,console

再运行上传的spark jar包

spark-submit --class com.wang.mytest.SparkFlumePushDemo /data/jar/spark_streaming-1.0-SNAPSHOT.jar

再启动telnet

telnet hadoop1 44444

方式二：flume的sink类型使用sparktraming的jar包
idea需要导入依赖：

<dependency>
     <groupId>org.apache.spark</groupId>
     <artifactId>spark-streaming-flume_2.11</artifactId>
     <version>2.2.0</version>
</dependency>

如果linux中的flume版本低，将以下3个jar包导入到flume的lib目录下，并删除对应的低版本的jar包
在这里插入图片描述
相关jar包下载
链接: https://pan.baidu.com/s/1ii9Y-ypTX-cYCOb3tuOXXw 提取码: ubxc

package com.wang.spark_streaming

import org.apache.spark.SparkConf

import org.apache.spark.streaming.dstream.ReceiverInputDStream
import org.apache.spark.streaming.flume.{FlumeUtils, SparkFlumeEvent}
import org.apache.spark.streaming.{Seconds, StreamingContext}

object SparkFlumePollDmeo extends App {
  private val conf: SparkConf = new SparkConf().setMaster("local[2]").setAppName("flumeDemo01")
  private val ssc = new StreamingContext(conf,Seconds(5))
//使用createPollingStream方法spark streaming从kafka中拉去数据
  private val flumePollStream: ReceiverInputDStream[SparkFlumeEvent] = FlumeUtils
    .createPollingStream(ssc,"hadoop1",56789)
  flumePollStream.map(x=>new String(x.event.getBody.array()).trim)
    .flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).print()

  ssc.start()
  ssc.awaitTermination()

}

agent.sources = s1
agent.channels = c1
agent.sinks = sk1

# 设置Source的类型为netcat，使用的channel为c1
agent.sources.s1.type = netcat
agent.sources.s1.bind = 192.168.108.181
agent.sources.s1.port = 44444
agent.sources.s1.channels = c1


agent.channels.c1.type = memory
agent.channels.c1.capacity = 1000


# AvroSink向Spark(55555)推送数据
# 使用push  createStream
agent.sinks.sk1.type=org.apache.spark.streaming.flume.sink.SparkSink
agent.sinks.sk1.hostname=192.168.108.181
agent.sinks.sk1.port=56789
agent.sinks.sk1.channel = c1

打jar包，将jar包放入linux中
启动flume

flume-ng agent --name a1 --conf conf/ --conf-file /opt/soft/flume160/conf/job/stream-flume-jar.conf -Dflume.root.logger=INFO,console

再运行上传的spark jar包

spark-submit --class com.wang.mytest.SparkFlumePollDemo /data/jar/spark_streaming-1.0-SNAPSHOT.jar

再启动telnet

telnet hadoop1 44444
案例五：Spark Streaming整合Kafka（streaming从kafka中读数据）
package com.wang.mytest


import org.apache.kafka.clients.consumer.{ConsumerConfig, ConsumerRecord}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.InputDStream
import org.apache.spark.streaming.kafka010.{ConsumerStrategies, KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.{Seconds, StreamingContext}

object SparkKafkaDirectDemo extends App {
  private val conf: SparkConf = new SparkConf().setAppName("SparkKafkaDirectDemo").setMaster("local[*]")
  private val ssc = new StreamingContext(conf,Seconds(5))
  // streaming当作消费者，所以要需要配置 StringDeserializer反序列化、GROUP_ID_CONFIG
  val kafkaParams = Map(
    (ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG->"hadoop1:9092"),
    ("key.deserializer"->"org.apache.kafka.common.serialization.StringDeserializer"),
    ("value.deserializer"-> "org.apache.kafka.common.serialization.StringDeserializer"),
    (ConsumerConfig.GROUP_ID_CONFIG -> "testGroup")
  )
  private val message: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(ssc,
    LocationStrategies.PreferConsistent,
    ConsumerStrategies.Subscribe(Set("kb07demo"), kafkaParams)
  )
  message.map(x=>x.value()).flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).print()
  ssc.start()
  ssc.awaitTermination()

}
Messi的小迷弟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spark修炼之道（进阶篇）——Spark入门到精通：第十节 Spark Streaming（一)
摇摆少年梦的技术博客
11-21 1万+
本节主要内容本节部分内容来自官方文档：http://spark.apache.org/docs/latest/streaming-programming-guide.html#mllib-operations Spark流式计算简介 Spark Streaming相关核心类 入门案例 1. Spark流式计算简介Hadoop的MapReduce及Spark SQL等只能进行离线计算，无法满足实时性要
java sparkstreaming_sparkstreaming原理
weixin_34902502的博客
03-04 358
Spark Streaming是Spark生态系统当中一个重要的框架，它建立在Spark Core之上，下面这幅图也可以看出Sparking Streaming在Spark生态系统中地位。 Spark Streaming是Spark Core的扩展应用，它具有可扩展，高吞吐量，对于流数据的可容错性等特点。可以监控来自Kafka,Flume,HDFS。Kinesis,Twitter，ZeroMQ或者...
SparkStreaming 架构及案例实现
EdwardWang_的博客
06-11 2102
一、概述Spark Streaming类似于Apache Storm，用于流式数据的处理。根据其官方文档介绍，Spark Streaming有高吞吐量和容错能力强等特点。Spark Streaming支持的数据输入源很多，例如：Kafka、Flume、Twitter、ZeroMQ和简单的TCP套接字等等。数据输入后可以用Spark的高度抽象原语如：map、reduc...
Spark Streaming 进阶与案例实战
唯二
10-29 202
Spark Streaming 进阶与案例实战 Spark Streaming 进阶与案例实战 1.带状态的算子: UpdateStateByKey 2.实战：计算到目前位置累积出现的单词个数写入到MySql中 1.create table CREATE TABLE `wordcount` ( `word` VARCHAR(50) NO...
Spark Streaming应用与实战全攻略（Ⅰ）
imgxr的博客
06-15 1834
作者：小小默，开源爱好者，关注Hadoop/Spark、机器学习、人工智能等相关技术。更多精彩欢迎关注作者个人博客。 Spark Streaming应用与实战系列包括以下六部分内容： 背景与架构改造 通过代码实现具体细节，并运行项目 对Streaming监控的介绍以及解决实际问题 对项目做压测与相关的优化 Streaming持续优化之HBase 管理Streaming任务 本篇为第一部分，包...
Spark Streaming编程实战（开发实例）
01-07
本节介绍如何编写 Spark Streaming 应用程序，由简到难讲解使用几个核心概念来解决实际应用问题。 流数据模拟器 在实例演示中模拟实际情况，需要源源不断地接入流数据，为了在演示过程中更接近真实环境，首先需要...
Spark Streaming 示例
04-03
`SparkStreaming.zip` 文件可能包含了一个示例项目，演示了如何创建一个 Spark Streaming 应用来从 Kafka 消费数据。代码通常会包含以下步骤： 1. 创建 SparkConf 对象，配置 Spark 应用的属性，如应用程序名称、...
大数据技术原理及应用课实验7 :Spark初级编程实践
最新发布
01-16
在这里，`sc`是SparkContext的实例，是Spark与集群交互的入口。 其次，Spark应用程序的编写通常使用Scala、Java、Python或R语言。在实验中，推荐使用Scala编写独立的应用程序，这需要对Spark的API有一定的了解。...
Spark源码系列（八）SparkStreaming实例分析
01-30
这一章要讲SparkStreaming，讲之前首先回顾下它的用法，具体用法请参照《Spark Streaming编程指南》。1、首先实例化一个StreamingContext2、调用StreamingContext的socketTextStream3、对获得的DStream进行处理4、...
Spark Streaming实时流处理项目实战.rar.rar
06-22
本项目实战旨在帮助读者深入理解和应用Spark Streaming，通过实际操作来掌握其核心概念、架构以及编程模型。 在Spark Streaming中，数据流被划分为一系列的小批量（称为DStreams，即Discretized Streams），这些小...
SparkStreaming整合Kafka
小东升职记
01-15 291
&lt;properties&gt; &lt;maven.compiler.source&gt;1.7&lt;/maven.compiler.source&gt; &lt;maven.compiler.target&gt;1.7&lt;/maven.compiler.target&gt; &lt;encoding&gt;UTF-8&lt;/en...
spark-streaming使用spark-ML模型实时预测
qq_14950717的博客
05-26 1787
不得不说Spark是一款优秀的计算引擎，继承Spark-ML、Spark-Graphx机器学习和图计算框架，Spark-ML一般用于离线分析和挖掘，生成模型。 如果我们把模型保存在HDFS，需要在实时计算里面使用提前训练好的模型， 解决方案如下： 1、通过转换序列化方式，把模型转换成可以被其他语言调用的方式，如：java、python 2、在spark-streaming中使用 具体读取kafak的配置信息和保证EOS的不在这里体现，主要体现如何使用Spark-ML训练好的模型，具体代码如下： val sp
Spark Streaming示例(scala篇)
weixin_42163700的博客
06-21 3399
本段代码运行于Intellij IDEA中,与linux 中nc进行交互1.Scala代码:import org.apache.spark.SparkConfimport org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}import org.apache.spark.streaming.{Seconds, Stre...
java sparkstreaming_Spark Streaming编程-java版
weixin_32060671的博客
02-13 423
目录介绍StreamingContext：核心概念1官方文档：带领着进入Spark Streaming的开发http://spark.apache.org/docs/latest/streaming-programming-guide.html#initializing-streamingcontextDiscretized(离散化) Streams(DStreams)：核心概念2对DStream...
Spark消费Kafka的两种方式
06-11 6077
在这里插入代码片
Java-Spark系列8-Spark streaming整合Kafka
热门推荐
只是甲的博客
09-30 1万+
文章目录一. Spark streaming整合Kafka概述1.1 Maven配置1.2 创建Direct Stream1.3 定位策略1.4 消费者的策略1.5 创建RDD1.6 获得Offsets1.7 存储 Offsets1.8 检查点1.9 Kafka自身1.10 自身数据存储二.Spark Streaming整合Kafka实战2.1 Maven配置2.2 代码2.3 测试参考: 一. Spark streaming整合Kafka概述 1.1 Maven配置 对于使用SBT/Maven项目定义的S
SparkStreaming Java
weixin_34128839的博客
08-14 467
2019独角兽企业重金招聘Python工程师标准>>> ...
SparkStreaming核心编程
twi_twi的博客
08-23 447
SparkStreaming的初步介绍（和小部分源码探源）
SparkStreaming介绍及开发环境搭建
ZZJXP的博客
05-19 451
<dependency> <groupId>org.apache.spark</groupId> <artifactId>spark-streaming_2.11</artifactId> <version>2.4.5</version> </dependency> package com.shujia.streaming import org.apache.spa...
华为SparkStreaming开发指南与实例解析
本文档是一份由华为技术有限公司发布的"Universe大数据分析平台Streaming开发指导"，主要面向有一定编程基础（特别是Scala和Java），并对大数据处理有兴趣的开发者。它提供了详细的开发示例和教程，旨在帮助读者理解...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值