基于Kafka Dircet方式的实时WordCount

这种新的不基于Receiver的直接方式，是在Spark 1.3中引入的，从而能够确保更加健壮的机制。替代掉使用Receiver来接收数据后，这种方式会周期性地查询Kafka，来获得每个topic+partition的最新的offset，从而定义每个batch的offset的范围。当处理数据的job启动时，就会使用Kafka的简单consumer api来获取Kafka指定offset范围的数据。

这种方式有如下优点：

1. 简化并行读取：
如果要读取多个partition，不需要创建多个输入DStream然后对它们进行union操作。Spark会创建跟Kafka partition一样多的RDD partition，并且会并行从Kafka中读取数据。所以在Kafka partition和RDD partition之间，有一个一对一的映射关系。

2. 高性能：
如果要保证零数据丢失，在基于receiver的方式中，需要开启WAL机制。这种方式其实效率低下，因为数据实际上被复制了两份，Kafka自己本身就有高可靠的机制，会对数据复制一份，而这里又会复制一份到WAL中。而基于direct的方式，不依赖Receiver，不需要开启WAL机制，只要Kafka中作了数据的复制，那么就可以通过Kafka的副本进行恢复。

3. 一次且仅一次的事务机制：
基于receiver的方式，是使用Kafka的高阶API来在ZooKeeper中保存消费过的offset的。这是消费Kafka数据的传统方式。这种方式配合着WAL机制可以保证数据零丢失的高可靠性，但是却无法保证数据被处理一次且仅一次，可能会处理两次。因为Spark和ZooKeeper之间可能是不同步的。
基于direct的方式，使用kafka的简单api，Spark Streaming自己就负责追踪消费的offset，并保存在checkpoint中。Spark自己一定是同步的，因此可以保证数据是消费一次且仅消费一次。

kafka数据流创建：

JavaPairReceiverInputDStream<String, String> directKafkaStream = 
     KafkaUtils.createDirectStream(
                  streamingContext,
                  [key class],
                  [value class], 
                  [key decoder class],
                  [value decoder class],
                  [map of Kafka parameters], 
                  [set of topics to consume]
                 );

Java代码:
spark： 2.3
kafka：1.1.1
scala：2.11

package cn.spark.streaming;

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

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.Function;
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.JavaPairInputDStream;
import org.apache.spark.streaming.api.java.JavaStreamingContext;
import org.apache.spark.streaming.kafka.KafkaUtils;

import kafka.serializer.StringDecoder;
import scala.Tuple2;
/**
 * 基于kafka Dricet方式的wordcount
 *
 */
public class KafkaDriectWordCount {

    
    public static void main(String[] args) throws Exception{
        
        SparkConf conf = new SparkConf().setAppName("KafkaDriectWordCount");
        
        JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(10));
        
        // properties
        Map<String, String> kafkaparams = new HashMap<String, String>();
        kafkaparams.put("bootstrap.servers", "hserver-1:9092,hserver-2:9092,hserver-3:9092");
        kafkaparams.put("group.id", "KafkaDriectWordCount");
        kafkaparams.put("auto.offset.reset", args[0]);
        
        // topic list
        Set<String> topics = new HashSet<String>();
        topics.add(args[1]);
        
        // create DStream --> data struct: Tuple2<String, String> --> the first element is null
        JavaPairInputDStream<String,String> KafkaInputDStream = 
                KafkaUtils.createDirectStream(
                        jssc,
                        String.class,
                        String.class,
                        StringDecoder.class,
                        StringDecoder.class,
                        kafkaparams, 
                        topics
                        );
        
        // flatMap
        JavaDStream<String> WordDStream = KafkaInputDStream.flatMap(
                
                new FlatMapFunction<Tuple2<String,String>, String>() {

                    private static final long serialVersionUID = 1L;

                    @Override
                    public Iterator<String> call(Tuple2<String, String> tuple) throws Exception {
                        
                        return Arrays.asList(tuple._2.split(" ")).iterator();
                    }
                });
        
        // mapToPair
        JavaPairDStream<String, Integer> PairDStream = WordDStream.mapToPair(
                
                new PairFunction<String, String, Integer>() {

                    private static final long serialVersionUID = 1178400314423080582L;

                    @Override
                    public Tuple2<String, Integer> call(String word) throws Exception {
                        
                        return new Tuple2<String, Integer>(word, 1);
                    }
                });
        
        // reduceByKey
        JavaPairDStream<String, Integer> WordCountDStream = PairDStream.reduceByKey(
                
                new Function2<Integer, Integer, Integer>() {
                    
                    private static final long serialVersionUID = -4424371412114866268L;

                    @Override
                    public Integer call(Integer v1, Integer v2) throws Exception {
                        
                        return v1 + v2;
                    }
                });
        
        // sort 
        JavaPairDStream<String, Integer> resultDStream =  WordCountDStream.transformToPair(
                
                new Function<JavaPairRDD<String,Integer>, JavaPairRDD<String,Integer>>() {

                    private static final long serialVersionUID = -4037579884645976648L;

                    @Override
                    public JavaPairRDD<String, Integer> call(JavaPairRDD<String, Integer> inputPairRDD) throws Exception {
                        
                        // swap key - value
                        JavaPairRDD<Integer, String> reseverPairRDD = inputPairRDD.mapToPair(
                                
                                new PairFunction<Tuple2<String,Integer>, Integer, String>() {

                                    private static final long serialVersionUID = 8784589314191257879L;

                                    @Override
                                    public Tuple2<Integer, String> call(Tuple2<String, Integer> tuple) throws Exception {

                                        return new Tuple2<Integer, String>(tuple._2, tuple._1);
                                    }
                                });
                        
                        // sortByKey
                        JavaPairRDD<Integer, String> sortPairRDD = reseverPairRDD.sortByKey(false);
                        
                        // swap key - value
                        JavaPairRDD<String, Integer> resultPairRDD = sortPairRDD.mapToPair(
                                
                                new PairFunction<Tuple2<Integer,String>, String, Integer>() {

                                    private static final long serialVersionUID = 8784589314191257879L;

                                    @Override
                                    public Tuple2<String, Integer> call(Tuple2<Integer, String> tuple) throws Exception {

                                        return new Tuple2<String, Integer>(tuple._2, tuple._1);
                                    }
                                });
                        
                        
                        return resultPairRDD;
                    }
                });
        
        resultDStream.print();
        
        jssc.start();
        
        jssc.awaitTermination();
        
        jssc.close();
        
        
    }
}