Spark Streamin知识点详解！！！

最新推荐文章于 2024-07-25 23:49:05 发布

数据行

最新推荐文章于 2024-07-25 23:49:05 发布

阅读量375

点赞数 1

分类专栏： spark 大数据学习总结文章标签： spark 大数据分布式

本文链接：https://blog.csdn.net/qq_45831157/article/details/126075774

版权

大数据学习总结同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

spark

2 篇文章 0 订阅

订阅专栏

Spark Streaming

Spark Streaming 知识点超详细文档！！！可以让基础小白快速入门。有丰富的小案例，边学边练！！

Spark Streaming是Spark平台上针对实时数据进行流式计算的组件，提供了丰富的处理数据流的API。

SparkStreaming 准实时（秒，分钟），微批次（时间）的数据处理框架

第1章 SparkStreaming概述

1.1 Spark Streaming是什么

Spark流使得构建可扩展的容错流应用程序变得更加容易。
Spark Streaming用于流式数据的处理。Spark Streaming支持的数据输入源很多，例如：Kafka、Flume、Twitter、ZeroMQ和简单的TCP套接字等等。数据输入后可以用Spark的高度抽象原语如：map、reduce、join、window等进行运算。而结果也能保存在很多地方，如HDFS，数据库等。

和Spark基于RDD的概念很相似，Spark Streaming使用离散化流(discretized stream)作为抽象表示，叫作DStream。DStream 是随时间推移而收到的数据的序列。在内部，每个时间区间收到的数据都作为 RDD 存在，而DStream是由这些RDD所组成的序列(因此得名“离散化”)。所以简单来将，DStream就是对RDD在实时数据处理场景的一种封装
1.2 Spark Streaming的特点
- 易用
- 容错
- 易整合到Spark体系
1.3 Spark Streaming架构
- 1.3.1 架构图
  - 整体架构图
  - SparkStreaming架构图
- 1.3.2 背压机制
  
  Spark 1.5以前版本，用户如果要限制Receiver的数据接收速率，可以通过设置静态配制参数“spark.streaming.receiver.maxRate”的值来实现，此举虽然可以通过限制接收速率，来适配当前的处理能力，防止内存溢出，但也会引入其它问题。比如：producer数据生产高于maxRate，当前集群处理能力也高于maxRate，这就会造成资源利用率下降等问题。
  为了更好的协调数据接收速率与资源处理能力，1.5版本开始Spark Streaming可以动态控制数据接收速率来适配集群数据处理能力。背压机制（即Spark Streaming Backpressure）: 根据JobScheduler反馈作业的执行信息来动态调整Receiver数据接收率。
  通过属性“spark.streaming.backpressure.enabled”来控制是否启用backpressure机制，默认值false，即不启用。

第2章 Dstream入门

2.1 WordCount案例实操
1. 添加依赖

<dependency>
  
      <groupId>org.apache.spark</groupId>
  
      <artifactId>spark-streaming_2.12</artifactId>
  
      <version>3.0.0</version>
  
  </dependency>

编写代码

object WordCount {
     def main(args: Array[String]): Unit = {
  
        //TODO 创建环境对象
        //StreamingContext创建时，需要传递两个参数
        //第一个参数表示环境配置
        val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreaming")
        //第二个参数表示批量处理的周期（采集周期）
        val ssc: StreamingContext = new StreamingContext(sparkConf, Seconds(3))
        //TODO 逻辑处理
        val lines: ReceiverInputDStream[String] = ssc.socketTextStream("localhost", 9999)
  
        val words: DStream[String] = lines.flatMap(_.split(" "))
  
        val wordToOne: DStream[(String, Int)] = words.map((_, 1))
  
        val wordToCount: DStream[(String, Int)] = wordToOne.reduceByKey(_ + _)
  
        wordToCount.print()


  
        //TODO 关闭环境
        //由于SparkStreaming采集器是长期执行的任务，所以不能直接关闭
        //如果main方法执行完毕，应用程序也会自动结束，所以不能让main执行完毕
        //ssc.stop()
  
        //1.启动采集器
        ssc.start()
        //2.等待采集器的关闭
        ssc.awaitTermination()
     }
  
  }

启动程序并通过netcat发送数据：

nc -lk 9999

hello spark

2.2 WordCount解析

Discretized Stream是Spark Streaming的基础抽象，代表持续性的数据流和经过各种Spark原语操作后的结果数据流。在内部实现上，DStream是一系列连续的RDD来表示。
- 每个RDD含有一段时间间隔内的数据。
- 对数据的操作也是按照RDD为单位来进行的
- 计算过程由Spark Engine来完成

第3章 DStream创建

3.1 RDD队列
- 3.1.1 用法及说明
  
  测试过程中，可以通过使用ssc.queueStream(queueOfRDDs)来创建DStream，每一个推送到这个队列中的RDD，都会作为一个DStream处理。
- 3.1.2 案例实操
  
  Ø 需求：循环创建几个RDD，将RDD放入队列。通过SparkStream创建Dstream，计算WordCount
  1. 编写代码

object RDDStream {
	  
	    def main(args: Array[String]) {
	  
	      //1.初始化Spark配置信息
	      val conf = new SparkConf().setMaster("local[*]").setAppName("RDDStream")
	  
	      //2.初始化SparkStreamingContext
	      val ssc = new StreamingContext(conf, Seconds(4))
	  
	      //3.创建RDD队列
	      val rddQueue = new mutable.Queue[RDD[Int]]()
	  
	      //4.创建QueueInputDStream
	      val inputStream = ssc.queueStream(rddQueue,oneAtATime = false)
	  
	      //5.处理队列中的RDD数据
	      val mappedStream = inputStream.map((_,1))
	      val reducedStream = mappedStream.reduceByKey(_ + _)
	  
	      //6.打印结果
	      reducedStream.print()
	  
	      //7.启动任务
	      ssc.start()
	  
	  	//8.循环创建并向RDD队列中放入RDD
	      for (i <- 1 to 5) {
	        rddQueue += ssc.sparkContext.makeRDD(1 to 300, 10)
	        Thread.sleep(2000)
	      }
	  
	      ssc.awaitTermination()
	  
	    }
	  }

  2) 结果展示
  -------------------------------------------
  Time: 1539075280000 ms
  -------------------------------------------
  (4,60)
  (0,60)
  (6,60)
  (8,60)
  (2,60)
  (1,60)
  (3,60)
  (7,60)
  (9,60)
  (5,60)
  
  -------------------------------------------
  Time: 1539075284000 ms
  -------------------------------------------
  (4,60)
  (0,60)
  (6,60)
  (8,60)
  (2,60)
  (1,60)
  (3,60)
  (7,60)
  (9,60)
  (5,60)
  
  -------------------------------------------
  Time: 1539075288000 ms
  -------------------------------------------
  (4,30)
  (0,30)
  (6,30)
  (8,30)
  (2,30)
  (1,30)
  (3,30)
  (7,30)
  (9,30)
  (5,30)
  
  -------------------------------------------
  Time: 1539075292000 ms
  -------------------------------------------

