Spark Streaming源码解读

转载 2016年06月01日 09:37:06

本期内容:

  • Direct Access

  • Kafka

前面有几期我们讲了带Receiver的Spark Streaming 应用的相关源码解读。但是现在开发Spark Streaming的应用越来越多的采用No Receivers(Direct Approach)的方式,No Receiver的方式的优势: 

1. 更强的控制自由度 

2. 语义一致性 

其实No Receivers的方式更符合我们读取数据,操作数据的思路的。因为Spark 本身是一个计算框架,他底层会有数据来源,如果没有Receivers,我们直接操作数据来源,这其实是一种更自然的方式。 如果要操作数据来源,肯定要有一个封装器,这个封装器一定是RDD类型。 以直接访问Kafka中的数据为例:

object DirectKafkaWordCount {  def main(args: Array[String]) {    val Array(brokers, topics) = args    // Create context with 2 second batch interval
    val sparkConf = new SparkConf().setAppName("DirectKafkaWordCount")    val ssc = new StreamingContext(sparkConf, Seconds(2))    // Create direct kafka stream with brokers and topics
    val topicsSet = topics.split(",").toSet    val kafkaParams = Map[String, String]("metadata.broker.list" -> brokers)    val messages = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](
      ssc, kafkaParams, topicsSet)    // Get the lines, split them into words, count the words and print
    val lines = messages.map(_._2)    val words = lines.flatMap(_.split(" "))    val wordCounts = words.map(x => (x, 1L)).reduceByKey(_ + _)
    wordCounts.print()    // Start the computation
    ssc.start()
    ssc.awaitTermination()
  }
}

Spark Streaming会封装一个KafkaRDD:

/** * A batch-oriented interface for consuming from Kafka. * Starting and ending offsets are specified in advance, * so that you can control exactly-once semantics. * @param kafkaParams Kafka <a href="http://kafka.apache.org/documentation.html#configuration"> * configuration parameters</a>. Requires "metadata.broker.list" or "bootstrap.servers" to be set * with Kafka broker(s) specified in host1:port1,host2:port2 form. * @param offsetRanges offset ranges that define the Kafka data belonging to this RDD * @param messageHandler function for translating each message into the desired type */private[kafka]class KafkaRDD[  K: ClassTag,  V: ClassTag,  U <: Decoder[_]: ClassTag,  T <: Decoder[_]: ClassTag,  R: ClassTag] private[spark] (    sc: SparkContext,    kafkaParams: Map[String, String],    val offsetRanges: Array[OffsetRange],    leaders: Map[TopicAndPartition, (String, Int)],    messageHandler: MessageAndMetadata[K, V] => R
  ) extends RDD[R](sc, Nil) with Logging with HasOffsetRanges {  override def getPartitions: Array[Partition] = {
    offsetRanges.zipWithIndex.map { case (o, i) =>
        val (host, port) = leaders(TopicAndPartition(o.topic, o.partition))        new KafkaRDDPartition(i, o.topic, o.partition, o.fromOffset, o.untilOffset, host, port)
    }.toArray
  }
...  override def compute(thePart: Partition, context: TaskContext): Iterator[R] = {    val part = thePart.asInstanceOf[KafkaRDDPartition]
    assert(part.fromOffset <= part.untilOffset, errBeginAfterEnd(part))    if (part.fromOffset == part.untilOffset) {
      log.info(s"Beginning offset ${part.fromOffset} is the same as ending offset " +
        s"skipping ${part.topic} ${part.partition}")      Iterator.empty
    } else {      new KafkaRDDIterator(part, context)
    }
  }

RDD中重要的方法 getPartitions 和 compute 其中compute中返回了一个 KafkaRDDIterator:

private class KafkaRDDIterator(      part: KafkaRDDPartition,      context: TaskContext) extends NextIterator[R] {    val kc = new KafkaCluster(kafkaParams)

...    private def fetchBatch: Iterator[MessageAndOffset] = {      val req = new FetchRequestBuilder()
        .addFetch(part.topic, part.partition, requestOffset, kc.config.fetchMessageMaxBytes)
        .build()      val resp = consumer.fetch(req)
      handleFetchErr(resp)      // kafka may return a batch that starts before the requested offset
      resp.messageSet(part.topic, part.partition)
        .iterator
        .dropWhile(_.offset < requestOffset)
    }    override def close(): Unit = {      if (consumer != null) {
        consumer.close()
      }
    }    override def getNext(): R = {      if (iter == null || !iter.hasNext) {
        iter = fetchBatch
      }      if (!iter.hasNext) {
        assert(requestOffset == part.untilOffset, errRanOutBeforeEnd(part))
        finished = true
        null.asInstanceOf[R]
      } else {        val item = iter.next()        if (item.offset >= part.untilOffset) {
          assert(item.offset == part.untilOffset, errOvershotEnd(item.offset, part))
          finished = true
          null.asInstanceOf[R]
        } else {
          requestOffset = item.nextOffset
          messageHandler(new MessageAndMetadata(
            part.topic, part.partition, item.message, item.offset, keyDecoder, valueDecoder))
        }
      }
    }
  }

其中会调用KafkaCluster的connect方法:

org/apache/spark/streaming/kafka/KafkaCluster.scala  def connect(host: String, port: Int): SimpleConsumer =
    new SimpleConsumer(host, port, config.socketTimeoutMs,
      config.socketReceiveBufferBytes, config.clientId)

KafkaCluster的connect方法返回了一个 SimpleConsumer,如果想自定义控制kafka消息的消费,则可自定义Kafka的consumer。

我们再回过头看看:

KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](
      ssc, kafkaParams, topicsSet)

