Spark Streaming Dstream Receiver

1.介绍
        是spark core的扩展，针对实时数据流处理,具有可扩展、高吞吐量、容错.
        数据可以是来自于kafka,flume,tcpsocket,使用高级函数(map reduce filter ,join , windows),
        处理的数据可以推送到database,hdfs,针对数据流处理可以应用到机器学习和图计算中。

        内部，spark接受实时数据流，分成batch(分批次)进行处理，最终在每个batch终产生结果stream.
        
        
2.discretized stream or DStream,
        离散流,表示的是连续的数据流。
        通过kafka、flume等输入数据流产生，也可以通过对其他DStream进行高阶变换产生。
        在内部，DStream是表现为RDD序列。

        准实时计算。batch,秒.

        DStream.map()
        DStream.updateStateByKey();

        batch interval :批次的间隔.

        windows length :窗口长度,跨批次。是批次的整数倍。

        slide interval :滑动间隔,窗口计算的间隔时间，有时批次interval的整倍数。

 

Spark Streaming使用

1.引入pom依赖

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

2.scala 类：

package com.mao.scala
import org.apache.spark._
import org.apache.spark.streaming._

object SparkStreamingDemo {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("sparkStreaming").setMaster("local[2]")
    //创建spark流上下文，批时长1s
    val ssc = new StreamingContext(conf, Seconds(1))
    //创建socket文本流
    val lines = ssc.socketTextStream("localhost", 9999)
    //压扁
    val words = lines.flatMap(_.split(" "))
    //变换成对偶
    val pairs = words.map(word => (word, 1))
    //聚合
    val wordCounts = pairs.reduceByKey(_ + _)
    wordCounts.print()
    //启动
    ssc.start()
    //等待结束
    ssc.awaitTermination()
  }
}

java类：

package com.mao.scala.java;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.Optional;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function2;
import org.apache.spark.api.java.function.PairFunction;
import org.apache.spark.streaming.Seconds;
import org.apache.spark.streaming.api.java.JavaDStream;
import org.apache.spark.streaming.api.java.JavaPairDStream;
import org.apache.spark.streaming.api.java.JavaReceiverInputDStream;
import org.apache.spark.streaming.api.java.JavaStreamingContext;
import scala.Some;
import scala.Tuple2;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;


public class JavaSparkStreamingWordCountApp {
    public static void main(String[] args) throws Exception {
        SparkConf conf = new SparkConf();
        conf.setAppName("wc");
        conf.setMaster("local[4]");
        //创建Spark流应用上下文
        JavaStreamingContext jsc = new JavaStreamingContext(conf, Seconds.apply(3));

        jsc.checkpoint("file:///d:/scala/check");
        //创建socket离散流
        JavaReceiverInputDStream sock = jsc.socketTextStream("localhost",9999);
        //压扁
        JavaDStream<String> wordsDS = sock.flatMap(new FlatMapFunction<String,String>() {
            public Iterator call(String str) throws Exception {
                List<String> list = new ArrayList<String>() ;
                String[] arr = str.split(" ");
                for(String s : arr){
                    list.add(s);
                }
                return list.iterator();
            }
        });

        //映射成元组
        JavaPairDStream<String,Integer> pairDS = wordsDS.mapToPair(new PairFunction<String, String, Integer>() {
            public Tuple2<String, Integer> call(String s) throws Exception {
                return new Tuple2<String,Integer>(s,1);
            }
        }) ;

        JavaPairDStream<String,Integer> jps = pairDS.updateStateByKey(new Function2<List<Integer>, Optional<Integer>, Optional<Integer>>() {
            public Optional<Integer> call(List<Integer> v1, Optional<Integer> v2) throws Exception {
                Integer newCount = v2.isPresent() ? v2.get() : 0  ;

                System.out.println("old value : " + newCount);
                for(Integer i : v1){
                    System.out.println("new value : " + i);
                    newCount = newCount +  i;
                }
                return Optional.of(newCount);
            }
        });

        //聚合
        JavaPairDStream<String,Integer> countDS = jps.reduceByKey(new Function2<Integer, Integer, Integer>() {
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1 + v2;
            }
        });

        //打印
        countDS.print();
        jsc.start();
        jsc.awaitTermination();
        jsc.stop();
    }
}

3.启动nc服务器
        [windows]
        cmd>nc -lL  -p 9999
    
    4.启动spark Streaming程序
        scala类或者java类
    5.在nc的命令行输入单词.
        hello world        ...
    6.观察spark计算结果。

导出stream程序的jar文件，丢到centos下运行。
    spark-submit --name wcstreaming 
                --class com.mao.spark.java.JavaSparkStreamingWordCountApp 
                --master spark://s201:7077 
                SparkDemo1-1.0-SNAPSHOT.jar

生产环境中spark streaming的job的注意事项
    避免单点故障。
    Driver            //驱动,运行用户编写的程序代码的主机。
    Executors        //执行的spark driver提交的job,内部含有附加组件比如receiver，
                    //receiver接受数据并以block方式保存在memory中，同时，将数据块复制到
                    //其他executor中，已备于容错。每个批次末端会形成新的DStream，交给
                    //下游处理。如果receiver故障，其他执行器中的receiver会启动进行数据的接收。

 

DStream:Discretized Streams 

离散流
    [注意事项]
    1.启动上下文之后，不能启动新的流或者添加新的
    2.上下 文停止后不能restart.
    3.同一JVM只有一个active的streamingcontext
    4.停止streamingContext会一同stop掉SparkContext，如若只停止StreamingContext.
      ssc.stop(false|true);
    5.SparkContext可以创建多个StreamingContext,创建新的之前停掉旧的。

DStream和Receiver
    1.介绍
        Receiver是接受者，从source接受数据，存储在内存中共spark处理。
    2.源
        基本源:fileSystem | socket,内置APAI支持。
        高级源:kafka | flume | ...，需要引入pom.xml依赖.
    3.注意
        使用local模式时，不能使用一个线程.使用的local[n]，n需要大于receiver的个数。