spark学习记录（十三、SparkStreaming）

一、SparkStreaming简介

SparkStreaming是流式处理框架，是Spark API的扩展，支持可扩展、高吞吐量、容错的实时数据流处理，实时数据的来源可以是：Kafka, Flume, Twitter, ZeroMQ或者TCP sockets，并且可以使用高级功能的复杂算子来处理流数据。例如：map,reduce,join,window 。最终，处理后的数据可以存放在文件系统，数据库等，方便实时展现。

SparkStreaming与Storm的区别:

Storm是纯实时的流式处理框架，SparkStreaming是准实时的处理框架（微批处理）。因为微批处理，SparkStreaming的吞吐量比Storm要高。Storm是来一条数据就处理一次，SparkStreaming是处理某段时间内来的数据。
Storm 的事务机制要比SparkStreaming的要完善。
Storm支持动态资源调度。(spark1.2开始和之后也支持)
SparkStreaming擅长复杂的业务处理，Storm不擅长复杂的业务处理，擅长简单的汇总型计算。

receiver task是7*24小时一直在执行，一直接收数据，将一段时间内接收来的数据保存到batch中。假设batchInterval为5s,那么会将接收来的数据每隔5秒封装到一个batch中，batch没有分布式计算特性，这一个batch的数据又被封装到一个RDD中，RDD最终封装到一个DStream中。

例如：假设batchInterval为5秒，每隔5秒通过SparkStreamin将得到一个DStream,在第6秒的时候计算这5秒的数据，假设执行任务的时间是3秒,那么第6~9秒一边在接收数据，一边在计算任务，9~10秒只是在接收数据。然后在第11秒的时候重复上面的操作。

如果job执行的时间大于batchInterval会有什么样的问题？

如果接受过来的数据设置的级别是仅内存，接收来的数据会越堆积越多，最后可能会导致OOM（如果设置StorageLevel包含disk, 则内存存放不下的数据会溢写至disk, 加大延迟）

二、java代码

添加依赖：

<dependency>
    <groupId>org.apache.spark</groupId>
    <artifactId>spark-streaming_2.12</artifactId>
    <version>2.4.0</version>
    <scope>provided</scope>
</dependency>

在hadoop1上输入命令：

nc -lk 9999
hello Sam
hello Tom
hello Jetty

public class JavaExample {
    public static void main(String[] args) throws InterruptedException {
        SparkConf conf = new SparkConf();
        conf.setMaster("local[2]");
        conf.setAppName("SparkStreamingTest");

        JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(5));

        JavaReceiverInputDStream<String> stream = jsc.socketTextStream("192.168.30.141", 9999);

        final JavaDStream<String> words = stream.flatMap(new FlatMapFunction<String, String>() {
            public Iterator<String> call(String s) throws Exception {
                return Arrays.asList(s.split(" ")).iterator();
            }
        });
        JavaPairDStream<String, Integer> pair = words.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> reduceByKey = pair.reduceByKey(new Function2<Integer, Integer, Integer>() {
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1 + v2;
            }
        });

        //打印输出
        reduceByKey.print();
        /**
         * foreachRDD可以拿到DStream中的RDD，对拿到的RDD可以使用RDD的transformations算子转换，
         * 要对拿到的RDD使用action触发执行，否则foreachRDD也不会执行
         * foreachRDD中call方法内，拿到RDD的算子外，代码在Driver执行，
         * 可以使用这个算子实现动态改变广播变量，即广播读取一个文件，只修改文件内容，不停止代码
         */
        reduceByKey.foreachRDD(new VoidFunction<JavaPairRDD<String, Integer>>() {
            public void call(JavaPairRDD<String, Integer> rdd) throws Exception {
                //SparkStreaming广播变量
                SparkContext context = rdd.context();
                JavaSparkContext javaSparkContext = new JavaSparkContext(context);
                Broadcast<String> broadcast = javaSparkContext.broadcast("hello");
                System.out.println(broadcast.getValue());

                JavaPairRDD<String, Integer> mapToPair = rdd.mapToPair(new PairFunction<Tuple2<String, Integer>, String, Integer>() {
                    public Tuple2<String, Integer> call(Tuple2<String, Integer> tuple2) throws Exception {
                        return new Tuple2<String, Integer>(tuple2._1 + "~", tuple2._2);
                    }
                });
                mapToPair.foreach(new VoidFunction<Tuple2<String, Integer>>() {
                    public void call(Tuple2<String, Integer> tuple2) throws Exception {
                        System.out.println(tuple2);
                    }
                });
            }
        });
        jsc.start();
        jsc.awaitTermination();
    }
}