实际生成了什么:

 def createDirectStream[    K: ClassTag,    V: ClassTag,    KD <: Decoder[K]: ClassTag,    VD <: Decoder[V]: ClassTag,    R: ClassTag] (      ssc: StreamingContext,      kafkaParams: Map[String, String],      fromOffsets: Map[TopicAndPartition, Long],      messageHandler: MessageAndMetadata[K, V] => R
  ): InputDStream[R] = {    val cleanedHandler = ssc.sc.clean(messageHandler)    new DirectKafkaInputDStream[K, V, KD, VD, R]
      ssc, kafkaParams, fromOffsets, cleanedHandler)
  }

生成了一个DirectKafkaInputDStream:

org/apache/spark/streaming/kafka/DirectKafkaInputDStream.scala override def compute(validTime: Time): Option[KafkaRDD[K, V, U, T, R]] = {    val untilOffsets = clamp(latestLeaderOffsets(maxRetries))    val rdd = KafkaRDD[K, V, U, T, R](
      context.sparkContext, kafkaParams, currentOffsets, untilOffsets, messageHandler)    // Report the record number and metadata of this batch interval to InputInfoTracker.
    val offsetRanges = currentOffsets.map { case (tp, fo) =>
      val uo = untilOffsets(tp)      OffsetRange(tp.topic, tp.partition, fo, uo.offset)
    }    val description = offsetRanges.filter { offsetRange =>
      // Don't display empty ranges.
      offsetRange.fromOffset != offsetRange.untilOffset
    }.map { offsetRange =>
      s"topic: ${offsetRange.topic}\tpartition: ${offsetRange.partition}\t" +
        s"offsets: ${offsetRange.fromOffset} to ${offsetRange.untilOffset}"
    }.mkString("\n")    // Copy offsetRanges to immutable.List to prevent from being modified by the user
    val metadata = Map(      "offsets" -> offsetRanges.toList,      StreamInputInfo.METADATA_KEY_DESCRIPTION -> description)    val inputInfo = StreamInputInfo(id, rdd.count, metadata)
    ssc.scheduler.inputInfoTracker.reportInfo(validTime, inputInfo)

    currentOffsets = untilOffsets.map(kv => kv._1 -> kv._2.offset)    Some(rdd)
  }