3.2 自定义数据源
- 3.2.1 用法及说明
  
  需要继承Receiver，并实现onStart、onStop方法来自定义数据源采集。
- 3.2.2 案例实操
  
  需求：自定义数据源，实现监控某个端口号，获取该端口号内容。
  1. 自定义数据源

class CustomerReceiver(host: String, port: Int) extends Receiver[String](StorageLevel.MEMORY_ONLY) {
	  
	    //最初启动的时候，调用该方法，作用为：读数据并将数据发送给Spark
	    override def onStart(): Unit = {
	      new Thread("Socket Receiver") {
	        override def run() {
	          receive()
	        }
	      }.start()
	    }
	  
	    //读数据并将数据发送给Spark
	    def receive(): Unit = {
	  
	      //创建一个Socket
	      var socket: Socket = new Socket(host, port)
	  
	      //定义一个变量，用来接收端口传过来的数据
	      var input: String = null
	  
	      //创建一个BufferedReader用于读取端口传来的数据
	      val reader = new BufferedReader(new InputStreamReader(socket.getInputStream, StandardCharsets.UTF_8))
	  
	      //读取数据
	      input = reader.readLine()
	  
	      //当receiver没有关闭并且输入数据不为空，则循环发送数据给Spark
	      while (!isStopped() && input != null) {
	        store(input)
	        input = reader.readLine()
	      }
	  
	      //跳出循环则关闭资源
	      reader.close()
	      socket.close()
	  
	      //重启任务
	      restart("restart")
	    }
	  
	    override def onStop(): Unit = {}
	  }
	  2) 使用自定义的数据源采集数据
	  object FileStream {
	  
	    def main(args: Array[String]): Unit = {
	  
	      //1.初始化Spark配置信息
	  val sparkConf = new SparkConf().setMaster("local[*]")
	  .setAppName("StreamWordCount")
	  
	      //2.初始化SparkStreamingContext
	      val ssc = new StreamingContext(sparkConf, Seconds(5))
	  
	  //3.创建自定义receiver的Streaming
	  val lineStream = ssc.receiverStream(new CustomerReceiver("hadoop102", 9999))
	  
	      //4.将每一行数据做切分，形成一个个单词
	      val wordStream = lineStream.flatMap(_.split("\t"))
	  
	      //5.将单词映射成元组（word,1）
	      val wordAndOneStream = wordStream.map((_, 1))
	  
	      //6.将相同的单词次数做统计
	      val wordAndCountStream = wordAndOneStream.reduceByKey(_ + _)
	  
	      //7.打印
	      wordAndCountStream.print()
	  
	      //8.启动SparkStreamingContext
	      ssc.start()
	      ssc.awaitTermination()
	    }
	  }

3.3 Kafka数据源（面试、开发重点）
- 3.3.1 版本选型
  
  ReceiverAPI：需要一个专门的Executor去接收数据，然后发送给其他的Executor做计算。存在的问题，接收数据的Executor和计算的Executor速度会有所不同，特别在接收数据的Executor速度大于计算的Executor速度，会导致计算数据的节点内存溢出。早期版本中提供此方式，当前版本不适用
  DirectAPI：是由计算的Executor来主动消费Kafka的数据，速度由自身控制。
- 3.3.2 Kafka 0-8 Receiver模式（当前版本不适用）
  
  1）需求：通过SparkStreaming从Kafka读取数据，并将读取过来的数据做简单计算，最终打印到控制台。
  2）导入依赖

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

  3）编写代码

  package com.atguigu.kafka
	  
	  import org.apache.spark.SparkConf
	  import org.apache.spark.streaming.dstream.ReceiverInputDStream
	  import org.apache.spark.streaming.kafka.KafkaUtils
	  import org.apache.spark.streaming.{Seconds, StreamingContext}
	  
	  object ReceiverAPI {
	  
	    def main(args: Array[String]): Unit = {
	  
	      //1.创建SparkConf
	      val sparkConf: SparkConf = new SparkConf().setAppName("ReceiverWordCount").setMaster("local[*]")
	  
	      //2.创建StreamingContext
	      val ssc = new StreamingContext(sparkConf, Seconds(3))
	  
	      //3.读取Kafka数据创建DStream(基于Receive方式)
	      val kafkaDStream: ReceiverInputDStream[(String, String)] = KafkaUtils.createStream(ssc,
	        "hadoop102:9092,hadoop103:9092,hadoop103:9092",
	        "sqlboy",
	        Map[String, Int]("sqlboy" -> 1))
	  
	      //4.计算WordCount
	      kafkaDStream.map { case (_, value) =>
	        (value, 1)
	      }.reduceByKey(_ + _)
	        .print()
	  
	      //5.开启任务
	      ssc.start()
	      ssc.awaitTermination()
	  
	    }
	  }

