SparkStreaming 之整合kafka0.8

本文详细介绍如何使用Spark Streaming通过直连方式消费Kafka 0.8版本数据,并将偏移量保存至Zookeeper,包括pom依赖配置、代码实现及关键步骤说明。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

直接贴代码,注释内都有详细解释:
pom依赖:

<!--SparkStreaming 整合kafka0.8版本-->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-kafka-0-8_2.11</artifactId>
            <version>2.1.3</version>
        </dependency>
package cn.spark.direct

import kafka.common.TopicAndPartition
import kafka.message.MessageAndMetadata
import kafka.serializer.StringDecoder
import kafka.utils.{ZKGroupTopicDirs, ZkUtils}
import org.I0Itec.zkclient.ZkClient
import org.apache.spark.SparkConf
import org.apache.spark.rdd.RDD
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka.{HasOffsetRanges, KafkaUtils, OffsetRange}
import org.apache.spark.streaming.{Duration, StreamingContext}

/**
  * 使用直连方式 SparkStreaming连接kafka0.8获取数据 将偏移量数据保存到zookeeper中
  *
  * @Author xiaohuli
  * @CreateDate 2019/2/17
  */
object Kafaka8Direct {
    def main(args: Array[String]): Unit = {
        //指定组名
        val group = "g001"
        //创建SparkConf 提交到集群中运行 不要设置master参数
        val conf = new SparkConf().setAppName("KafakaDirect8").setMaster("local[4]")
        //设置SparkStreaming,并设定间隔时间
        val ssc = new StreamingContext(conf, Duration(5000))
        //指定消费者的topic名字
        val topic = "wordcount"
        //指定kafka的broker地址(SparkStreaming的Task直接连接到kafka的分区上,用更加底层的API消费,效率更高)
        val brokerList = "master:9092,slave1:9092,slave2:9092"

        //指定zookeeper的地址,用来存放数据偏移量数据,也可以使用Redis MySQL等
        val zkQuorum = "master:2181,slave1:2181,slave2:2181"
        //创建Stream时使用的topic名字集合,SparkStreaming可同时消费多个topic
        val topics: Set[String] = Set(topic)

        //创建一个 ZKGroupTopicDirs 对象,就是用来指定在zk中的存储目录,用来保存数据偏移量
        val topicDirs = new ZKGroupTopicDirs(group, topic)
        //获取 zookeeper 中的路径 "/g001/offsets/wordcount/"
        val zkTopicPath = s"${topicDirs.consumerOffsetDir}"

        //准备kafka的参数
        val kafkaParams = Map(
            //"key.deserializer" -> classOf[StringDeserializer], //key的数据类型
            //"value.deserializer" -> classOf[StringDeserializer], //value的数据类型
            //"deserializer.encoding" -> "GB2312", //配置读取Kafka中数据的编码
            "metadata.broker.list" -> brokerList,
            "group.id" -> group,
            //SmallestTimeString 从头开始读取数据
            //LargestTimeString 表示从启动后开始
            "auto.offset.reset" -> kafka.api.OffsetRequest.SmallestTimeString
        )

        //构造一个zookeeper的客户端 用来读写偏移量数据
        val zkClient = new ZkClient(zkQuorum)

        //查询该路径下是否有子节点,即是否有分区读取数据记录的读取的偏移量
        // /g001/offsets/wordcount/0/1001
        // /g001/offsets/wordcount/1/1001
        // /g001/offsets/wordcount/2/1001
        val children: Int = zkClient.countChildren(zkTopicPath)

        var kafkaStream: InputDStream[(String, String)] = null

        //构造一个map集合用来存放数据偏移量信息
        var fromOffsets: Map[TopicAndPartition, Long] = Map()

        //判断是否保存过数据 根据子节点的数量是否为0
        if (children > 0) {
            //保存过offset
            //遍历子节点
            for (i <- 0 until (children)) {

                //获取子节点 /g001/offsets/wordcount/0/1001
                val partitionOffset: String = zkClient.readData[String](s"$topicDirs/$i")
                // /wordcount/0
                val tp = TopicAndPartition(topic, i)
                //获取数据偏移量  将不同分区内的数据偏移量保存到map集合中
                //  wordcount/0 -> 1001
                fromOffsets += (tp -> partitionOffset.toLong)
            }
            // 泛型中 key:kafka中的key   value:hello tom hello jerry
            //创建函数 解析数据 转换为(topic_name, message)的元组
            val messageHandler = (mmd: MessageAndMetadata[String, String]) => (mmd.topic, mmd.message())
            //利用底层的API创建DStream 采用直连的方式
            //[String, String, StringDecoder, StringDecoder, (String, String)]
            // key      value   key的解码器     value的解码器   解析函数的返回值类型
            kafkaStream = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder, (String, String)](ssc, kafkaParams, fromOffsets, messageHandler)
        } else {
            //zk中没有子节点数据 就是第一次读取数据 直接创建直连对象
            kafkaStream = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder](ssc, kafkaParams, topics)
        }

        //偏移量的范围
        var offsetRanges = Array[OffsetRange]()

        //直接操作kafkaStream
        //依次迭代DStream中的kafkaRDD 只有kafkaRDD才可以强转为HasOffsetRanges  从中获取数据偏移量信息
        //之后是操作的RDD 不能够直接操作DStream 因为调用Transformation方法之后就不是kafkaRDD了获取不了偏移量信息
        kafkaStream.foreachRDD(kafkaRDD => {

            //强转为HasOffsetRanges 获取offset偏移量数据
            offsetRanges = kafkaRDD.asInstanceOf[HasOffsetRanges].offsetRanges

            //获取数据
            val lines: RDD[String] =kafkaRDD.map(_._2)
            //todo
            //val results = yourCalculation(rdd)
            //接下来就是对RDD进行操作 触发action
            lines.foreachPartition(patition => {
                patition.foreach(x => println(x))
            })

            for (o <- offsetRanges) {
                //拼接zk路径  /g001/offsets/wordcount/0
                val zkPath = s"${topicDirs.consumerOffsetDir}/${o.partition}"
                //将 partition 的偏移量数据 offset 保存到zookeeper中
                ZkUtils.updatePersistentPath(zkClient, zkPath, o.untilOffset.toString)
            }
        })

        //开启SparkStreaming 并等待退出
        ssc.start()
        ssc.awaitTermination()

    }
}

