Structured Streaming详解及实用样例

Structured Streaming

什么是Structured Streaming

泛指使用SQL操作Spark的流处理。Structured Streaming是一个scalable 和 fault-tolerant 流处理引擎，该引擎是构建Spark SQL之上。可以使得用户以静态批处理的方式去计算流处理。Structured Streaming底层毁掉用SparkSQL 引擎对流数据做增量和持续的更新计算并且输出最终结果。用户可以使用 Dataset/DataFrame API完成流处理中的常见问题：aggregations-聚合统计、event-time window-事件窗口、stream-to-batch/stream-to-stream join连接等功能。Structured Streaming可以通过 checkpointing （检查点）和 Write-Ahead Logs（写前日志）机制实现end-to-end（端到端）、exactly-once（进准一次）语义容错机制。总之Structured Streaming提供了 快速、可扩展、容错、端到端的精准一次的流处理，无需用户过多的干预。

Structured Streaming底层计算引擎默认采取的是micro-batch处理引擎（DStream一致的），除此之外Spark还提供了其它的处理模型可供选择：micro-batch-100ms、Fixed interval micro-batches、One-time micro-batch、Continuous Processing-1ms(实验)

快速入门

• pom

<properties>
    <spark.version>2.4.3</spark.version>
    <scala.version>2.11</scala.version>
</properties>
<dependencies>
    <dependency>
        <groupId>org.apache.spark</groupId>
        <artifactId>spark-sql_${scala.version}</artifactId>
        <version>${spark.version}</version>
    </dependency>
</dependencies>

• Driver 程序

//1.创建sparksession
val spark = SparkSession
.builder
.appName("StructuredNetworkWordCount")
.master("local[5]")
.getOrCreate()
import spark.implicits._
spark.sparkContext.setLogLevel("FATAL")

//2.通过流的方式创建Dataframe - 细化
val lines = spark.readStream
.format("socket")
.option("host", "CentOS")
.option("port", 9999)
.load()

//3.执行SQL操作 API    - 细化 窗口等
val wordCounts = lines.as[String].flatMap(_.split(" "))
.groupBy("value").count()


//4.构建StreamQuery 将结果写出去 - 细化
val query = wordCounts.writeStream
.outputMode("complete") //表示全量输出，等价于 updateStateByKey
.format("console")
.start()

//5.关闭流
query.awaitTermination()

常规概念

结构化流处理中的关键思想是将实时数据流视为被连续追加的表。将输入数据流视为“Input Table”。流上到达的每个数据项都像是将新行附加到Input Table中。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XHxXUltA-1606729413963)(assets/1570693628976.png)]

对Input Table的查询将生成“Result Table”。每个触发间隔（例如，每1秒钟），新行将附加到Input Table中，最终更新Result Table。无论何时更新Result Table，我们都希望将更改后的结果行写入外部接收器（sink）。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4LXXAUd6-1606729413965)(assets/1570694216166.png)]

“输出”定义为写到外部存储器的内容。输出支持一下模式的输出：

• Complete Mode（状态） - 整个更新的结果表将被写入外部存储器。由存储连接器决定如何处理整个表的写入。
• Update Mode（状态） - 自上次触发以来，仅结果表中已更新的行将被写入外部存储（Spark 2.1.1），如果没有聚合该策略等价于Append Mode
• Append Mode（无状态） - 自上次触发以来，仅追加到结果表中的新行将被写入外部存储。这仅适用于结果表中现有行预计不会更改的查询。（Append也可以用在含有聚合的查询中，但是仅仅限制在窗口计算-后续讨论）

注意：

1. Spark 并不会存储 Input Table 的数据，一旦处理完数据之后，就将接收的数据丢弃。Spark仅仅维护的是计算的中间结果（状态）

2）Structured Stream好处在于用户无需维护 计算状态（相比较于Storm流处理），Spark就可以实现end-to-end（端到端）、exactly-once（进准一次）语义容错机制。

输入和输出

输入

√Kafka source

<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-sql-kafka-0-10_${scala.version}</artifactId>
    <version>${spark.version}</version>
</dependency>

//1.创建sparksession
val spark = SparkSession
.builder
.appName("StructuredNetworkWordCount")
.master("local[6]")
.getOrCreate()
import spark.implicits._
spark.sparkContext.setLogLevel("FATAL")

//2.通过流的方式创建Dataframe
val df = spark.readStream
    .format("kafka")
    .option("kafka.bootstrap.servers", "CentOS:9092")
    .option("subscribe", "topic01")
    .load()

//3.执行SQL操作 API
import org.apache.spark.sql.functions._

val wordCounts = df.selectExpr("CAST(key AS STRING)", "CAST(value AS STRING)", "partition", "offset", "CAST(timestamp AS LONG)")
    .flatMap(row => row.getAs[String]("value").split("\\s+"))
    .map((_, 1))
    .toDF("word", "num")
    .groupBy($"word")
    .agg(sum($"num"))

//4.构建StreamQuery 将结果写出去
val query = wordCounts.writeStream
    .outputMode(OutputMode.Update())
    .format("console")
    .start()

//5.关闭流
query.awaitTermination()

FileSource(了解)

//1.创建sparksession
    val spark = SparkSession
      .builder
      .appName("StructuredNetworkWordCount")
      .master("local[6]")
      .getOrCreate()
    import spark.implicits._
    spark.sparkContext.setLogLevel("FATAL")

    //2.通过流的方式创建Dataframe - 细化
    val schema = new StructType()
                    .add("id",IntegerType)
                    .add("name",StringType)
                    .add("age",IntegerType)
                    .add("dept",IntegerType)

    val df = spark.readStream
        .schema(schema)
        .format("json")
        .load("file:///D:/demo/json")
   
    //3 。SQL操作
    // 略
    //4.构建StreamQuery 将结果写出去
    val query = df.writeStream
      .outputMode(OutputMode.Update())
      .format("console")
      .start()
     //5.关闭流
     query.awaitTermination()

输出

File sink(了解)

val spark = SparkSession
.builder
.appName("filesink")
.master("local[6]")
.getOrCreate()
import spark.implicits._
spark.sparkContext.setLogLevel("FATAL")

val lines = spark.readStream
.format("socket")
.option("host", "CentOS")
.option("port", 9999)
.load()

val wordCounts=lines.as[String].flatMap(_.split("\\s+"))
.map((_,1))
.toDF("word","num")

val query = wordCounts.writeStream
.outputMode(OutputMode.Append())
.option("path", "file:///D:/write/json")
.option("checkpointLocation", "file:///D:/checkpoints") //需要指定检查点
.format("json")
.start()

query.awaitTermination()

仅仅只支持Append Mode,所以一般用作数据的清洗，不能做为数据分析（聚合）输出。

√Kafka Sink

val spark = SparkSession
.builder
.appName("filesink")
.master("local[6]")
.getOrCreate()
import spark.implicits._
spark.sparkContext.setLogLevel("FATAL")

val lines = spark.readStream
.format("socket")
.option("host", "CentOS")
.option("port", 9999)
.load()

//import org.apache.spark.sql.functions._
//001 zhangsan iphonex 15000
val userCost=lines.as[String].map(_.split("\\s+"))
.map(ts=>(ts(0),ts(1),ts(3).toDouble))
.toDF("id","name","cost")
.groupBy