- 3.3.3 Kafka 0-8 Direct模式（当前版本不适用）

  需求：通过SparkStreaming从Kafka读取数据，并将读取过来的数据做简单计算，最终打印到控制台。
  2）导入依赖

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

  3）编写代码（自动维护offset）

 import kafka.serializer.StringDecoder
	  import org.apache.kafka.clients.consumer.ConsumerConfig
	  import org.apache.spark.SparkConf
	  import org.apache.spark.streaming.dstream.InputDStream
	  import org.apache.spark.streaming.kafka.KafkaUtils
	  import org.apache.spark.streaming.{Seconds, StreamingContext}
	  
	  object DirectAPIAuto02 {
	  
	    val getSSC1: () => StreamingContext = () => {
	      val sparkConf: SparkConf = new SparkConf().setAppName("ReceiverWordCount").setMaster("local[*]")
	      val ssc = new StreamingContext(sparkConf, Seconds(3))
	      ssc
	    }
	  
	    def getSSC: StreamingContext = {
	  
	      //1.创建SparkConf
	      val sparkConf: SparkConf = new SparkConf().setAppName("ReceiverWordCount").setMaster("local[*]")
	  
	      //2.创建StreamingContext
	      val ssc = new StreamingContext(sparkConf, Seconds(3))
	  
	      //设置CK
	      ssc.checkpoint("./ck2")
	  
	      //3.定义Kafka参数
	      val kafkaPara: Map[String, String] = Map[String, String](
	        ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "hadoop102:9092,hadoop103:9092,hadoop103:9092",
	        ConsumerConfig.GROUP_ID_CONFIG -> "sqlboy"
	      )
	  
	      //4.读取Kafka数据
	      val kafkaDStream: InputDStream[(String, String)] = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](ssc,
	        kafkaPara,
	        Set("sqlboy"))
	  
	      //5.计算WordCount
	      kafkaDStream.map(_._2)
	        .flatMap(_.split(" "))
	        .map((_, 1))
	        .reduceByKey(_ + _)
	        .print()
	  
	      //6.返回数据
	      ssc
	    }
	  
	    def main(args: Array[String]): Unit = {
	  
	      //获取SSC
	      val ssc: StreamingContext = StreamingContext.getActiveOrCreate("./ck2", () => getSSC)
	  
	      //开启任务
	      ssc.start()
	      ssc.awaitTermination()
	    }
	  
	  }

  4）编写代码（手动维护offset）

import kafka.common.TopicAndPartition
	  import kafka.message.MessageAndMetadata
	  import kafka.serializer.StringDecoder
	  import org.apache.kafka.clients.consumer.ConsumerConfig
	  import org.apache.spark.SparkConf
	  import org.apache.spark.streaming.dstream.{DStream, InputDStream}
	  import org.apache.spark.streaming.kafka.{HasOffsetRanges, KafkaUtils, OffsetRange}
	  import org.apache.spark.streaming.{Seconds, StreamingContext}
	  
	  object DirectAPIHandler {
	  
	    def main(args: Array[String]): Unit = {
	  
	      //1.创建SparkConf
	      val sparkConf: SparkConf = new SparkConf().setAppName("ReceiverWordCount").setMaster("local[*]")
	  
	      //2.创建StreamingContext
	      val ssc = new StreamingContext(sparkConf, Seconds(3))
	  
	      //3.Kafka参数
	      val kafkaPara: Map[String, String] = Map[String, String](
	        ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "hadoop102:9092,hadoop103:9092,hadoop104:9092",
	        ConsumerConfig.GROUP_ID_CONFIG -> "atguigu"
	      )
	  
	      //4.获取上一次启动最后保留的Offset=>getOffset(MySQL)
	      val fromOffsets: Map[TopicAndPartition, Long] = Map[TopicAndPartition, Long](TopicAndPartition("sqlboy", 0) -> 20)
	  
	      //5.读取Kafka数据创建DStream
	      val kafkaDStream: InputDStream[String] = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder, String](ssc,
	        kafkaPara,
	        fromOffsets,
	        (m: MessageAndMetadata[String, String]) => m.message())
	  
	      //6.创建一个数组用于存放当前消费数据的offset信息
	      var offsetRanges = Array.empty[OffsetRange]
	  
	      //7.获取当前消费数据的offset信息
	      val wordToCountDStream: DStream[(String, Int)] = kafkaDStream.transform { rdd =>
	        offsetRanges = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
	        rdd
	      }.flatMap(_.split(" "))
	        .map((_, 1))
	        .reduceByKey(_ + _)
	  
	      //8.打印Offset信息
	      wordToCountDStream.foreachRDD(rdd => {
	        for (o <- offsetRanges) {
	          println(s"${o.topic}:${o.partition}:${o.fromOffset}:${o.untilOffset}")
	        }
	        rdd.foreach(println)
	      })
	  
	      //9.开启任务
	      ssc.start()
	      ssc.awaitTermination()
	    }
	  }

- 3.3.4 Kafka 0-10 Direct模式

  需求：通过SparkStreaming从Kafka读取数据，并将读取过来的数据做计算，最终打印到控制台。
  2）导入依赖

 <dependency>
	       <groupId>org.apache.spark</groupId>
	       <artifactId>spark-streaming-kafka-0-10_2.12</artifactId>
	       <version>3.0.0</version>
	  </dependency>
	  <dependency>
	      <groupId>com.fasterxml.jackson.core</groupId>
	      <artifactId>jackson-core</artifactId>
	      <version>2.10.1</version>
	  </dependency>

  3）编写代码

  import org.apache.kafka.clients.consumer.{ConsumerConfig, 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}
	  
	  object DirectAPI {
	  
	    def main(args: Array[String]): Unit = {
	  
	      //1.创建SparkConf
	      val sparkConf: SparkConf = new SparkConf().setAppName("ReceiverWordCount").setMaster("local[*]")
	  
	      //2.创建StreamingContext
	      val ssc = new StreamingContext(sparkConf, Seconds(3))
	  
	      //3.定义Kafka参数
	      val kafkaPara: Map[String, Object] = Map[String, Object](
	        ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "hadoop102:9092,hadoop103:9092,hadoop103:9092",
	        ConsumerConfig.GROUP_ID_CONFIG -> "sqlboy",
	        "key.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
	        "value.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer"
	      )
	  
	      //4.读取Kafka数据创建DStream
	      val kafkaDStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream[String, String](ssc,
	        LocationStrategies.PreferConsistent,
	        ConsumerStrategies.Subscribe[String, String](Set("sqlboy"), kafkaPara))
	  
	      //5.将每条消息的KV取出
	      val valueDStream: DStream[String] = kafkaDStream.map(record => record.value())
	  
	      //6.计算WordCount
	      valueDStream.flatMap(_.split(" "))
	        .map((_, 1))
	        .reduceByKey(_ + _)
	        .print()
	  
	      //7.开启任务
	      ssc.start()
	      ssc.awaitTermination()
	    }
	  }

  查看Kafka消费进度
  bin/kafka-consumer-groups.sh --describe --bootstrap-server hadoop102:9092 --group sqlboy

