spark streaming 整合kafka

一：

1. createStream会使用 Receiver；而createDirectStream不会,数据会通过driver接收。

2.createStream使用 Receiver 源源不断的接收数据并把数据交给 ReceiverSupervisor 处理最终存储为 blocks 作为 RDD 的输入，从 kafka 拉取数据与计算消费数据相互独立；而createDirectStream会在每个 batch 拉取数据并就地消费，到下个 batch 再次拉取消费，周而复始，从 kafka 拉取数据与计算消费数据是连续的，没有独立开

　　createStream 一般是一个inputstreaming 对应一个receiver，receiver其实就是一个消费者进程，你可以设置多个线程来消费，或者create多个inputstreaming 最后union就行。

3.createStream中创建的KafkaInputDStream 每个 batch 所对应的 RDD 的 partition 不与 Kafka partition 一一对应；而createDirectStream-中创建的 DirectKafkaInputDStream 每个 batch 所对应的 RDD 的 partition 与 Kafka partition 一一对应。

------------------------------------------------------------------------------

以上内容出自-----http://www.cnblogs.com/dylenwu/archive/2016/11/30/6118610.html

------------------------------------------------------------------------------

我用的是Direc模式，这个模式更高效、更安全。

代码：

messages.foreachRDD { rdd =>
    rdd.foreachPartition { partition =>
      println(s"debug: partition size: ${partition.size}")
      partition.foreach { item =>
        if (item.contains("transaction_id")){
          val oneLine=item.split("----")
                      oneLine.foreach(one=>{
                        val n=getTuple(one)
                        oneDataArrM.+=(n)
                    })
                  }
      }
    }
  }

messages是kafka过来的流，这个流是一个RDD序列，同理，流是由多个rdd包含的，rdd中是有一个或多个partition，对应topic中的partiton，一对一。

全部代码：

package com.zlbw

import kafka.serializer.StringDecoder
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.streaming.kafka.KafkaUtils
import org.apache.spark.streaming.{Seconds, StreamingContext}
import scala.collection.mutable.ArrayBuffer

/**
  * Created by USER on 2017/7/17.
  */
object s extends App{
  //  val spark=SparkSession.builder().appName("test").master("local[1]").getOrCreate()
  val spark=new SparkConf()
  spark.setAppName("test").setMaster("local[2]")
  val sc=new SparkContext(spark)
  //设置处理间隔10s
  val scc = new StreamingContext(sc,Seconds(10))
  scc.sparkContext.setLogLevel("WARN")

  val messages=crateDateStream(scc,"kafkatest2","172.16.90.61:6667,172.16.90.62:6667").map(_._2)
  val oneDataArrM = new ArrayBuffer[Tuple2[String,String]]()
  val twoDataArrM = new ArrayBuffer[Tuple2[String,String]]()
  val threeDataArrM = new ArrayBuffer[Tuple2[String,String]]()
  messages.foreachRDD { rdd =>
    rdd.foreachPartition { partition =>
      println(s"debug: partition size: ${partition.size}")
      partition.foreach { item =>
        if (item.contains("transaction_id")){
          val oneLine=item.split("----")
                      oneLine.foreach(one=>{
                        val n=getTuple(one)
                        oneDataArrM.+=(n)
                    })
                  }
      }
    }
  }
	
  def crateDateStream(scc:StreamingContext,topics:String,brokers:String)={
    val topicSet = topics.split(",").toSet
    val kafkaParams = Map[String, String](
      "metadata.broker.list" -> brokers,
      "serializer.class" -> "kafka.serializer.StringEncoder")
    println("****************************************************")
    KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](scc, kafkaParams, topicSet)
  }
  def getTuple(line:String): Tuple2[String,String]= {
    val words = line.trim.split("=>")
    if (words.length>1){
      (words(0),words(1))
    }else{
      null
    }
  }
  scc.start()
  scc.awaitTermination()

}

以上仅供参考，之后又新的发现再次更新，希望各位积极讨论