Spark(十六)【SparkStreaming基本使用】

目录
  • 一. SparkStreaming简介
    • 1. 相关术语
    • 2. SparkStreaming概念
    • 3. SparkStreaming架构
    • 4. 背压机制
  • 二. Dstream入门
    • 1. WordCount案例实操
    • 2. WordCount解析
    • 3. web UI
    • 注意
  • 三. Dstream创建
    • 1. RDD队列(测试使用)
    • 2. 自定义数据源
    • 3. Kafka直连
      • 案例
      • 实现数据零丢失
  • 四. DStream转化 (API)
    • 无状态转化
      • Transform
      • 双流 join
    • 有状态转化(重要)
      • UpdateStateByKey
      • WindowOperations 窗口
      • window窗口
  • 五. 程序优雅关闭

一. SparkStreaming简介

1. 相关术语

流式数据: 指数据源源不断。

实时数据: 当前正在产生的数据。

离线数据: 过去(不是当下产生的)已经产生的数据。

实时计算: 理想上,实时计算一定是对实时数据的计算,理想期望立刻当前计算出结果(要在公司规定的时效范围内)。

离线计算: 计算通常需要划分一段时间。

总结:离线计算和实时计算主要通过计算的时效性进行区分,实时在不同的公司,有相对参考的标准。

2. SparkStreaming概念

SparkStreaming可以用来进行实时计算,Spark Streaming用于流式数据的处理,但是SparkStreaming是一个准(接近)实时计算的框架。

SparkStreaming在进行实时计算时,采用的是微批次(区别于流式)计算。

使用DStream作为最基本的数据抽象。DStream会将一段时间采集到的数据,封装为一个RDD进行计算处理。

3. SparkStreaming架构

Spark(十六)【SparkStreaming基本使用】_第1张图片

SparkStreaming程序在架构上整体分为两块

​ 数据接受模块: 启动一个Excutor运行Reciever程序,Reciever程序会将指定时间间隔收到的一批数据,进行存储,存储后,将这批数据的id,发送给Driver。

​ 数据处理模块(Driver): Driver端有RecieverTracer,不断接受 Reciever发送的已经收到的一批数据的ID,之后,通过JobGenerator,将这批数据,提交为一个Job,提交Job后,会启动Excutor运算这批数据。这批数据在运算时,会有Reciever所在的Excutor发送过来,运行结束后将结果返回给Driver。

4. 背压机制

Spark Streaming可以动态控制数据接收速率来适配集群数据处理能力。

背压机制(即Spark Streaming Backpressure): 根据JobScheduler反馈作业的执行信息来动态调整Receiver数据接收率。

把spark.streaming.backpressure.enabled 参数设置为ture,开启背压机制后Spark Streaming会根据延迟动态去kafka消费数据,上限由spark.streaming.kafka.maxRatePerPartition参数控制,所以两个参数一般会一起使用。

二. Dstream入门

1. WordCount案例实操

需求:使用netcat工具向9999端口不断的发送数据,通过SparkStreaming读取端口数据并统计不同单词出现的次数。

① 添加pom依赖


    org.apache.spark
    spark-streaming_2.12
    3.0.0

② 代码实现

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

/**
 * @description: WordCount入门案例
 * @author: HaoWu
 * @create: 2020年08月10日
 */
object WordCountTest {
  def main(args: Array[String]): Unit = {

    //1.初始化Spark配置信息
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("StreamWordCount")

    //2.初始化SparkStreamingContext,3秒统计一次,可以设置多个级别:Milliseconds,Seconds,Minutes
    val ssc = new StreamingContext(sparkConf, Seconds(3))

    //3.通过监控端口创建DStream,读进来的数据为一行行
    val lineStreams = ssc.socketTextStream("hadoop102", 9999)
    //4.处理DStream
    //将每一行数据做切分,形成一个个单词
    val wordStreams = lineStreams.flatMap(_.split(" "))

    //将单词映射成元组(word,1)
    val wordAndOneStreams = wordStreams.map((_, 1))

    //将相同的单词次数做统计
    val wordAndCountStreams = wordAndOneStreams.reduceByKey(_+_)

    //打印
    wordAndCountStreams.print()
     
    //5.启动SparkStreamingContext
    ssc.start()
    ssc.awaitTermination()
  }
}

③在hadoop102节点启动nc工具发送数据,同时启动SparkStreaming程序

nc -lk hadoop102 9999

结果

-------------------------------------------
Time: 1597053684000 ms
-------------------------------------------
(,1)
(as,1)
(fdaf,1)
(sa,1)