第4章 DStream转换

DStream上的操作与RDD的类似，分为Transformations（转换）和Output Operations（输出）两种，此外转换操作中还有一些比较特殊的原语，如：updateStateByKey()、transform()以及各种Window相关的原语。

4.1 无状态转化操作

无状态转化操作就是把简单的RDD转化操作应用到每个批次上，也就是转化DStream中的每一个RDD。部分无状态转化操作列在了下表中。注意，针对键值对的DStream转化操作(比如 reduceByKey())要添加import StreamingContext._才能在Scala中使用。

需要记住的是，尽管这些函数看起来像作用在整个流上一样，但事实上每个DStream在内部是由许多RDD（批次）组成，且无状态转化操作是分别应用到每个RDD上的。
例如：reduceByKey()会归约每个时间区间中的数据，但不会归约不同区间之间的数据。
- 4.1.1 Transform
  
  Transform允许DStream上执行任意的RDD-to-RDD函数。即使这些函数并没有在DStream的API中暴露出来，通过该函数可以方便的扩展Spark API。该函数每一批次调度一次。其实也就是对DStream中的RDD应用转换。

object Transform {
	  
	    def main(args: Array[String]): Unit = {
	  
	      //创建SparkConf
	      val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("WordCount")
	  
	      //创建StreamingContext
	      val ssc = new StreamingContext(sparkConf, Seconds(3))
	  
	      //创建DStream
	      val lineDStream: ReceiverInputDStream[String] = ssc.socketTextStream("linux1", 9999)
	  
	      //转换为RDD操作
	      val wordAndCountDStream: DStream[(String, Int)] = lineDStream.transform(rdd => {
	  
	        val words: RDD[String] = rdd.flatMap(_.split(" "))
	  
	        val wordAndOne: RDD[(String, Int)] = words.map((_, 1))
	  
	        val value: RDD[(String, Int)] = wordAndOne.reduceByKey(_ + _)
	  
	        value
	      })
	  
	      //打印
	      wordAndCountDStream.print
	  
	      //启动
	      ssc.start()
	      ssc.awaitTermination()
	  
	    }
	  }

- 4.1.2 join

  两个流之间的join需要两个流的批次大小一致，这样才能做到同时触发计算。计算过程就是对当前批次的两个流中各自的RDD进行join，与两个RDD的join效果相同。

import org.apache.spark.SparkConf
	  import org.apache.spark.streaming.{Seconds, StreamingContext}
	  import org.apache.spark.streaming.dstream.{DStream, ReceiverInputDStream}
	  
	  object JoinTest {
	  
	    def main(args: Array[String]): Unit = {
	  
	      //1.创建SparkConf
	      val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("JoinTest")
	  
	      //2.创建StreamingContext
	      val ssc = new StreamingContext(sparkConf, Seconds(5))
	  
	      //3.从端口获取数据创建流
	      val lineDStream1: ReceiverInputDStream[String] = ssc.socketTextStream("linux1", 9999)
	      val lineDStream2: ReceiverInputDStream[String] = ssc.socketTextStream("linux2", 8888)
	  
	      //4.将两个流转换为KV类型
	      val wordToOneDStream: DStream[(String, Int)] = lineDStream1.flatMap(_.split(" ")).map((_, 1))
	      val wordToADStream: DStream[(String, String)] = lineDStream2.flatMap(_.split(" ")).map((_, "a"))
	  
	      //5.流的JOIN
	      val joinDStream: DStream[(String, (Int, String))] = wordToOneDStream.join(wordToADStream)
	  
	      //6.打印
	      joinDStream.print()
	  
	      //7.启动任务
	      ssc.start()
	      ssc.awaitTermination()
	    }
	  }

4.2 有状态转化操作
- 4.2.1 UpdateStateByKey
  
  UpdateStateByKey原语用于记录历史记录，有时，我们需要在DStream中跨批次维护状态(例如流计算中累加wordcount)。针对这种情况，updateStateByKey()为我们提供了对一个状态变量的访问，用于键值对形式的DStream。给定一个由(键，事件)对构成的 DStream，并传递一个指定如何根据新的事件更新每个键对应状态的函数，它可以构建出一个新的 DStream，其内部数据为(键，状态) 对。
  updateStateByKey() 的结果会是一个新的DStream，其内部的RDD 序列是由每个时间区间对应的(键，状态)对组成的。
  updateStateByKey操作使得我们可以在用新信息进行更新时保持任意的状态。为使用这个功能，需要做下面两步：
  1. 定义状态，状态可以是一个任意的数据类型。
  2. 定义状态更新函数，用此函数阐明如何使用之前的状态和来自输入流的新值对状态进行更新。
    使用updateStateByKey需要对检查点目录进行配置，会使用检查点来保存状态。
    更新版的wordcount
  1. 编写代码

object WorldCount {
	  