<think>我们正在处理关于Kafka2.12版本与SparkStreaming整合的问题。根据引用内容,我们需要关注以下几点:1.根据引用[2],SparkStreamingKafka整合需要引入对应的jar包,根据Kafka版本选择分支:spark-streaming-kafka-0-8和spark-streaming-kafka-0-10。而Kafka2.12版本指的是Scala版本(Kafka客户端是用Scala编写的,2.12表示Scala的版本),实际上Kafka的版本是0.10.x或更高(如1.x,2.x等)。因此,我们需要确定Kafka的具体版本(比如0.10.x,0.11.x,1.x,2.x等)来选择对应的jar包。2.引用[3]提到,SparkStreaming集成Kafka0.10较为简单,并且Kafka分区和Spark分区之间是1:1对应关系。3.引用[4]给出了一个提交SparkStreaming任务的命令示例,其中指定了主类和jar包。但是,用户的问题中明确提到“Kafka2.12版本”,这里需要澄清:Kafka的版本号通常由两部分组成,例如kafka_2.12-2.4.0,其中2.12是Scala版本,2.4.0Kafka的版本。因此,我们需要知道Kafka的具体版本(如2.4.0)来确定使用哪个spark-streaming-kafka集成包。根据Spark官方文档,SparkStreamingKafka的集成方式如下:-对于Kafka0.8版本,使用spark-streaming-kafka-0-8-对于Kafka0.10及以上版本,使用spark-streaming-kafka-0-10由于Kafka2.12通常指的是Scala2.12编译的Kafka,而Kafka版本可能是0.10.2.0、2.4.0等。因此,我们假设用户使用的是较新的Kafka版本(如0.10或以上),那么应该使用spark-streaming-kafka-0-10。步骤:1.添加依赖:在项目中引入spark-streaming-kafka-0-10_2.12(注意:这里的2.12是Scala版本,需要与项目中使用的Scala版本一致,并且与Spark的Scala版本一致)。2.编写代码:使用DirectAPI(推荐)来消费Kafka数据。3.配置参数:设置Kafka消费者的相关参数(如bootstrap.servers,group.id,key.deserializer,value.deserializer,auto.offset.reset等)。4.提交任务:使用spark-submit提交应用程序,并确保包含spark-streaming-kafka-0-10_2.12依赖。下面是一个具体的步骤和示例代码:第一步:添加依赖(以Maven为例)```xml<dependency><groupId>org.apache.spark</groupId><artifactId>spark-streaming-kafka-0-10_2.12</artifactId><version>${spark.version}</version></dependency><dependency><groupId>org.apache.spark</groupId><artifactId>spark-core_2.12</artifactId><version>${spark.version}</version></dependency><dependency><groupId>org.apache.spark</groupId><artifactId>spark-streaming_2.12</artifactId><version>${spark.version}</version></dependency>```注意:将${spark.version}替换为相应的Spark版本,如3.0.0。第二步:编写SparkStreaming代码(使用DirectAPI)```scalaimportorg.apache.kafka.clients.consumer.ConsumerConfigimportorg.apache.kafka.common.serialization.StringDeserializerimportorg.apache.spark.SparkConfimportorg.apache.spark.streaming._importorg.apache.spark.streaming.kafka010._objectKafkaSparkStreamingDemo{defmain(args:Array[String]):Unit={//创建StreamingContext,批次间隔5秒valconf=newSparkConf().setAppName("KafkaSparkStreaming").setMaster("local[*]")valssc=newStreamingContext(conf,Seconds(5))//配置Kafka参数valkafkaParams=Map[String,Object](ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG->"localhost:9092",ConsumerConfig.GROUP_ID_CONFIG->"spark-streaming-group",ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG->classOf[StringDeserializer],ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG->classOf[StringDeserializer],ConsumerConfig.AUTO_OFFSET_RESET_CONFIG->"latest",ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG->(false:java.lang.Boolean))//要消费的主题valtopics=Array("topic1")//创建DStreamvalstream=KafkaUtils.createDirectStream[String,String](ssc,LocationStrategies.PreferConsistent,ConsumerStrategies.Subscribe[String,String](topics,kafkaParams))//处理每条消息vallines=stream.map(record=>record.value)valwords=lines.flatMap(_.split(""))valwordCounts=words.map(word=>(word,1)).reduceByKey(_+_)//输出结果wordCounts.print()//启动流计算ssc.start()ssc.awaitTermination()}}```第三步:提交任务使用spark-submit提交任务,注意指定主类和jar包,以及相关的依赖。如果使用--packages选项,可以自动下载依赖:```spark-submit--masteryarn\--deploy-modecluster\--classcom.example.KafkaSparkStreamingDemo\--packagesorg.apache.spark:spark-streaming-kafka-0-10_2.12:3.0.0\/path/to/your-application.jar```或者,如果已经将依赖打包到uberjar中,则不需要--packages。注意事项:1.确保Spark版本和Kafka集成包的版本兼容。2.根据实际Kafka集群地址修改bootstrap.servers。3.根据需求调整消费者组ID(group.id)和偏移量重置策略(auto.offset.reset)。引用说明:[^2]提到了根据Kafka版本选择jar包分支的原则。[^3]提供了使用DirectAPI的简要说明。[^4]给出了提交任务的命令示例。因此,针对用户的问题,我们给出了使用Kafka0.10及以上版本(对应Scala2.12)的整合步骤。相关问题:1.SparkStreaming整合Kafka时如何管理偏移量?2.如何提高SparkStreaming消费Kafka数据的并行度?3.SparkStreaming整合Kafka时有哪些调优参数?</think>### 使用 Kafka 2.12 提交 Spark Streaming 任务的配置和步骤 #### 核心配置项 1. **依赖管理** 在项目构建文件(如 Maven/SBT)中添加对应版本的依赖: ```xml <!-- Maven 示例 --> <dependency> <groupId>org.apache.spark</groupId> <artifactId>spark-streaming-kafka-0-10_2.12</artifactId> <version>3.3.0</version> <!-- Spark 版本需匹配 --> </dependency> ``` **关键说明**: - `spark-streaming-kafka-0-10`:适用于 Kafka 0.10.x 及更高版本 - `_2.12`:Scala 2.12 版本(Kafka 2.12 即 Scala 2.12 编译版本)[^2][^3] 2. **Kafka 参数配置** ```scala val kafkaParams = Map[String, Object]( "bootstrap.servers" -> "kafka-server:9092", // Kafka 集群地址 "key.deserializer" -> classOf[StringDeserializer], "value.deserializer" -> classOf[StringDeserializer], "group.id" -> "spark-streaming-group", "auto.offset.reset" -> "latest", // 偏移量重置策略 "enable.auto.commit" -> (false: java.lang.Boolean) // 禁用自动提交 ) ``` **必选参数**:`bootstrap.servers`, `key.deserializer`, `value.deserializer`[^1] 3. **创建 Direct Stream** ```scala import org.apache.spark.streaming.kafka010._ val topics = Array("input-topic") val stream = KafkaUtils.createDirectStream[String, String]( streamingContext, LocationStrategies.PreferConsistent, // 分区分配策略 ConsumerStrategies.Subscribe[String, String](topics, kafkaParams) ) ``` Kafka 分区与 Spark 分区保持 1:1 映射关系[^3] #### 完整步骤示例(WordCount) ```scala import org.apache.spark.streaming._ import org.apache.spark.streaming.kafka010._ val conf = new SparkConf().setAppName("Kafka2Spark") val ssc = new StreamingContext(conf, Seconds(5)) // 1. Kafka 配置 val kafkaParams = Map( "bootstrap.servers" -> "kafka1:9092,kafka2:9092", "key.deserializer" -> classOf[StringDeserializer], "value.deserializer" -> classOf[StringDeserializer], "group.id" -> "wordcount-group", "auto.offset.reset" -> "earliest" ) // 2. 创建数据流 val topics = Set("text-topic") val messages = KafkaUtils.createDirectStream[String, String]( ssc, LocationStrategies.PreferConsistent, ConsumerStrategies.Subscribe[String, String](topics, kafkaParams) ) // 3. 数据处理 val words = messages.map(_.value).flatMap(_.split(" ")) val wordCounts = words.countByValue() // 4. 结果输出 wordCounts.print() ssc.start() ssc.awaitTermination() ``` #### 任务提交命令 ```bash spark-submit \ --master yarn \ --deploy-mode cluster \ --class com.example.KafkaStreamingApp \ --packages org.apache.spark:spark-streaming-kafka-0-10_2.12:3.3.0 \ /path/to/your-app.jar ``` **关键参数**: - `--packages`:自动下载 Kafka 集成依赖 - Scala 版本需与 Kafka 依赖的 `2.12` 后缀匹配[^2][^4] #### 注意事项 1. **偏移量管理**:需手动管理偏移量(如保存到 Zookeeper 或数据库) 2. **版本兼容性**: - Spark 3.x 推荐 Kafka Client 2.8.0+ - Scala 版本必须一致(如 `_2.12`) 3. **性能优化**: ```scala conf.set("spark.streaming.kafka.maxRatePerPartition", "1000") // 每分区消费速率 ``` ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值