-------------------------------------------
Time: 1597053686000 ms
-------------------------------------------

-------------------------------------------
Time: 1597053688000 ms
-------------------------------------------

2. WordCount解析

Discretized Stream是Spark Streaming的基础抽象,代表持续性的数据流和经过各种Spark原语操作后的结果数据流。在内部实现上,DStream是一系列连续的RDD来表示。每个RDD含有一段时间间隔内的数据。

Spark(十六)【SparkStreaming基本使用】_第2张图片

3. web UI

Spark(十六)【SparkStreaming基本使用】_第3张图片

注意

SparkStream程序运行要启动两个线程,最少需要2个CPU,不然程序无法启动。
Receiver、Driver各启动一个excupu。本地测试的设置为“local[*]

三. Dstream创建

1. RDD队列(测试使用)

测试过程中,可以通过使用ssc.queueStream(queueOfRDDs)来创建DStream,每一个推送到这个队列中的RDD,都会作为一个DStream处理,测试使用验证数据处理的逻辑

需求:循环创建几个RDD,将RDD放入队列。通过SparkStream创建Dstream,计算WordCount。

queueStream函数签名

 def queueStream[T: ClassTag](
      queue: Queue[RDD[T]],   // 传入的队列
      oneAtATime: Boolean,  // 在一个周期内,是否只允许采集一个RDD
      defaultRDD: RDD[T]  // 队列空了时,是否返回一个默认的RDD,可以设置为null,不返回
    ): InputDStream[T] = {
    new QueueInputDStream(this, queue, oneAtATime, defaultRDD)
  }
import org.apache.spark.SparkConf
import org.apache.spark.rdd.RDD
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.{Seconds, StreamingContext}
import scala.collection.mutable
/**
 * @description: RDD队列创建DStream
 * @author: HaoWu
 * @create: 2020年08月10日
 */
object WordCountSeqTest {
  def main(args: Array[String]): Unit = {
    //1.创建SparkStreamingContext
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDDSeqApp")
    val ssc: StreamingContext = new StreamingContext(conf, Seconds(2))
    //2.创建可变RDD队列
    val que: mutable.Queue[RDD[String]] = new mutable.Queue[RDD[String]]()
    //3.创建DStream
    val dStream: InputDStream[String] = ssc.queueStream(que, oneAtATime = false)
    //4.DStream的逻辑处理
    val result: DStream[(String, Int)] = dStream.flatMap(_.split(",")).map((_, 1)).reduceByKey(_ + _)
    //5.打印
    result.print(100)
    //6.运行程序
    ssc.start()
    val rdd = ssc.sparkContext.makeRDD(List("sada", "dafa", "adfafa", "fafda"))
    //7.往队列中每一秒添加一个RDD
    println("Start启动.....")
    for (i <- 1 to 10) {
      que.+=(rdd)
      Thread.sleep(1000)
    }
    ssc.awaitTermination()
  }
}

结果

Start启动
-------------------------------------------
Time: 1597055400000 ms
-------------------------------------------
(dafa,1)
(fafda,1)
(adfafa,1)
(sada,1)

-------------------------------------------
Time: 1597055402000 ms
-------------------------------------------
(dafa,2)
(fafda,2)
(adfafa,2)
(sada,2)

2. 自定义数据源

使用:需要继承Receiver,并实现onStart、onStop方法来自定义数据源采集。

继承Receiver

/*
	StorageLevel: 数据存储的级别!存内存,还是存磁盘等!
    T: 每次收的数据的类型
*/
abstract class Receiver[T](val storageLevel: StorageLevel) extends Serializable

实现onStart方法

在收数据之前,运行一些指定的安装操作

def onStart() {
	//1.在收数据时,onStart()不能被阻塞!
	//2.必须新开启一个线程收数据!
	//3.收到数据后,可以调用store()来存储数据!
      }

实现Onstop方法

在停止接收数据之前,清理组件

注意:在发生异常时,可以调用restart()重启接收器,还可以调用stop()彻底停止收数据

需求:自定义数据源,实现监控某个端口号,获取该端口号内容。

代码

import java.io.{BufferedInputStream, BufferedReader, InputStreamReader}
import java.net.Socket
import org.apache.spark.storage.StorageLevel
import org.apache.spark.streaming.receiver.Receiver


class MyCustomReceiver(var hostname: String, var port: Int) extends Receiver[String](StorageLevel.MEMORY_ONLY) {
  var socket: Socket = null
  var reader: BufferedReader = null