	    def main(args: Array[String]) {
	  
	      // 定义更新状态方法，参数values为当前批次单词频度，state为以往批次单词频度
	      val updateFunc = (values: Seq[Int], state: Option[Int]) => {
	        val currentCount = values.foldLeft(0)(_ + _)
	        val previousCount = state.getOrElse(0)
	        Some(currentCount + previousCount)
	      }
	  
	      val conf = new SparkConf().setMaster("local[*]").setAppName("NetworkWordCount")
	      val ssc = new StreamingContext(conf, Seconds(3))
	      ssc.checkpoint("./ck")
	  
	      // Create a DStream that will connect to hostname:port, like hadoop102:9999
	      val lines = ssc.socketTextStream("linux1", 9999)
	  
	      // Split each line into words
	      val words = lines.flatMap(_.split(" "))
	  
	      //import org.apache.spark.streaming.StreamingContext._ // not necessary since Spark 1.3
	      // Count each word in each batch
	      val pairs = words.map(word => (word, 1))
	  
	      // 使用updateStateByKey来更新状态，统计从运行开始以来单词总的次数
	      val stateDstream = pairs.updateStateByKey[Int](updateFunc)
	      stateDstream.print()
	  
	      ssc.start()            // Start the computation
	      ssc.awaitTermination() // Wait for the computation to terminate
	      //ssc.stop()
	    }
	  }

  2) 启动程序并向9999端口发送数据
  nc -lk 9999
  Hello World
  Hello Scala
  3) 结果展示
  -------------------------------------------
  Time: 1504685175000 ms
  -------------------------------------------
  -------------------------------------------
  Time: 1504685181000 ms
  -------------------------------------------
  (shi,1)
  (shui,1)
  (ni,1)
  -------------------------------------------
  Time: 1504685187000 ms
  -------------------------------------------
  (shi,1)
  (ma,1)
  (hao,1)
  (shui,1)

- 4.2.2 WindowOperations

  Window Operations可以设置窗口的大小和滑动窗口的间隔来动态的获取当前Steaming的允许状态。所有基于窗口的操作都需要两个参数，分别为窗口时长以及滑动步长。
  Ø 窗口时长：计算内容的时间范围；
  Ø 滑动步长：隔多久触发一次计算。
  注意：这两者都必须为采集周期大小的整数倍。
  WordCount第三版：3秒一个批次，窗口12秒，滑步6秒。

object WorldCount {
	    def main(args: Array[String]) {
	      val conf = new SparkConf().setMaster("local[2]").setAppName("NetworkWordCount")
	      val ssc = new StreamingContext(conf, Seconds(3))
	      ssc.checkpoint("./ck")
	  
	      // Create a DStream that will connect to hostname:port, like localhost:9999
	      val lines = ssc.socketTextStream("linux1", 9999)
	  
	      // Split each line into words
	      val words = lines.flatMap(_.split(" "))
	  
	  // Count each word in each batch
	      val pairs = words.map(word => (word, 1))
	  
	      val wordCounts = pairs.reduceByKeyAndWindow((a:Int,b:Int) => (a + b),Seconds(12), Seconds(6))
	  
	      // Print the first ten elements of each RDD generated in this DStream to the console
	      wordCounts.print()
	  
	      ssc.start()            // Start the computation
	      ssc.awaitTermination() // Wait for the computation to terminate
	     }
	  }

  关于Window的操作还有如下方法：
  	（1）window(windowLength, slideInterval): 基于对源DStream窗化的批次进行计算返回一个新的Dstream；
  	（2）countByWindow(windowLength, slideInterval): 返回一个滑动窗口计数流中的元素个数；
  	（3）reduceByWindow(func, windowLength, slideInterval): 通过使用自定义函数整合滑动区间流元素来创建一个新的单元素流；
  	（4）reduceByKeyAndWindow(func, windowLength, slideInterval, [numTasks]): 当在一个(K,V)对的DStream上调用此函数，会返回一个新(K,V)对的DStream，此处通过对滑动窗口中批次数据使用reduce函数来整合每个key的value值。
  	（5）reduceByKeyAndWindow(func, invFunc, windowLength, slideInterval, [numTasks]): 这个函数是上述函数的变化版本，每个窗口的reduce值都是通过用前一个窗的reduce值来递增计算。通过reduce进入到滑动窗口数据并”反向reduce”离开窗口的旧数据来实现这个操作。一个例子是随着窗口滑动对keys的“加”“减”计数。通过前边介绍可以想到，这个函数只适用于”可逆的reduce函数”，也就是这些reduce函数有相应的”反reduce”函数(以参数invFunc形式传入)。如前述函数，reduce任务的数量通过可选参数来配置。
  
  val ipDStream = accessLogsDStream.map(logEntry => (logEntry.getIpAddress(), 1))
  val ipCountDStream = ipDStream.reduceByKeyAndWindow(
    {(x, y) => x + y},
    {(x, y) => x - y},
    Seconds(30),
    Seconds(10))
    //加上新进入窗口的批次中的元素 //移除离开窗口的老批次中的元素 //窗口时长// 滑动步长
  	countByWindow()和countByValueAndWindow()作为对数据进行计数操作的简写。countByWindow()返回一个表示每个窗口中元素个数的DStream，而countByValueAndWindow()返回的DStream则包含窗口中每个值的个数。
  val ipDStream = accessLogsDStream.map{entry => entry.getIpAddress()}
  val ipAddressRequestCount = ipDStream.countByValueAndWindow(Seconds(30), Seconds(10)) 
  val requestCount = accessLogsDStream.countByWindow(Seconds(30), Seconds(10))

第5章 DStream输出

输出操作指定了对流数据经转化操作得到的数据所要执行的操作(例如把结果推入外部数据库或输出到屏幕上)。与RDD中的惰性求值类似，如果一个DStream及其派生出的DStream都没有被执行输出操作，那么这些DStream就都不会被求值。如果StreamingContext中没有设定输出操作，整个context就都不会启动。
注意：

连接不能写在driver层面（序列化）
如果写在foreach则每个RDD中的每一条数据都创建，得不偿失；
增加foreachPartition，在分区创建（获取）。

print()：在运行流程序的驱动结点上打印DStream中每一批次数据的最开始10个元素。这用于开发和调试。在Python API中，同样的操作叫print()。
saveAsTextFiles(prefix, [suffix])：以text文件形式存储这个DStream的内容。每一批次的存储文件名基于参数中的prefix和suffix。”prefix-Time_IN_MS[.suffix]”。
saveAsObjectFiles(prefix, [suffix])：以Java对象序列化的方式将Stream中的数据保存为 SequenceFiles . 每一批次的存储文件名基于参数中的为"prefix-TIME_IN_MS[.suffix]". Python中目前不可用。
saveAsHadoopFiles(prefix, [suffix])：将Stream中的数据保存为 Hadoop files. 每一批次的存储文件名基于参数中的为"prefix-TIME_IN_MS[.suffix]"。Python API 中目前不可用。
foreachRDD(func)：这是最通用的输出操作，即将函数 func 用于产生于 stream的每一个RDD。其中参数传入的函数func应该实现将每一个RDD中数据推送到外部系统，如将RDD存入文件或者通过网络将其写入数据库。

