spark复习笔记(7):sparkstreaming

一、介绍

　　1.sparkStreaming是核心模块Spark API的扩展，具有可伸缩，高吞吐量以及容错的实时数据流处理等。数据可以从许多来源（如Kafka，Flume，Kinesis或TCP套接字）中获取。并且可以使用以高级函数表示的复杂算法进行处理map，例如reduce，join和window。最后，处理后的数据可以推送到文件系统，数据库和实时仪表盘。[DStresam]:离散流，连续的RDD序列。准实时计算，以batch处理作业。

　　2.在内部，它的工作原理如下。Spark Streaming接收实时输入数据流并将数据分成批处理，然后由Spark引擎处理，以批量生成最终结果流。

　　3.sparkStreaming提供了一个高级的抽象discretized stream称之为DStream，表示连续的数据流。DStream可以通过像Kafka，Flume和Kinesis等源的输入数据流创建。或者通过应用在其他DStream上应用高级的操作得来。在内部DStream也表现为RDD序列。

　　4.在我们详细介绍如何编写自己的Spark Streaming程序之前，让我们快速了解一下简单的Spark Streaming程序是什么样的。假设我们想要计算从TCP套接字上侦听的数据服务器接收的文本数据中的字数。您需要做的就是如下。

二、体验spark Streaming

　　1.pom.xml文件

<dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming_2.11</artifactId>
            <version>2.1.0</version>
 </dependency>

　　2.编写程序

package com.jd.spark.scala

import org.apache.spark._
import org.apache.spark.streaming._
import org.apache.spark.streaming.StreamingContext._

object SparkStreamingDemo {
  def main(args: Array[String]): Unit = {
    //这个地方要注意，并发线程数要大于1，创建一个配置对象，将其设置为本地模式，
    val conf = new SparkConf().setMaster("local[2]").setAppName("NetworkWordCount");
    //创建sparkStreaming上下文,批次时长是1s
    val ssc = new StreamingContext(conf,Seconds(1));
    //创建套接字文本流
    val lines = ssc.socketTextStream("localhost",9999);
    //将读取进来的行进行压扁操作,这个地方返回的都是离散流DStream
    val words = lines.flatMap(_.split(" "))
    //变换成对偶
    val pairs = words.map((_,1));
    //聚合操作
    val count = pairs.reduceByKey(_ +_);
    count.print();
    //开始进行相关的计算，等待其停止
    ssc.start();
    //等待结束
    ssc.awaitTermination()
  }

}

　　3.启动nc服务器

　　4.导出stream程序的jar文件，丢到centos上去运行

　　　　(1)

　　　　(2)

　　　　(3)spark-submit  --class com.jd.spark.scala.SparkStreamingDemo SparkDemo1-1.0-SNAPSHOT.jar

三、Kafka+ Spark Streaming做流计算

　　0.启动kafka集群

　　　　a)启动zk:zkServer.sh start

　　　　b)启动kafka: bin/kafka-server-start.sh config/server.properties

　　　　c)验证kafka服务器是否成功

　　　　　　$>netstat -anop | grep 9092

　　　　d)创建主题

　　　　　　$>bin/kafka-topics.sh --create --zookeeper s11:2181 --replication-factor 3 --partitions 3 --topic test1

　　　　e)查看主题列表

　　　　　　$>bin/kafka-topics.sh --list --zookeeper s11:2181

　　　　f)启动控制台生产者

　　　　　　$>bin/kafka-console-producer.sh --broker-list s12:9092 --topic test1

　　　　g)启动控制台消费者

　　　　　　$>bin/kafka-console-consumer.sh --bootstrap-server s12:9092 --topic test --from-beginning --zookeeper s202:2181

　　1.引入pom.xml文件 

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

　　2.Option[T]可选的

　　　　None　　　　//

　　　　

　　3.

　　4.

三、windows：窗口化操作

　　1.batch interval:批次的间隔

　　2.windows length:窗口长度，跨批次。批次的整数倍

　　3.slide interval:滑动间隔，窗口计算的间隔时间，也是批次的整倍数

　　4.reduceByKeyAndWindow():按照key和窗口进行聚合。

　　　　reduceByKeyAndWindow(_ + _,windows length,sliding interval)

四、持久化

　　1.memory_only

　　2.memory_ser

　　3.spark-submit --class 

五、生产环境下spark streaming的job的注意事项

　　避免单点故障。

　　Driver　　　　//　　驱动，运行用户编写的程序代码的主机

　　Excutors　　  //执行的spark driver提交的作业，内部含有附加组件，比如receiver,receiver接收数据并以block的方式保存在内存中，同时将数据块复制到其他的executor中，以备容错。每个批次的末端会形成新的DStream。如果receiver故障，其他执行程序会接收

　　spark streaming 实现容错

　　　　如果executor发生故障，所有未被处理的数据都会丢失，解决办法可以通过wal方式将数据预先写入到hdfs或者s3

　　　　如果Driver故障的，Driver程序会停止，所有的执行程序都会失去连接，他们会结束计算。解决办法，自动配置和编程

　　　　　　1:配置Driver程序，自动重启，配置自动重启，使用特定的集群管理器来实现

　　　　　　2.重启的时候，从宕机的地方开始重启，通过检查点记住可以实现该功能

　　　　　　　　//目录可以是本地，也可以是hdfs

　　　　　　　　jsc.checkpoint("d://....................");

　　　　　　　　不再使用new方式创建SparkStreamContext对象，而是通过工厂的方式JavaStreamingContext.getOrCreate()方式来创建上下文对象。首先会检查检查点目录，看是否有job运行,