  /**
   * 重写onStart方法
   */
  override def onStart(): Unit = {
    //异常处理
    try {
      socket = new Socket(hostname, port)
    } catch {
      case e: ConnectException => {
        restart("重试~~~~");
        return
      }
    }
    println("Socket已经连接上~~~~~")
    //获取reader
    reader = new BufferedReader(new InputStreamReader(socket.getInputStream))
    //开始接收数据
    recevie()
  }

  /**
   * 新建一个线程接收数据
   */
  def recevie(): Unit = {
    new Thread("Socket Receiver ThreadName") {
      //设置当前线程为守护线程    当前线程依附于 Receiver所在的main线程!
      // 如果一个JVM中,只有守护线程,JVM就会关闭!
      setDaemon(true)
      override def run(): Unit = {
        //异常处理
        try {
          println("开始接收:" + hostname + ":" + port + "  的数据")
          var line = reader.readLine()
          while (socket != null && line != null) {
            //存储数据
            store(line)
            line = reader.readLine()
          }
        } catch {
          case e: Exception => e.getMessage
        } finally {
          onStop();
          restart("重启Receiver~~~")
        }

      }
    }.start()
  }

  /**
   * 关闭资源
   */
  override def onStop(): Unit = {
    if (socket != null) {
      socket.close()
      socket = null
    }

    if (reader != null) {
      reader.close()
      reader = null
    }
  }
}

测试

object CostumReceiver extends {
  def main(args: Array[String]): Unit = {
   val conf = new SparkConf().setMaster("local[*]").setAppName("CostumReceive")
    val ssc: StreamingContext = new StreamingContext(conf,Seconds(2))
    //创建自定义Receiver
    val receiver: CostumeReceiver = new CostumeReceiver("hadoop102",9999)
    //创建DStream
    val dStream: ReceiverInputDStream[String] = ssc.receiverStream(receiver)
    val result = dStream.flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_)
    result.print(100)
    ssc.start()
    ssc.awaitTermination()
  }
}

3. Kafka直连

好处

由Excutor直接去Kafka读取数据,减少数据的网络IO传输!

Reciver只需要将一个采集周期采集的数据的元数据信息,发送给Excutor即可!

案例

pom依赖


     org.apache.spark
     spark-streaming-kafka-0-10_2.12
     3.0.0


    com.fasterxml.jackson.core
    jackson-core
    2.10.1


代码

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

/**
 * @description: SparkStreaming直连消费Kafka数据
 * @author: HaoWu
 * @create: 2020年08月10日
 */
object SparkStreamingKafkaTest {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("CostumReceive")
    val ssc: StreamingContext = new StreamingContext(conf, Seconds(2))
    //设置消费kafka的参数,可以参考kafka.consumer.ConsumerConfig类中配置说明
    val kafkaParams: Map[String, Object] = Map[String, Object](
      "bootstrap.servers" -> "hadoop102:9092,hadoop103:9092,hadoop104:9092", //zookeeper的host,port
      "group.id" -> "g3", //消费者组
      "enable.auto.commit" -> "true", //是否自动提交
      "auto.commit.interval.ms" -> "500", //500ms自动提交offset
      "key.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
      "value.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
      "auto.offset.reset" -> "earliest"//第一次运行,从最初始偏移量开始消费数据
    )

    //使用工具类创建DStream,消费topic test1的数据
    val ds: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream[String, String](
      ssc,
      LocationStrategies.PreferConsistent,
      //订阅主题
      ConsumerStrategies.Subscribe[String, String](List("test1"),
        kafkaParams))

    //逻辑处理
    val result: DStream[(String, Int)] = ds.flatMap(record => record.value().split(" ")).map((_, 1)).reduceByKey(_ + _)
    result.print(100)
    //运行程序
    ssc.start()
    ssc.awaitTermination()
  }
}

测试

启动zk集群,kafka集群,向test1主题添加数据

[root@hadoop102 kafka]$ bin/kafka-console-producer.sh --broker-list hadoop102:9092 --topic test1
>fasdf a
>asf as
>asf sa
实现数据零丢失

spark官网:sparkstreaming集成kafka

方法一:checkpoint实现

①取消基于时间的自动提交,改为手动提交

②在消费逻辑真正执行完后,再手动提交

Spark在手动取消offset提交后,允许设置一个checkpoint目录,在程序崩溃之前,可以将崩溃时,程序的状态(包含offset)保存到目录中!