三、算子

/**
 * updateStateByKey:
 * 返回一个新的“状态”Dstream,通过给定的func来更新之前的每个状态的key对应的value值，这也可以用于维护key的任意状态数据。
 * 注意：作用在（K,V）格式的DStream上
 * <p>
 * updateStateByKey的主要功能:
 * 1、Spark Streaming中为每一个Key维护一份state状态，state类型可以是任意类型的的， 可以是一个自定义的对象，那么更新函数也可以是自定义的。
 * 2、通过更新函数对该key的状态不断更新，对于每个新的batch而言，Spark Streaming会在使用updateStateByKey的时候为已经存在的key进行
 * state的状态更新
 * （对于每个新出现的key，会同样的执行state的更新函数操作），
 * 如果要不断的更新每个key的state，就一定涉及到了状态的保存和容错，这个时候就需要开启checkpoint机制和功能
 *
 * @author root
 */
public class Operate_updateStateByKey {
    public static void main(String[] args) throws InterruptedException {
        SparkConf conf = new SparkConf().setMaster("local").setAppName("Operate_count");
        JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(5));
        /**
         * checkpoint存储地址
         * 如果batchInterval小于10，那么10s会将内存中的数据写入硬盘中
         * 如果batchInterval大于10，那么以batchInterval为准
         *
         * 这样做是为了防止频繁的写hdfs
         */
        jsc.checkpoint("checkpoint");
        //读取文件存储地址
        JavaDStream<String> textFileStream = jsc.textFileStream("data");
        /**
         * 实现一个累加统计word的功能
         */
        JavaPairDStream<String, Integer> mapToPair = textFileStream.flatMap(new FlatMapFunction<String, String>() {
            private static final long serialVersionUID = 1L;

            public Iterator<String> call(String t) throws Exception {

                return Arrays.asList(t.split(" ")).iterator();
            }
        }).mapToPair(new PairFunction<String, String, Integer>() {

            private static final long serialVersionUID = 1L;

            public Tuple2<String, Integer> call(String t) throws Exception {
                return new Tuple2<String, Integer>(t.trim(), 1);
            }
        });

        JavaPairDStream<String, Integer> updateStateByKey = mapToPair.updateStateByKey(new Function2<List<Integer>, Optional<Integer>, Optional<Integer>>() {
            private static final long serialVersionUID = 1L;

            public Optional<Integer> call(List<Integer> values, Optional<Integer> state)
                    throws Exception {
                /**
                 * values:经过分组最后 这个key所对应的value  [1,1,1,1,1]
                 * state:这个key在本次之前之前的状态
                 */
                Integer updateValue = 0;

                if (state.isPresent()) {
                    updateValue = state.get();
                }
                for (Integer i : values) {
                    updateValue += i;
                }
                return Optional.of(updateValue);
            }
        });

        updateStateByKey.print();

        jsc.start();
        jsc.awaitTermination();
        jsc.close();
    }

}

