Spark05_Streaming的使用

概述

介绍:

• SparkStreaming是一种用于流式数据的处理,准实时(秒级, 分钟)数据处理, 微批量数据处理的一种方式
• Spark Streaming 使用离散化流(discretized stream)作为抽象表示，叫作 DStream。DStream 就是对 RDD 在实时数据处理场景的一种封装。

---

图解:

---

背压机制

背压机制（即 Spark Streaming Backpressure）: 根据JobScheduler 反馈作业的执行信息来动态调整 Receiver 数据接收率。
通过属性“spark.streaming.backpressure.enabled”来控制是否启用 backpressure 机制，默认值false，即不启用

解决 : 可以解决接收的速率和消费的速率不对等产生的问题

---

以kafka为数据源进行消费

依赖:

<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>

代码:

package com.dxy.streaming

import org.apache.kafka.clients.consumer.ConsumerConfig
import org.apache.spark.{
    
    SPARK_BRANCH, SparkConf}
import org.apache.spark.storage.StorageLevel
import org.apache.spark.streaming.dstream.DStream
import org.apache.spark.streaming.kafka010.{
    
    ConsumerStrategies, KafkaUtils, LocationStrategies}
import org.apache.spark.streaming.receiver.Receiver
import org.apache.spark.streaming.{
    
    Duration, StreamingContext}

import scala.util.Random

object SparkStream03_kafka {
    
    

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

    val conf = new SparkConf().setAppName("Streaming").setMaster("local[*]")
    val sm = new StreamingContext(conf, Duration(5000))

    //定义kafka配置
    val kafkaPara: Map[String, Object] = Map[String, Object](
      ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG -> "hadoop202:9092,hadoop203:9092,hadoop204:9092",
      ConsumerConfig.GROUP_ID_CONFIG -> "user",
      "key.deserializer" ->
        "org.apache.kafka.common.serialization.StringDeserializer",
      "value.deserializer" ->
        "org.apache.kafka.common.serialization.StringDeserializer"
    )

    // 创建以kafka为数据源  
    /**
    第一个参数   StreamingContext对象
    第二个参数:  自动寻找本地位置
    第三个参数:  kafka配置, 以及消费的主题
    */
    val kafkaData = KafkaUtils.createDirectStream(
      sm,
      LocationStrategies.PreferConsistent,
       ConsumerStrategies.Subscribe[String, String](Set("spark_kafka_test"), kafkaPara)
    )

    val valueDStream: DStream[String] = kafkaData.map(record => record.value())
    //6.计算 WordCount
    valueDStream.flatMap(_.split(" "))
      .map((_, 1))
      .reduceByKey(_ + _)
      .print()


     sm.start()
    sm.awaitTermination()
  }
  
}

kafka produce生产数据:

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

      val conf = new SparkConf().setAppName("模拟kafka生产数据").setMaster("local[*]")
      val sm = new StreamingContext(conf, Duration(5000))

    val prop = new Properties()
    // 添加配置
    prop.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop202: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 produce = new KafkaProducer[String, String](prop)

     while (true){
    
    
        
       // 模拟创建数据
       mockData().foreach(
         data => {
    
    

           val record = new ProducerRecord[String, String]("spark_test1", data)
           produce.send(record)
           println(data)
         }
       )

       Thread.sleep(2000)

     }


    sm.start()
    sm.awaitTermination()
}