1、基于Receiver的方式java
一、概述apache
基于Receiver的方式： Receiver是使用Kafka的高层次Consumer API来实现的。receiver从Kafka中获取的数据都是存储在Spark Executor的内存中的， 而后Spark Streaming启动的job会去处理那些数据。 然而，在默认的配置下，这种方式可能会由于底层的失败而丢失数据。若是要启用高可靠机制，让数据零丢失，就必须启用Spark Streaming的 预写日志机制（Write Ahead Log，WAL）。该机制会同步地将接收到的Kafka数据写入分布式文件系统（好比HDFS）上的预写日志中。因此， 即便底层节点出现了失败，也可使用预写日志中的数据进行恢复。 如何进行Kafka数据源链接？ 1、在maven添加依赖 groupId = org.apache.spark artifactId = spark-streaming-kafka_2.10 version = 1.5.1 2、使用第三方工具类建立输入DStream JavaPairReceiverInputDStream<String, String> kafkaStream = KafkaUtils.createStream(streamingContext, [ZK quorum], [consumer group id], [per-topic number of Kafka partitions to consume]); 须要注意的要点： 1、Kafka中的topic的partition，与Spark中的RDD的partition是没有关系的。因此，在KafkaUtils.createStream()中， 提升partition的数量，只会增长一个Receiver中，读取partition的线程的数量。不会增长Spark处理数据的并行度。 2、能够建立多个Kafka输入DStream，使用不一样的consumer group和topic，来经过多个receiver并行接收数据。 3、若是基于容错的文件系统，好比HDFS，启用了预写日志机制，接收到的数据都会被复制一份到预写日志中。所以， 在KafkaUtils.createStream()中，设置的持久化级别是StorageLevel.MEMORY_AND_DISK_SER。 Kafka命令： bin/kafka-topics.sh --zookeeper 192.168.1.107:2181,192.168.1.108:2181,192.168.1.109:2181 --topic TestTopic --replication-factor 1 --partitions 1 --create bin/kafka-console-producer.sh --broker-list 192.168.1.107:9092,192.168.1.108:9092,192.168.1.109:9092 --topic TestTopic [ZK quorum： 192.168.1.191:2181,192.168.1.192:2181,192.168.1.193:2181
二、java版本api
package cn.spark.study.streaming; import java.util.Arrays; import java.util.HashMap; import java.util.Map; 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.JavaPairReceiverInputDStream; import org.apache.spark.streaming.api.java.JavaStreamingContext; import org.apache.spark.streaming.kafka.KafkaUtils; import scala.Tuple2; /** * 基于Kafka receiver方式的实时wordcount程序 * @author Administrator * */ public class KafkaReceiverWordCount { public static void main(String[] args) { SparkConf conf = new SparkConf() .setMaster("local[2]") .setAppName("KafkaWordCount"); JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(5)); // 使用KafkaUtils.createStream()方法，建立针对Kafka的输入数据流 Map<String, Integer> topicThreadMap = new HashMap<String, Integer>(); // 使用多少个线程去拉取topic的数据 topicThreadMap.put("WordCount", 1); // 这里接收的四个参数；第一个：streamingContext // 第二个：ZK quorum； 第三个：consumer group id 能够本身写； // 第四个：per-topic number of Kafka partitions to consume JavaPairReceiverInputDStream<String, String> lines = KafkaUtils.createStream( jssc, "192.168.1.135:2181,192.168.1.136:2181,192.168.1.137:2181", "DefaultConsumerGroup", topicThreadMap); // wordcount逻辑 JavaDStream<String> words = lines.flatMap( new FlatMapFunction<Tuple2<String,String>, String>() { private static final long serialVersionUID = 1L; @Override public Iterable<String> call(Tuple2<String, String> tuple) throws Exception { return Arrays.asList(tuple._2.split(" ")); } }); JavaPairDStream<String, Integer> pairs = words.mapToPair( new PairFunction<String, String, Integer>() { private static final long serialVersionUID = 1L; @Override public Tuple2<String, Integer> call(String word) throws Exception { return new Tuple2<String, Integer>(word, 1); } }); JavaPairDStream<String, Integer> wordCounts = pairs.reduceByKey( new Function2<Integer, Integer, Integer>() { private static final long serialVersionUID = 1L; @Override public Integer call(Integer v1, Integer v2) throws Exception { return v1 + v2; } }); wordCounts.print(); jssc.start(); jssc.awaitTermination(); jssc.close(); } } ##运行程序 ##新建一个topic [root@spark1 kafka]# bin/kafka-topics.sh --zookeeper 192.168.1.135:2181,192.168.1.136:2181,192.168.1.137:2181 --topic WordCount --replication-factor 1 --partitions 1 --create ##启动生产者，而后能够输入一些数据，观察程序端的输出统计 [root@spark1 kafka]# bin/kafka-console-producer.sh --broker-list 192.168.1.135:9092,192.168.1.136:9092,192.168.1.137:9092 --topic WordCount
2、基于Direct的方式maven
一、概述分布式
这种新的不基于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本身必定是同步的，所以能够保证数据 是消费一次且仅消费一次。 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]); Kafka命令： bin/kafka-topics.sh --zookeeper 192.168.1.107:2181,192.168.1.108:2181,192.168.1.109:2181 --topic TestTopic --replication-factor 1 --partitions 1 --create bin/kafka-console-producer.sh --broker-list 192.168.1.107:9092,192.168.1.108:9092,192.168.1.109:9092 --topic TestTopic 192.168.1.191:2181,192.168.1.192:2181,192.168.1.193:2181 metadata.broker.list
二、java版本ide
package cn.spark.study.streaming; import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; import kafka.serializer.StringDecoder; 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.JavaPairInputDStream; import org.apache.spark.streaming.api.java.JavaStreamingContext; import org.apache.spark.streaming.kafka.KafkaUtils; import scala.Tuple2; /** * 基于Kafka Direct方式的实时wordcount程序 * @author Administrator * */ public class KafkaDirectWordCount { public static void main(String[] args) { SparkConf conf = new SparkConf() .setMaster("local[2]") .setAppName("KafkaDirectWordCount"); JavaStreamingContext jssc = new JavaStreamingContext(conf, Durations.seconds(5)); // 首先，要建立一份kafka参数map Map<String, String> kafkaParams = new HashMap<String, String>(); kafkaParams.put("metadata.broker.list", "192.168.1.135:9092,192.168.1.136:9092,192.168.1.137:9092"); // 而后，要建立一个set，里面放入，你要读取的topic // 这个，就是咱们所说的，它本身给你作的很好，能够并行读取多个topic Set<String> topics = new HashSet<String>(); topics.add("WordCount"); // 建立输入DStream JavaPairInputDStream<String, String> lines = KafkaUtils.createDirectStream( jssc, String.class, String.class, StringDecoder.class, StringDecoder.class, kafkaParams, topics); // 执行wordcount操做 JavaDStream<String> words = lines.flatMap( new FlatMapFunction<Tuple2<String,String>, String>() { private static final long serialVersionUID = 1L; @Override public Iterable<String> call(Tuple2<String, String> tuple) throws Exception { return Arrays.asList(tuple._2.split(" ")); } }); JavaPairDStream<String, Integer> pairs = words.mapToPair( new PairFunction<String, String, Integer>() { private static final long serialVersionUID = 1L; @Override public Tuple2<String, Integer> call(String word) throws Exception { return new Tuple2<String, Integer>(word, 1); } }); JavaPairDStream<String, Integer> wordCounts = pairs.reduceByKey( new Function2<Integer, Integer, Integer>() { private static final long serialVersionUID = 1L; @Override public Integer call(Integer v1, Integer v2) throws Exception { return v1 + v2; } }); wordCounts.print(); jssc.start(); jssc.awaitTermination(); jssc.close(); } }