第6章优雅关闭

流式任务需要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://hadoop102:9000"), new Configuration(), "sqlboy")
  
      while (true) {
        try
          Thread.sleep(5000)
        catch {
          case e: InterruptedException =>
            e.printStackTrace()
        }
        val state: StreamingContextState = ssc.getState
  
        val bool: Boolean = fs.exists(new Path("hdfs://hadoop102: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()
    }
  }

第7章 SparkStreaming 案例实操

7.1 环境准备

 <dependencies>
      <dependency>
          <groupId>org.apache.spark</groupId>
          <artifactId>spark-core_2.12</artifactId>
          <version>3.0.0</version>
      </dependency>
  
      <dependency>
          <groupId>org.apache.spark</groupId>
          <artifactId>spark-streaming_2.12</artifactId>
          <version>3.0.0</version>
      </dependency>
  
      <dependency>
          <groupId>org.apache.spark</groupId>
          <artifactId>spark-streaming-kafka-0-10_2.12</artifactId>
          <version>3.0.0</version>
      </dependency>
  
      <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
      <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>druid</artifactId>
          <version>1.1.10</version>
      </dependency>
  
      <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>5.1.27</version>
  	</dependency>
  	<dependency>
  	    <groupId>com.fasterxml.jackson.core</groupId>
  	    <artifactId>jackson-core</artifactId>
  	    <version>2.10.1</version>
  	</dependency>
  </dependencies>

7.2 数据准备

 def main(args: Array[String]): Unit = {
        //生成模拟数据
        //模式：timestamp area city userid adid
        //含义：时间戳     区域   城市  用户  广告
  
        //Application => Kafka => SparkStreaming =>Analysis
        val prop = new Properties()
  
        // 添加配置
        prop.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092")
        prop.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer")
        prop.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer")
        // 根据配置创建Kafka生产者
        val producer: KafkaProducer[String, String] = new KafkaProducer[String, String](prop)
        while(true){
           mockdata().foreach(
              data => {
                 //向kafka中生成数据
                 val record: ProducerRecord[Nothing, String] = new ProducerRecord("sqlboy", data)
                 producer.send(record)
              }
           )
        }
     }
     def mockdata():ListBuffer[String] ={
        val list = ListBuffer[String]()
        val areaList = ListBuffer[String]("华北","华东","华南")
        val cityList = ListBuffer[String]("北京","上海","深圳")
  
        for(i<-1 to 30){
           val area = areaList(new Random().nextInt(3))
           val city = cityList(new Random().nextInt(3))
           val userid = new Random().nextInt(6)+1
           val adid = new Random().nextInt(6)+1
  
           list.append(s"${System.currentTimeMillis()} ${area} ${city} ${userid} ${adid}")
        }
        list
     }
  
  }

7.3 需求一：广告黑名单

实现实时的动态黑名单机制：将每天对某个广告点击超过 100 次的用户拉黑。
注：黑名单保存到MySQL中。
思路分析
1）读取Kafka数据之后，并对MySQL中存储的黑名单数据做校验；
2）校验通过则对给用户点击广告次数累加一并存入MySQL；
3）在存入MySQL之后对数据做校验，如果单日超过100次则将该用户加入黑名单。

MySQL建表
创建库spark2020
1）存放黑名单用户的表

CREATE TABLE black_list (userid CHAR(1) PRIMARY KEY);

2）存放单日各用户点击每个广告的次数

CREATE TABLE user_ad_count (
  	dt varchar(255),
  	userid CHAR (1),
  	adid CHAR (1),
  	count BIGINT,
  	PRIMARY KEY (dt, userid, adid)
  );

- 工具类

 object JDBCutil {
	     //初始化连接池
	     var dataSource: DataSource = init()
	  
	     //初始化连接池方法
	     def init(): DataSource = {
	        val properties = new Properties()
	        properties.setProperty("driverClassName", "com.mysql.jdbc.Driver")
	        properties.setProperty("url", "jdbc:mysql://hadoop102:3306/spark-streaming")
	        properties.setProperty("username", "root")
	        properties.setProperty("password", "XXXXXX")
	        properties.setProperty("maxActive", "50")
	        DruidDataSourceFactory.createDataSource(properties)
	     }
	  
	     //获取MySQL连接
	     def getConnection: Connection = {
	        dataSource.getConnection
	     }
	  
	     //执行SQL语句,单条数据插入
	     def executeUpdate(connection: Connection, sql: String, params: Array[Any]): Int = {
	        var rtn = 0
	        var pstmt: PreparedStatement = null
	        try {
	           connection.setAutoCommit(false)
	           pstmt = connection.prepareStatement(sql)
	  
	           if (params != null && params.length > 0) {
	              for (i <- params.indices) {
	                 pstmt.setObject(i + 1, params(i))
	              }
	           }
	           rtn = pstmt.executeUpdate()
	           connection.commit()
	           pstmt.close()
	        } catch {
	           case e: Exception => e.printStackTrace()
	        }
	        rtn
	     }
	  
	     //执行SQL语句,批量数据插入
	     def executeBatchUpdate(connection: Connection, sql: String, paramsList: Iterable[Array[Any]]): Array[Int] = {
	        var rtn: Array[Int] = null
	        var pstmt: PreparedStatement = null
	        try {
	           connection.setAutoCommit(false)
	           pstmt = connection.prepareStatement(sql)
	           for (params <- paramsList) {
	              if (params != null && params.length > 0) {
	                 for (i <- params.indices) {
	                    pstmt.setObject(i + 1, params(i))
	                 }
	                 pstmt.addBatch()
	              }
	           }
	           rtn = pstmt.executeBatch()
	           connection.commit()
	           pstmt.close()
	        } catch {
	           case e: Exception => e.printStackTrace()
	        }
	        rtn
	     }
	  
	     //判断一条数据是否存在
	     def isExist(connection: Connection, sql: String, params: Array[Any]): Boolean = {
	        var flag: Boolean = false
	        var pstmt: PreparedStatement = null
	        try {
	           pstmt = connection.prepareStatement(sql)
	           for (i <- params.indices) {
	              pstmt.setObject(i + 1, params(i))
	           }
	           flag = pstmt.executeQuery().next()
	           pstmt.close()
	        } catch {
	           case e: Exception => e.printStackTrace()
	        }
	     }
	     //获取MySQL的一条数据
	     def getDataFromMysql(connection: Connection, sql: String, params: Array[Any]): Long = {
	        var result: Long = 0L
	        var pstmt: PreparedStatement = null
	        try {
	           pstmt = connection.prepareStatement(sql)
	           for (i <- params.indices) {
	              pstmt.setObject(i + 1, params(i))
	           }
	           val resultSet: ResultSet = pstmt.executeQuery()
	           while (resultSet.next()) {
	              result = resultSet.getLong(1)
	           }
	           resultSet.close()
	           pstmt.close()
	        } catch {
	           case e: Exception => e.printStackTrace()
	        }
	        result
	     }
	  }