这里面即产生了KafkaRDD实例,一些相关的北京Java培训基本都会讲一些这方面的知识。

我们再重新思考有Receiver和No Receiver的Spark Streaming应用 Direct访问的好处:

 1. 不需要缓存,不会出现OOM等问题(数据缓存在Kafka中) 

 2. 如果采用Receiver的方式,Receiver和Worker上Executor绑定了,不方便做分布式(配置一下也可以做)。如果采用Direct的方式,直接是RDD操作,数据默认分布在多个Executor上,天然就是分布式的。 

 3. 数据消费的问题,在实际操作的时候,如果采用Receiver的方式,如果数据操作来不及消费,Delay多次之后,Spark Streaming程序有可能崩溃。如果是Direct的方式,就不会。

 4. 完全的语义一致性,不会重复消费,且只被消费一次。


Spark Streaming源码解读之Job详解

一:Spark Streaming Job生成深度思考 1. 做大数据例如Hadoop,Spark等,如果不是流处理的话,一般会有定时任务。例如10分钟触发一次,1个小时触发一次,这就是做流处理的...
  • snail_gesture
  • snail_gesture
  • 2016年05月15日 16:53
  • 12862

spark streaming源码解读

让我们按照源码一步步的解析。请一定一定一定和我们一起跟踪代码。一定要照着做,才能理解。 我们先看下StreamingContext创建的时候有哪些成员变量被初始化了。 看下 StreamingCo...
  • a11a2233445566
  • a11a2233445566
  • 2017年02月05日 14:27
  • 319

Spark定制班第14课:Spark Streaming源码解读之State管理之updateStateByKey和mapWithState解密

从这节课开始,简介Spark Streaming的状态管理。   Spark Streaming 是按Batch Duration来划分Job的,但我们有时需要根据业务要求按照另外的时间周期(比如说,...
  • andyshar
  • andyshar
  • 2016年05月26日 23:26
  • 1630

Spark(五) -- Spark Streaming介绍与基本执行过程

Spark Streaming作为Spark上的四大子框架之一,肩负着实时流计算的重大责任 而相对于另外一个当下十分流行的实时流计算处理框架Storm,Spark Streaming有何优点?又有何...
  • qq1010885678
  • qq1010885678
  • 2015年05月16日 20:11
  • 2046

大数据技术--Spark Streaming

到Spark Streaming,我们不得不说一下BDAS(Berkeley Data Analytics Stack),这个伯克利大学提出的关于数据分析的软件栈。从它的视角来看,目前的大数据处理可以...
  • qq_34941023
  • qq_34941023
  • 2017年01月14日 20:37
  • 235

Spark Streaming 入门教程

工具  intelliJ  IDE工具,和 spark 包,还有 linun服务器 首先  intelliJ  IDE 新建一个项目导入 spark的jar包 使用的是 spark-1.4.0-bin...
  • a2615381
  • a2615381
  • 2017年06月12日 00:07
  • 404

第82讲 Spark Streaming第一讲 Spark Streaming 工作原理

spark Streaming工作原理
  • njiang
  • njiang
  • 2016年04月18日 07:08
  • 1399

spark streaming应用场景(一) 日志分析

日志分析场景: 日志数据 访问IP,URL,耗时 统计每个URL在最近一分钟的访问次数,平均耗时 解决方案 将日志数据导入kafka, 通过spark streaming 从kafka中将数据抽...
  • dreaper126
  • dreaper126
  • 2016年01月11日 11:38
  • 2206

第24课:Spark Streaming的Transformation、Action、Input和Output

第24课:Spark Streaming的Transformation、Action、Input和Output 源码图解 1 Spark Streaming的Transformation、Acti...
  • duan_zhihua
  • duan_zhihua
  • 2016年06月10日 07:10
  • 554

Spark Streaming job 远程debug方法

记录下spark job的运程调试方法。
  • xueba207
  • xueba207
  • 2016年02月23日 15:17
  • 1566
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Spark Streaming源码解读
举报原因:
原因补充:

(最多只允许输入30个字)