Java SparkStream WordCount

package stream;

import org.apache.spark.SparkConf;
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.Durations;
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.Tuple2;

import java.util.Arrays;

/**
 * Created by xupan on 2017/11/27.
 */
public class SparkStreamOnline {

    public static void main(String[] args) {
        /**
         * 第一步：配置SparkConf
         * 1：至少两条线程：由于Spark Stream运行的时候至少有一条线程不断循环接收数据
         * 而且至少有一条线程用于处理接收数据，若是没有线程处理数据，随着时间的推移，内存和磁盘都会不堪重负
         * 2：对于集群而言，每一个Executor不止一个线程，对于处理Spark Streaming的应用程序而言，每一个Executor
         * 通常分配多少core比较合适呢？通常5个左右的core是最佳的
         *
         **/
//        SparkConf conf = new SparkConf()
//                .setMaster("local[2]")
//                .setAppName("SparkStreamOnline");

        //运行在集群环境不用指定core，能够在提交的时候或则在默认配置【系统配置】中指定
        SparkConf conf = new SparkConf()
                .setMaster("spark://xupan001:7070")
                .setAppName("SparkStreamOnline");

        /**
         * 第二步：建立SparkStreamingContext，
         * 1：这SparkStreaming应用程序全部功能的起始点和程序调度的核心
         * JavaStreamingContext的构建基于SparkConf参数， 也能够基于持久化的SparkStreamContext的内容恢复过来（典型的场景就是Driver崩溃后继续上一次的状态，
         * 此时状态的恢复须要基于曾经的Checkpoint）
         * 2：在一个Spark Streaming程序中能够建立若干个SparkStreamingContext对象：使用下一个JavaStreamingContext
         * 以前须要把前面一个SparkStreaming对象关闭掉，由此咱们得到一个重大的启发SparkStreaming只是SparkCore上的一个
         * 应用程序，只不过SparkStreaming框架须要运行的话须要Spark工程师些业务程序处理代码
         */
        JavaStreamingContext stream = new JavaStreamingContext(conf, Durations.seconds(5));//每隔5秒钟

        /**
         *
         * 第三步：建立Spark Streaming输入数据来源Input Stream：
         * 1:数据能够是HDFS，File，KAFKA,Socket
         * 2:这里数据来源于网络端口，Spark Streaming 连接上该端口运行时一直监听该端口的数据，该端口服务必须先存在，而且后续会根据业务须要不断有数据产生
         * 3:若是常常间隔5秒没数据的话不断的启动空Job，会形成空Job，会形成调度资源的浪费，由于并无数据须要进行运算，因此生产环境中提交Job前会判断有无数据，若是没有就不提交job
         **/
        JavaReceiverInputDStream lines = stream.socketTextStream("local", 9999);

        /**
         * 第四步：接下来就像对于RDD编程同样基于DStream进行编程，缘由是DStreaming是RDD产生的模版或则说是类，在Spark Streaming具体发生计算前实质是把每一个Batch的DStreaming操做翻译成RDD操做
         **/
        final JavaDStream<String> words = lines.flatMap(new FlatMapFunction<String, String>() {
            public Iterable<String> call(String line) throws Exception {
                return Arrays.asList(line.split(" "));
            }
        });

        JavaPairDStream paris = words.mapToPair(new PairFunction<String, String, Integer>() {
            public Tuple2<String, Integer> call(String word) throws Exception {
                return new Tuple2<String, Integer>(word, 1);
            }
        });

        JavaPairDStream wordCount = paris.reduceByKey(new Function2<Integer, Integer, Integer>() {
            public Integer call(Integer v1, Integer v2) throws Exception {
                return v1 + v2;
            }
        });

        /**
         * Spark Streaming 要想运行具体的Job，DStream就必须有out put操做，
         * output stream 有不少触发函数，如：print saveAsTextFile saveAsHadoopFiles等，
         * 最重要的一个方式是：foreachRDD,由于Spark Streaming处理的结果通常都会放在redis，DB，DashBoard上面
         *
         * 此处的print不会触发job执行，由于如今一切都是在Spark Streaming控制下的
         * 对于Spark Streaming 而言job的触发基于Durations时间间隔
         */
        wordCount.print();

        /**
         * Spark Streaming 执行引擎也就是Driver开始运行，Driver启动的时候是位于一条新的线程中的，内部是由消息循环体用于接收
         * 应用程序自己或则Executor中的消息
         **/
        stream.start();

        stream.awaitTermination();

        stream.close();

    }
}