WordCountOnline（包含获取数据，在控制台输出；flatmap，maptopair，reducebykey；driver端和executor端区别，日志去重；foreachRD）

package com.bjsxt;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
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.api.java.function.VoidFunction;
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 scala.actors.threadpool.Arrays;
/**
 * 1.local的模拟线程数必须大于2 ，因为一条线程被receiver（接受数据的线程）占用，另一个线程是job执行
 * 2.Durations时间的设置，就是我们能接受的延迟度，这个我们需要根据集群的资源情况以及监控每一个job的执行时间来调节出最佳时间
 * 3.创建JavaStreamingContext有两种方式（SparkConf、SparkContext)
 * 4.业务逻辑完成以后，需要有一个output operator
 * 5.JavaStreamingContext.start()Streaming框架启动之后，是不能再次添加业务逻辑的
 * 6.JavaStreamingContext.stop()无参数的stop方法会将sparkContext一同关闭，stop（false),默认为true，会一同关闭
 * 7.JavaStreamingContxt.stop()停止之后，是不能再调用start
 * @author Administrator
 */
/**
 * foreach算子注意：
 * 1.foreachRDD是DStream中output operator类算子
 * 2.foreachRDD可以遍历得到DStream中的RDD，可以在这个算子内对RDD使用RDD的transformation类算子，进行转化，但是一定要用rdd的action类算子进行触发执行
 * 3.foreachRDD可以得到DStream中的RDD，在这个算子内，RDD算子外执行代码是在Driver端执行的，RDD算子内代码是在Executor中执行的。
 * 
 * @author Administrator
 *
 */
public class WordCountOnline {
    public static void main(String[] args) {
        /**
         * 这里的local一定要设置为2，因为其中一个线程接受数据的时候，是占用状态，需要另外一个线程输出
         */
        SparkConf conf=new SparkConf().setAppName("test").setMaster("local[2]");
        /**
         * 在创建streamcontext的时候，设置batch interval时间
         * 创建JavaStreamingContext有两种方式（SparkConf、SparkContext)
         */
        JavaStreamingContext jsc=new JavaStreamingContext(conf,Durations.seconds(5));
        /**
         * 去除重复的日志
         */
        jsc.sparkContext().setLogLevel("WARN");
        JavaReceiverInputDStream<String> lines = jsc.socketTextStream("node01", 9999);
        
        JavaDStream<String> words = lines.flatMap(new FlatMapFunction<String, String>() {

            @Override
            public Iterable<String> call(String s) throws Exception {
                System.out.println("*************************************");
                return Arrays.asList(s.split(" "));
            }
        });
        JavaPairDStream<String, Integer> ones = words.mapToPair(new PairFunction<String, String, Integer>() {

            @Override
            public Tuple2<String, Integer> call(String word) throws Exception {
                
                return new Tuple2<String,Integer>(word,1);
            }
        });
        JavaPairDStream<String, Integer> counts = ones.reduceByKey(new Function2<Integer, Integer, Integer>() {
            
            @Override
            public Integer call(Integer v1, Integer v2) throws Exception {
                
                return v1+v2;
            }
        });
        //outputoperttor类算子
        //counts.print()打印输出
        counts.foreachRDD(new VoidFunction<JavaPairRDD<String,Integer>>() {
            
            @Override
            public void call(JavaPairRDD<String, Integer> pairRDD) throws Exception {
                System.out.println("sdsdsdfj~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
                pairRDD.foreach(new VoidFunction<Tuple2<String,Integer>>() {

                    @Override
                    public void call(Tuple2<String, Integer> tuple) throws Exception {
                        System.out.println("tuple---------"+tuple);                        
                    }                    
                });    
            }
        });
        jsc.start();
        //等待spark程序被终止
        jsc.awaitTermination();
        jsc.stop(false);        
    }
}