public class Operate_window {
    public static void main(String[] args) throws InterruptedException {
        SparkConf conf = new SparkConf();
        conf.setMaster("local[2]");
        conf.setAppName("Operate_window");
        JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(5));
        /**
         * 设置日志级别
         */
        jsc.sparkContext().setLogLevel("WARN");
        //设置checkpoint
        jsc.checkpoint("./checkpoint");
        JavaReceiverInputDStream<String> textStream = jsc.socketTextStream("192.168.30.141", 9999);
//        切分
        JavaDStream<String> flatMap = textStream.flatMap(new FlatMapFunction<String, String>() {
            public Iterator<String> call(String s) throws Exception {
                return Arrays.asList(s.split(" ")).iterator();
            }
        });
//        计数
        JavaPairDStream<String, Integer> mapToPair = flatMap.mapToPair(new PairFunction<String, String, Integer>() {
            public Tuple2<String, Integer> call(String s) throws Exception {
                return new Tuple2<String, Integer>(s, 1);
            }
        });
        /**
         *每个10s，计算最近60s内的数据，那么这个窗口大小为60s，里面有12个rdd，在没有计算之前，这些rdd是不会计算的
         * 那么在计算的时候会将这12个rdd聚合起来，然后一起执行reduceByKeyAndWindow，
         * reduceByKeyAndWindow是针对窗口操作而不是DStream
         */
        JavaPairDStream<String, Integer> reduceByKeyAndWindow = mapToPair.reduceByKeyAndWindow(new Function2<Integer, Integer, Integer>() {
            public Integer call(Integer v1, Integer v2) throws Exception {
                //加上新进窗口的批次
                return v1 + v2;
            }
            //每隔5s计算最近15s的数据，这两个参数要是bathInterval的整数倍即上面设置的5s的整数倍
        }, new Function2<Integer, Integer, Integer>() {
            public Integer call(Integer v1, Integer v2) throws Exception {
                //减去新离开窗口的批次
                return v1 - v2;
            }
        }, Durations.seconds(15), Durations.seconds(5));

        reduceByKeyAndWindow.print();
        jsc.start();
        jsc.awaitTermination();
        jsc.close();
    }
}

public class Operate_transform {
    public static void main(String[] args) throws InterruptedException {
        SparkConf conf = new SparkConf();
        conf.setMaster("local[2]").setAppName("Operate_transform");
        JavaStreamingContext jsc = new JavaStreamingContext(conf, Durations.seconds(5));
        //黑名单
        List<String> list = Arrays.asList("Sam");
        final Broadcast<List<String>> broadcast = jsc.sparkContext().broadcast(list);

        JavaReceiverInputDStream<String> stream = jsc.socketTextStream("192.168.30.141", 9999);

        JavaPairDStream<String, String> mapToPair = stream.mapToPair(new PairFunction<String, String, String>() {
            public Tuple2<String, String> call(String s) throws Exception {
                return new Tuple2<String, String>(s.split(" ")[1], s);
            }
        });
        /**
         * 过滤黑名单上的名字
         * transform可以拿到DStream中的RDD，做RDD到RDD之间的转换，不需要Action算子触发，需要返回类型RDD
         * 注意：transform call方法内，拿到RDD算子外的代码在Driver端执行，也可以做到动态改变广播变量
         */
        JavaDStream<String> transform = mapToPair.transform(new Function<JavaPairRDD<String, String>, JavaRDD<String>>() {
            public JavaRDD<String> call(JavaPairRDD<String, String> nameRDD) throws Exception {
                //数据过滤
                JavaPairRDD<String, String> filter = nameRDD.filter(new Function<Tuple2<String, String>, Boolean>() {
                    public Boolean call(Tuple2<String, String> tuple2) throws Exception {
                        return !broadcast.getValue().contains(tuple2._1);
                    }
                });

                JavaRDD<String> map = filter.map(new Function<Tuple2<String, String>, String>() {
                    public String call(Tuple2<String, String> tuple2) throws Exception {
                        return tuple2._2;
                    }
                });

                return map;
            }
        });

        transform.print();

        jsc.start();
        jsc.awaitTermination();
        jsc.close();

    }
}

spark学习记录（十三、SparkStreaming）

一、SparkStreaming简介

二、java代码

三、算子

猜你喜欢