kafka java doc_基于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 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 kafkaparams = new HashMap();

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 topics = new HashSet();

topics.add(args[1]);

// create DStream --> data struct: Tuple2 --> the first element is null

JavaPairInputDStream KafkaInputDStream =

KafkaUtils.createDirectStream(

jssc,

String.class,

String.class,

StringDecoder.class,

StringDecoder.class,

kafkaparams,

topics

);

// flatMap

JavaDStream WordDStream = KafkaInputDStream.flatMap(

new FlatMapFunction, String>() {

private static final long serialVersionUID = 1L;

@Override

public Iterator call(Tuple2 tuple) throws Exception {

return Arrays.asList(tuple._2.split(" ")).iterator();

}

});

// mapToPair

JavaPairDStream PairDStream = WordDStream.mapToPair(

new PairFunction() {

private static final long serialVersionUID = 1178400314423080582L;

@Override

public Tuple2 call(String word) throws Exception {

return new Tuple2(word, 1);

}

});

// reduceByKey

JavaPairDStream WordCountDStream = PairDStream.reduceByKey(

new Function2() {

private static final long serialVersionUID = -4424371412114866268L;

@Override

public Integer call(Integer v1, Integer v2) throws Exception {

return v1 + v2;

}

});

// sort

JavaPairDStream resultDStream = WordCountDStream.transformToPair(

new Function, JavaPairRDD>() {

private static final long serialVersionUID = -4037579884645976648L;

@Override

public JavaPairRDD call(JavaPairRDD inputPairRDD) throws Exception {

// swap key - value

JavaPairRDD reseverPairRDD = inputPairRDD.mapToPair(

new PairFunction, Integer, String>() {

private static final long serialVersionUID = 8784589314191257879L;

@Override

public Tuple2 call(Tuple2 tuple) throws Exception {

return new Tuple2(tuple._2, tuple._1);

}

});

// sortByKey

JavaPairRDD sortPairRDD = reseverPairRDD.sortByKey(false);

// swap key - value

JavaPairRDD resultPairRDD = sortPairRDD.mapToPair(

new PairFunction, String, Integer>() {

private static final long serialVersionUID = 8784589314191257879L;

@Override

public Tuple2 call(Tuple2 tuple) throws Exception {

return new Tuple2(tuple._2, tuple._1);

}

});

return resultPairRDD;

}

});

resultDStream.print();

jssc.start();

jssc.awaitTermination();

jssc.close();

}

}