- 代码实现

  object Req1 {
	     def main(args: Array[String]): Unit = {
	  
	        //TODO 创建环境对象
	        //StreamingContext创建时，需要传递两个参数
	        //第一个参数表示环境配置
	        val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreaming")
	        //第二个参数表示批量处理的周期（采集周期）
	        val ssc: StreamingContext = new StreamingContext(sparkConf, Seconds(3))
	  
	        val kafkaPara: Map[String, Object] = Map[String, Object](
	           ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "hadoop102:9092,hadoop103:9092,hadoop104:9092",
	           ConsumerConfig.GROUP_ID_CONFIG -> "atguigu",
	           "key.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
	           "value.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer"
	        )
	  
	        val kafkaDataDS: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream[String, String](
	           ssc,
	           LocationStrategies.PreferConsistent,
	           ConsumerStrategies.Subscribe[String, String](Set("sqlboy"), kafkaPara)
	        )
	        val adClickData: DStream[AdClickData] = kafkaDataDS.map(
	           kafkaData => {
	              val data: String = kafkaData.value()
	              val datas: Array[String] = data.split(" ")
	              AdClickData(datas(0), datas(1), datas(2), datas(3), datas(4))
	           }
	        )
	  
	        val ds: DStream[((String, String, String), Int)] = adClickData.transform(
	           rdd => {
	              //TODO 周期性的获取黑名单数据
	              val blackList: ListBuffer[String] = ListBuffer[String]()
	              val conn: Connection = JDBCutil.getConnection
	              val pstat: PreparedStatement = conn.prepareStatement("select userid from black_list")
	              val rs: ResultSet = pstat.executeQuery()
	              while (rs.next()) {
	                 blackList.append(rs.getString(1))
	              }
	              rs.close()
	              pstat.close()
	              conn.close()
	  
	              //TODO 判断点击用户是否在黑名单中
	              val filterRDD: RDD[AdClickData] = rdd.filter(
	                 data => {
	                    !blackList.contains(data.user)
	                 }
	              )
	  
	              //TODO 如果用户不在黑名单中，那么进行统计数量（每个采集周期）
	              filterRDD.map(
	                 data => {
	                    val sdf: SimpleDateFormat = new SimpleDateFormat("yyyy-MM-dd")
	                    val day: String = sdf.format(new Date(data.ts.toLong))
	                    val user: String = data.user
	                    val ad: String = data.ad
	                    ((day, user, ad), 1)
	                 }
	              ).reduceByKey(_ + _)
	           }
	        )
	  
	        ds.foreachRDD(
	           rdd => {
	              //rdd.foreach方法会每一条数据创建连接
	              rdd.foreach{
	                 case ((day, user, ad), count) => {
	                    println(s"${day} ${user} ${ad} ${count}")
	                    if(count >= 30){
	                       //TODO 如果统计数量超过点击阙值，那么需要将用户拉入到黑名单
	                       val conn: Connection = JDBCutil.getConnection
	                       val sql:String =
	                          """
	                            |insert into black_list (useri) values (?)
	                            |ON DUPLICATE KEY
	                            |UPDATE userid = ?
	                            |""".stripMargin
	                       JDBCutil.executeUpdate(conn, sql, Array(user,user))
	                       conn.close()
	                    }else{
	                       //TODO 如果没有超过阙值，那么需要将当天的广告点击数量进行更新
	                       val conn: Connection = JDBCutil.getConnection
	                       val sql =
	                          """
	                            |select
	                            | *
	                            | from user_ad_count
	                            | where dt = ? and userid = ? and adid = ?
	                            |""".stripMargin
	                       val flg: Boolean = JDBCutil.isExist(conn, sql, Array(day, user, ad))
	                       //查询统计表数据
	                       if (flg){
	                          //如果存在数据，那么更新
	                          val sql1 = """
	                                       |update user_ad_count
	                                       |set count = count + ?
	                                       |where dt = ? and userid = ? and adid = ?
	                                       |""".stripMargin
	                          JDBCutil.executeUpdate(conn, sql1, Array(count, day, user, ad))
	  
	  
	                          //TODO 判断更新后的点击数据是否超过阙值，如果超过，那么将用户拉入黑名单
	                          val sql2 =
	                             """
	                               |select *
	                               |from user_ad_count
	                               |where dt = ? and userid = ? and adid = ? and count >= 30
	                               |""".stripMargin
	                          val flg1: Boolean = JDBCutil.isExist(conn, sql2, Array(day, user, ad))
	                          if (flg1){
	                             val sql3 = """
	                                  |insert into black_list (useri) values (?)
	                                  |ON DUPLICATE KEY
	                                  |UPDATE userid = ?
	                                  |""".stripMargin
	                             JDBCutil.executeUpdate(conn, sql3, Array(user, user))
	                          }
	                       }else {
	                          //如果不存在数据，那么新增
	                          val sql4 =
	                             """
	                               |insert into user_ad_count (dt,userid,count) values(?,?,?,?)
	                               |""".stripMargin
	                          JDBCutil.executeUpdate(conn, sql4, Array(day, user,ad,count))
	                       }
	                       conn.close()
	                    }
	                 }
	              }
	           }
	        )
	  
	        ssc.start()
	        ssc.awaitTermination()
	     }
	     //广告点击数据
	     case class AdClickData(ts:String,area:String,city:String,user:String,ad:String)
	  }