在程序重启后,可以选择重建状态!保证从之前未消费的位置继续消费

缺点:小文件,重建会启动很多没用的任务

代码实现

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

/**
 * @description: 保证数据不丢失
 * @author: HaoWu
 * @create: 2020年08月10日
 */
object KafkaTest {
  def main(args: Array[String]): Unit = {
    /**
     *  程序异常重建SparkStreamingContext
     */
    def rebuild(): StreamingContext = {
      val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("My app")
      val ssc: StreamingContext = new StreamingContext(conf, Seconds(2))
      //设置checkpoint目录
      ssc.checkpoint("kafka")
      //TODO 消费参数配置
      val kafkaParams: Map[String, Object] = Map[String, Object](
        "bootstrap.servers" -> "hadoop102:9092",
        //      "client.id" -> "c4",
        "group.id" -> "g1",
        "enable.auto.commit" -> "false",
        "auto.commit.interval.ms" -> "500",
        "key.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
        "value.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
        "auto.offset.reset" -> "earliest"
      )
      //TODO 消费数据穿建 DStream
      val ds: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream[String, String](
        ssc,
        LocationStrategies.PreferConsistent,
        ConsumerStrategies.Subscribe[String, String](List("test1"),
          kafkaParams))
      //TODO 消费逻辑
      val ds1: DStream[String] = ds.flatMap(record => record.value().split(" "))
      //模拟消费异常
      val result: DStream[(String, Int)] = ds1.map(x => {
//        if (x == "d") {
//          throw new UnknownError("程序异常~~~~~~~~~")
//        }
        (x, 1)
      }).reduceByKey(_ + _)
      //打印
      result.print(100)
      ssc
    }
    
    // 重建context  防止进程崩溃,进程崩溃后,重建程序
    val ssc: StreamingContext = StreamingContext.getActiveOrCreate("kafka", rebuild)
    //运行程序
    ssc.start()
    ssc.awaitTermination()
  }
}

方法二:手动提交offset

不丢数据,可能数据重复

四. DStream转化 (API)

无状态转化:每个批次单独处理自己批次中的的RDD。

有状态转化:跨批次之间的转化,当前批次的RDD计算需要和之前的批次的结果做累加。

无状态转化

reduceByKey:只针对单个批次的RDD做转化。

map:RDD的map操作

Transform

将当前批次的RDD[T] => RDD[U]

def transform[U: ClassTag](transformFunc: RDD[T] => RDD[U]): DStream[U] = 
    //转换为RDD操作
    val ds1: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop102", 9999)
    //4.处理DStream
    val ds2: DStream[(String, Int)] = ds1.transform(rdd => {
      val value: RDD[(String, Int)] = rdd.flatMap(_.split(" ")).map((_, 1))
      value
    })
双流 join

可以实现双流join,实质就是对2个流各个批次的RDD进行join

前提:两个流的批次大小一致,DS中的元素必须是K-V结构,拉链操作

    //3.通过监控端口创建DStream,读进来的数据为一行行
    val ds1: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop102", 9999)
    val ds2: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop103", 8888)
    //4.处理DStream
    val ds11: DStream[(String, Int)] = ds1.flatMap(_.split(" ")).map((_, 1))
    val ds22: DStream[(String, String)] = ds2.flatMap(_.split(" ")).map((_, "aa"))
    //5.双流join
    val result: DStream[(String, (Int, String))] = ds11.join(ds22)
    //打印
    result.print(100)

有状态转化(重要)

UpdateStateByKey

流计算中累加wordcount可以使用这个算子

函数签名

 //Seq[V]:当前批次的相同key的values集合
 //Option[S]:之前批次的结果,可以通过
 def updateStateByKey[S: ClassTag](
      updateFunc: (Seq[V], Option[S]) => Option[S]
    ): DStream[(K, S)] = 

案例:求截止到当前时间单词的个数(wordcount)

/**
 * @description: **UpdateStateByKey**案例
 * @author: HaoWu
 * @create: 2020年08月10日
 */
object NoStatusTest {
  def main(args: Array[String]): Unit = {
    //1.初始化Spark配置信息
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("StreamWordCount")
    //2.初始化SparkStreamingContext,3秒统计一次,可以设置多个级别:Milliseconds,Seconds,Minutes
    val ssc = new StreamingContext(sparkConf, Seconds(3))
    //设置checkpoint,保存状态
    ssc.checkpoint("./updatestate")
    //通过监控端口创建DStream,读进来的数据为一行
    val ds: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop102", 9999)
    //转化为K-V类型
    val ds1: DStream[(String, Int)] = ds.flatMap(_.split(" ")).map((_, 1))
    val result: DStream[(String, Int)] = ds1.updateStateByKey((seq: Seq[Int], option: Option[Int]) => {
      var sum: Int = seq.sum
      val value: Int = option.getOrElse(0)
      sum += value
      Some(sum)
    })
    //打印
    result.print(100)
    //5.启动SparkStreamingContext
    ssc.start()
    ssc.awaitTermination()
  }
}

结果

-------------------------------------------
Time: 1597142208000 ms
-------------------------------------------
(a,7)
(b,3)

-------------------------------------------
Time: 1597142211000 ms
-------------------------------------------
(a,9)
(ab,1)
(b,4)

-------------------------------------------
Time: 1597142214000 ms
-------------------------------------------
(a,10)
(ab,2)
(b,5)

注意

①RDD是K-V

②updateFunc参数里面参数声明泛型[],返回结果用Some包装

③设置checkpoint

WindowOperations 窗口

Window Operations可以设置窗口的大小和滑动窗口的间隔来动态的获取当前Steaming的允许状态。所有基于窗口的操作都需要两个参数,分别为窗口时长以及滑动步长。

窗口时长:计算内容的时间范围。

滑动步长:隔多久触发一次计算。

注意:这两者都必须为采集周期大小的整数倍

两种实现