7.4 需求二：广告点击量实时统计

描述：实时统计每天各地区各城市各广告的点击总流量，并将其存入MySQL。

思路分析
1）单个批次内对数据进行按照天维度的聚合统计;
2）结合MySQL数据跟当前批次数据更新原有的数据。

MySQL建表

 CREATE TABLE area_city_ad_count (
  	dt CHAR(10),
  	area CHAR(4),
  	city CHAR(4),
  	adid CHAR(2),
    count BIGINT,
  	PRIMARY KEY (dt,area,city,adid)
  );

- 代码实现

 object Req2 {
	     def main(args: Array[String]): Unit = {
	  
	        //TODO 创建环境对象
	        //StreamingContext创建时，需要传递两个参数
	        //第一个参数表示环境配置
	        val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreaming")
	        //第二个参数表示批量处理的周期（采集周期）
	        val ssc: StreamingContext = new StreamingContext(sparkConf, Seconds(3))
	  
	        val kafkaPara: Map[String, Object] = Map[String, Object](
	           ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "hadoop102:9092,hadoop103:9092,hadoop104:9092",
	           ConsumerConfig.GROUP_ID_CONFIG -> "atguigu",
	           "key.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
	           "value.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer"
	        )
	  
	        val kafkaDataDS: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream[String, String](
	           ssc,
	           LocationStrategies.PreferConsistent,
	           ConsumerStrategies.Subscribe[String, String](Set("sqlboy"), kafkaPara)
	        )
	        val adClickData: DStream[AdClickData] = kafkaDataDS.map(
	           kafkaData => {
	              val data: String = kafkaData.value()
	              val datas: Array[String] = data.split(" ")
	              AdClickData(datas(0), datas(1), datas(2), datas(3), datas(4))
	           }
	        )
	        val reduceDS: DStream[((String, String, String, String), Int)] = adClickData.map(
	           data => {
	              val sdf: SimpleDateFormat = new SimpleDateFormat("yyyy-MM-dd")
	              val day: String = sdf.format(new Date(data.ts.toLong))
	              val area = data.area
	              val city = data.city
	              val ad = data.ad
	  
	              ((day, area, city, ad), 1)
	           }
	        ).reduceByKey(_ + _)
	  
	        reduceDS.foreachRDD(
	           rdd => {
	              rdd.foreachPartition(
	                 iter => {
	                    val conn: Connection = JDBCutil.getConnection
	                    val pstat: PreparedStatement = conn.prepareStatement(
	                       """
	                         |insert into area_city_ad_count(dt,area,city,adid, count)
	                         |values (?,?,?,?,?)
	                         |on DUPLICATE KEY
	                         |UPDATE count = count + ?
	                         |""".stripMargin)
	                    iter.foreach{
	                       case ((day, area, city, ad), sum) => {
	                                 pstat.setString(1,day)
	                                 pstat.setString(2,area)
	                                 pstat.setString(3,city)
	                                 pstat.setString(4,ad)
	                                 pstat.setInt(5,sum)
	                                 pstat.setInt(6,sum)
	                          pstat.executeUpdate()
	                       }
	                    }
	                    pstat.close()
	                    conn.close()
	                 }
	              )
	           }
	        )
	  
	  
	        ssc.start()
	        ssc.awaitTermination()
	     }
	  //广告点击数据
	  case class AdClickData(ts:String,area:String,city:String,user:String,ad:String)
	  }

7.5 需求三：最近一小时某个广告点击量趋势统计

结果展示：
1：List [15:50->10,15:51->25,15:52->30]
2：List [15:50->10,15:51->25,15:52->30]
3：List [15:50->10,15:51->25,15:52->30]

思路分析
1）开窗确定时间范围；
2）在窗口内将数据转换数据结构为((adid,hm),count);
3）按照广告id进行分组处理，组内按照时分排序。
- 代码实现

 object Req3 {
	     def main(args: Array[String]): Unit = {
	  
	        //TODO 创建环境对象
	        //StreamingContext创建时，需要传递两个参数
	        //第一个参数表示环境配置
	        val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("SparkStreaming")
	        //第二个参数表示批量处理的周期（采集周期）
	        val ssc: StreamingContext = new StreamingContext(sparkConf, Seconds(5))
	  
	        val kafkaPara: Map[String, Object] = Map[String, Object](
	           ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "hadoop102:9092,hadoop103:9092,hadoop104:9092",
	           ConsumerConfig.GROUP_ID_CONFIG -> "atguigu",
	           "key.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer",
	           "value.deserializer" -> "org.apache.kafka.common.serialization.StringDeserializer"
	        )
	  
	        val kafkaDataDS: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream[String, String](
	           ssc,
	           LocationStrategies.PreferConsistent,
	           ConsumerStrategies.Subscribe[String, String](Set("sqlboy"), kafkaPara)
	        )
	        val adClickData: DStream[AdClickData] = kafkaDataDS.map(
	           kafkaData => {
	              val data: String = kafkaData.value()
	              val datas: Array[String] = data.split(" ")
	              AdClickData(datas(0), datas(1), datas(2), datas(3), datas(4))
	           }
	        )
	  
	        //最近一分钟，每十秒计算一次
	        //涉及窗口的计算
	        val reduceDS: DStream[(Long, Int)] = adClickData.map(
	           data => {
	              val ts = data.ts.toLong
	              val newTs: Long = ts / 10000 * 10000
	              (newTs, 1)
	           }
	        ).reduceByKeyAndWindow(
	           (x: Int, y: Int) => {
	              x + y
	           },
	           Seconds(60),
	           Seconds(10)
	        )
	  
	        reduceDS.print()
	  
	        ssc.start()
	        ssc.awaitTermination()
	     }
	     //广告点击数据
	     case class AdClickData(ts:String,area:String,city:String,user:String,ad:String)
	  }