①每个窗口单独统计窗口内部数据,每次滑动,重新计算(无状态

  def reduceByWindow(
      //窗口内的归约计算
      reduceFunc: (T, T) => T, 
      //窗口大小
      windowDuration: Duration,
      //步长
      slideDuration: Duration
    ): DStream[T] = ssc.withScope {
    this.reduce(reduceFunc).window(windowDuration, slideDuration).reduce(reduceFunc)
  }

②当前窗口和之前窗口有重叠,会使用之前的窗口的数据和当前窗口计算(有状态

Spark(十六)【SparkStreaming基本使用】_第4张图片

def reduceByKeyAndWindow(
    // old window 和新进入的values进行运算(上图的窗口B绿色部分)
      reduceFunc: (V, V) => V,
    // old window和离开的values进行运算(上图的窗口A的黄色部分)
      invReduceFunc: (V, V) => V,
    //窗口大小
      windowDuration: Duration,
    //步长
      slideDuration: Duration = self.slideDuration,
      numPartitions: Int = ssc.sc.defaultParallelism,
      filterFunc: ((K, V)) => Boolean = null
    ): DStream[(K, V)] = ssc.withScope {
    reduceByKeyAndWindow(
      reduceFunc, invReduceFunc, windowDuration,
      slideDuration, defaultPartitioner(numPartitions), filterFunc
    )
  }

案例:每间隔5分钟,统计最近1h所有的单词统计

实现一:无状态

    //1.初始化Spark配置信息
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("StreamWordCount")
    //2.初始化SparkStreamingContext,3秒统计一次,可以设置多个级别:Milliseconds,Seconds,Minutes
    val ssc = new StreamingContext(sparkConf, Seconds(3))
    //通过监控端口创建DStream,读进来的数据为一行
    val ds: ReceiverInputDStream[String] = ssc.socketTextStream("hadoop102", 9999)
    //转化为K-V类型
    val ds1: DStream[(String, Int)] = ds.flatMap(_.split(" ")).map((_, 1))
    val result: DStream[(String, Int)] = ds1.reduceByKeyAndWindow((_ + _), windowDuration = Seconds(4), Seconds(2))
    //打印
    result.print(100)
    //5.启动SparkStreamingContext
    ssc.start()
    ssc.awaitTermination()

实现二:有状态

需要设置检查点

        //1.初始化Spark配置信息
    val sparkConf = new SparkConf().setMaster("local[*]").setAppName("StreamWordCount")
    //2.初始化SparkStreamingContext,3秒统计一次,可以设置多个级别:Milliseconds,Seconds,Minutes
    val ssc = new StreamingContext(sparkConf, Seconds(3))
    //需要上一个window计算的结果,设置检查点
    ssc.checkpoint("updateStateByKey1")
    // DS[String] :  输入流中的每行数据
    val ds: ReceiverInputDStream[String] = context.socketTextStream("hadoop103", 3333)
    val result: DStream[(String, Int)] = ds.flatMap(_.split(" ")).map((_, 1))
      .reduceByKeyAndWindow((_+_),(_ - _),windowDuration=Seconds(4),filterFunc=_._2 != 0)
    result.print(100)
    //运行程序
    context.start()
    context.awaitTermination()
window窗口

定义DS的窗口,之后DS的算子都是在窗口中运算

  def window(windowDuration: Duration, slideDuration: Duration): DStream[T] = ssc.withScope {
    new WindowedDStream(this, windowDuration, slideDuration)
  }
ds.window(窗口大小,滑动步长)

五. 程序优雅关闭

流式任务需要7*24小时执行,但是有时涉及到升级代码需要主动停止程序,但是分布式程序,没办法做到一个个进程去杀死,所有配置优雅的关闭就显得至关重要了。使用外部文件系统来控制内部程序关闭

MonitorStop类:启动一个线程检查是否停止程序

import java.net.URI
import org.apache.hadoop.conf.Configuration
import org.apache.hadoop.fs.{FileSystem, Path}
import org.apache.spark.streaming.{StreamingContext, StreamingContextState}

class MonitorStop(ssc: StreamingContext) extends Runnable {

  override def run(): Unit = {
    val fs: FileSystem = FileSystem.get(new URI("hdfs://linux1:9000"), new Configuration(), "root")

    while (true) {
      try
        Thread.sleep(5000)
      catch {
        case e: InterruptedException =>
          e.printStackTrace()
      }
      val state: StreamingContextState = ssc.getState
       // 读取一个标记(数据库,文件系统)/应用程序/_stop
      val bool: Boolean = fs.exists(new Path("hdfs://linux1:9000/stopSpark"))
      if (bool) {
        if (state == StreamingContextState.ACTIVE) {
          ssc.stop(stopSparkContext = true, stopGracefully = true)
          System.exit(0)
        }
      }
    }
  }
}

SparkTest

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

object SparkTest {
  def createSSC(): _root_.org.apache.spark.streaming.StreamingContext = {

    val update: (Seq[Int], Option[Int]) => Some[Int] = (values: Seq[Int], status: Option[Int]) => {

      //当前批次内容的计算
      val sum: Int = values.sum

      //取出状态信息中上一次状态
      val lastStatu: Int = status.getOrElse(0)

      Some(sum + lastStatu)
    }

    val sparkConf: SparkConf = new SparkConf().setMaster("local[4]").setAppName("SparkTest")

    //设置优雅的关闭
    sparkConf.set("spark.streaming.stopGracefullyOnShutdown", "true")

    val ssc = new StreamingContext(sparkConf, Seconds(5))

    ssc.checkpoint("./ck")

    val line: ReceiverInputDStream[String] = ssc.socketTextStream("linux1", 9999)

    val word: DStream[String] = line.flatMap(_.split(" "))

    val wordAndOne: DStream[(String, Int)] = word.map((_, 1))

    val wordAndCount: DStream[(String, Int)] = wordAndOne.updateStateByKey(update)

    wordAndCount.print()

    ssc
  }

  def main(args: Array[String]): Unit = {

    val ssc: StreamingContext = StreamingContext.getActiveOrCreate("./ck", () => createSSC())

    new Thread(new MonitorStop(ssc)).start()
    ssc.start()
    ssc.awaitTermination()
  }
}

练手示例

  /*
      优雅地关闭
   */
  @Test
  def test5() : Unit ={

    val conf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("My app")

    val context = new StreamingContext(conf, Seconds(2))

    // DS[String] :  输入流中的每行数据
    val ds: ReceiverInputDStream[String] = context.socketTextStream("hadoop103", 3333)

    val result: DStream[(String, Int)] = ds.window(Seconds(4),Seconds(2))
      .flatMap(_.split(" ")).map((_, 1))
      .reduceByKey(_+_)
    result.foreachRDD(rdd => println(rdd.collect().mkString(",")))
    //运行程序
    context.start()
	
    //启动分线程,执行关闭
    new Thread(){

      //判断是否需要关闭
      def ifShouldNotStop():Boolean={
          // 读取一个标记(数据库,文件系统)/应用程序/_stop
          true
      }
      //关闭
      override def run(): Unit = {

        while(ifShouldNotStop()){
            Thread.sleep(5000)
        }

        // 关闭   stopGraceFully: 等收到的数据计算完成后再关闭
        context.stop(true,true)

      }
    }.start()

     // 当前线程阻塞,后续的代码都不会执行!
    context.awaitTermination()
  }
}

你可能感兴趣的:(Spark(十六)【SparkStreaming基本使用】)