Spark Streaming篇3：Spark Streaming 把数据发往kafka，并实现去重

最新推荐文章于 2024-01-21 10:48:27 发布
最新推荐文章于 2024-01-21 10:48:27 发布
阅读量846 收藏 6
点赞数
分类专栏： 笔记

Spark Streaming篇3：Spark Streaming 把数据发往kafka，并实现去重

废话不多说，直接上干货

package com.iflytek.kafka

import java.util.Properties

import com.iflytek.kafkaManager.KafkaSink
import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.log4j.{Level, Logger}
import org.apache.spark.broadcast.Broadcast
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.functions.lit
import org.apache.spark.sql.types._
import org.apache.spark.sql.{Dataset, Row, SparkSession, _}
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010.ConsumerStrategies.Subscribe
import org.apache.spark.streaming.kafka010.KafkaUtils
import org.apache.spark.streaming.kafka010.LocationStrategies.PreferConsistent
import org.apache.spark.streaming.{Seconds, StreamingContext}

/*
  需求：
  利用sparkstreaming实时过滤30s内重复出现的人
 */
object WC2Kafka2 {
  def main(args: Array[String]): Unit = {
    Logger.getRootLogger.setLevel(Level.ERROR)
    System.setProperty("HADOOP_USER_NAME","root")
    System.setProperty("user.name","root")
    val warehouse = "hdfs://cdh01:8020/user/hive/warehouse/carbon.store"
    val sparkSession: SparkSession = SparkSession.builder()
      .appName("xx2")
      .master("local[2]")
      .config("spark.testing.memory", "471859200")
      .config("spark.steaming.kafka.maxRatePerPartition","10")
      .config("spark.sql.streaming.schemaInference", "true")
      .getOrCreate()
    val ssc = new StreamingContext(sparkSession.sparkContext, Seconds(3))

    val kafkaParams = Map[String, Object](
      "bootstrap.servers" -> "cdh01:9092",
      "key.deserializer" -> classOf[StringDeserializer],
      "value.deserializer" -> classOf[StringDeserializer],
      "group.id" -> "xytest1101",
      "auto.offset.reset" -> "latest",//earliest latest
      "enable.auto.commit" -> (false: java.lang.Boolean)
    )
    val topics = Array("pd_ry_txjl")
    val stream: InputDStream[ConsumerRecord[String, String]] ={
      KafkaUtils.createDirectStream[String, String](
        ssc,
        PreferConsistent,
        Subscribe[String, String](topics, kafkaParams))}
    val value: DStream[String] = stream.map(_.value())
    val kafkaProducerConfig = {
      val p = new Properties()
      p.setProperty("bootstrap.servers","cdh01:9092")
      p.setProperty("key.serializer","org.apache.kafka.common.serialization.StringSerializer")
      p.setProperty("value.serializer","org.apache.kafka.common.serialization.StringSerializer")
      p
    }
    val kafkaProducer: Broadcast[KafkaSink[String, String]] =
    {sparkSession.sparkContext.broadcast(KafkaSink[String, String](kafkaProducerConfig))}
    val windowWords: DStream[String] = value.window(Seconds(6), Seconds(6))
    val schema = {StructType(Seq(
      StructField("id",StringType,true),
      StructField("name",StringType,true),
      StructField("age",StringType,true),
      StructField("time",TimestampType,true)))}
    windowWords.foreachRDD(rdd=>{
      import org.apache.spark.sql.functions._
      import sparkSession.implicits._
      val rdd1: RDD[String] = rdd.cache()
      val ds: Dataset[String] = sparkSession.createDataset(rdd1)
      val frameAll: Dataset[Row] = {//下面是解析2层嵌套的json
        ds.select(get_json_object(col("value").cast("string"), "$.body") as ("body"))
          .select(get_json_object(col("body"), "$.body") as ("body"))
          .select(from_json(col("body"), schema) as ("parsed_value"))
          .select(
            col("parsed_value").getItem("id") as ("id"),
            col("parsed_value").getItem("name") as ("name"),
            col("parsed_value").getItem("age") as ("age"),
            from_unixtime((col("parsed_value").getItem("time").cast("double")/1000), "yyyy-MM-dd HH:mm:ss").cast("TIMESTAMP") as ("time"))
          .filter("id is not null")
      }
      frameAll.createOrReplaceTempView("frameAll")
      sparkSession.sqlContext.cacheTable("frameAll")
      val distancted: Dataset[Row] = frameAll.dropDuplicates(Array("name","id"))
      distancted.createOrReplaceTempView("distancted")
      sparkSession.sqlContext.cacheTable("distancted")
      sendKafka(distancted,kafkaProducer)
      sparkSession.sqlContext.uncacheTable("frameAll")
      sparkSession.sqlContext.uncacheTable("distancted")
      rdd1.unpersist(true)
    })
    ssc.start()
    ssc.awaitTermination()
  }

//把数据再包装成之前的2层嵌套json，发往kafka
  def sendKafka(distancted:DataFrame,kafkaProducer:Broadcast[KafkaSink[String, String]]):Unit={
    if(!distancted.rdd.isEmpty()){
      distancted.toJSON.withColumnRenamed("value", "body")
        .withColumn("skynet.priority", lit("4"))
        .toJSON.withColumnRenamed("value", "properties")
        .toJSON.withColumnRenamed("value", "body")
        .withColumn("skynet.msg.location", lit("LOCAL"))
        .withColumn("skynet.priority", lit("4"))
        .toJSON.withColumnRenamed("value", "properties")
        .toJSON.foreach(rdd=>{
        kafkaProducer.value.send("xytest",rdd.toString)
      })
    }
  }
}

KafkaSink通用类

package com.iflytek.kafkaManager

import java.util.concurrent.Future
import org.apache.kafka.clients.producer.{KafkaProducer, ProducerRecord, RecordMetadata}

class KafkaSink[K, V](createProducer: () => KafkaProducer[K, V])
  extends Serializable {
//这样写可以避免序列化错误
  @transient
  lazy val producer = createProducer()
//发送消息
  def send(topic: String, key: K, value: V): Future[RecordMetadata] =
    producer.send(new ProducerRecord[K, V](topic, key, value))

  def send(topic: String, value: V): Future[RecordMetadata] =
    producer.send(new ProducerRecord[K, V](topic, value))
}

object KafkaSink {

  import scala.collection.JavaConversions._

  def apply[K, V](config: Map[String, Object]): KafkaSink[K, V] = {
     val createProducerFunc = () => {
//      新建kafka Producer
      val producer = new KafkaProducer[K, V](config)
      sys.addShutdownHook {
//        确保在excutor的jvm关闭前
//        kafka producer 将缓存中的所有信息写入kafka
        producer.close()
      }
      producer
    }
    new KafkaSink(createProducerFunc)
  }

  def apply[K, V](config: java.util.Properties): KafkaSink[K, V] = apply(config.toMap)
}

pom如下：

    <properties>
        <spark.version>2.3.2</spark.version>
        <scala.version>2.11.8</scala.version>
        <hbase.version>1.2.1</hbase.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>${spark.version}</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_2.11</artifactId>
            <version>${spark.version}</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-hive_2.11</artifactId>
            <version>${spark.version}</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-yarn_2.11</artifactId>
            <version>${spark.version}</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_2.11</artifactId>
            <version>${spark.version}</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming_2.11</artifactId>
            <version>${spark.version}</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-kafka-0-10_2.11</artifactId>
            <version>${spark.version}</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql-kafka-0-10_2.11</artifactId>
            <version>${spark.version}</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>0.11.0.0</version>
            <scope>compile</scope>
        </dependency>
        
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.31</version>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>com.jolbox</groupId>
            <artifactId>bonecp</artifactId>
            <version>0.8.0.RELEASE</version>
            <scope>compile</scope>
        </dependency>


        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.13</version>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>${hbase.version}</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-common</artifactId>
            <version>${hbase.version}</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-server</artifactId>
            <version>${hbase.version}</version>
            <scope>compile</scope>
        </dependency>
        <!--<dependency>-->
            <!--<groupId>org.apache.hadoop</groupId>-->
            <!--<artifactId>hadoop-client</artifactId>-->
            <!--<version>2.7.2</version>-->
        <!--</dependency>-->
        <!--&lt;!&ndash;guava和hadoop版本得对应&ndash;&gt;-->
        <!--<dependency>-->
            <!--<groupId>com.google.guava</groupId>-->
            <!--<artifactId>guava</artifactId>-->
            <!--<version>18.0</version>-->
        <!--</dependency>-->

            <dependency>
                <groupId>org.scala-lang</groupId>
                <artifactId>scala-library</artifactId>
                <version>${scala.version}</version>
                <scope>compile</scope>
            </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.2.0</version>
                <executions>
                    <execution>
                        <id>compile-scala</id>
                        <phase>compile</phase>
                        <goals>
                            <goal>add-source</goal>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>test-compile-scala</id>
                        <phase>test-compile</phase>
                        <goals>
                            <goal>add-source</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <scalaVersion>2.11.8</scalaVersion>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.6.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <compilerArgs>
                        <arg>-extdirs</arg>
                        <arg>${project.basedir}/lib</arg>
                    </compilerArgs>
                </configuration>
            </plugin>
        </plugins>
    </build>
spark-kafka-writer:将您的Spark数据无缝地写入Kafka
05-14
火花卡夫卡作家 将您的Spark数据无缝地写入Kafka 安装 根据您使用的是Kafka 0.8还是0.10以及您的Spark版本，可以在Maven Central上使用spark-kafka-writer，并具有以下坐标： 卡夫卡0.8 卡夫卡0.10 斯巴达克2.4.X :cross_mark: "com.github.benfradet" %% "spark-kafka-writer" % "0.5.0" 火花2.2.X :cross_mark: "com.github.benfradet" %% "spark-kafka-writer" % "0.4.0" 斯巴达克2.1.X "com.github.benfradet" %% "spark-kafka-0-8-writer" % "0.3.0" "com.github.benfradet" %% "spark-kafka-0-10-writer"
Spark踩坑记——Spark Streaming+Kafka
weixin_30375427的博客
01-03 2204
目录 前言 Spark streaming接收Kafka数据 基于Receiver的方式 直接读取方式 Spark向kafka中写入数据 Spark streaming+Kafka应用 Spark streaming+Ka...
spark streaming去重
量子人生
02-05 8224
spark streaming去重 由于客观原因，后台系统在记录的日志中有重复数据，重复数据的生成时间一般间隔在1s之内，在spark对日志数据进行消费处理时，需要对数据去重，减少对Hbase的写入。 本文给出两种思路。
Spark Streaming将处理结果数据写入Kafka
storm_fury
07-10 3343
Spark 没有直截有效的方式将消息发送到Kafka。 input.foreachRDD(rdd => // 不能在这里创建KafkaProducer rdd.foreachPartition(partition => partition.foreach { case x: String => { val props = new Has...
Spark Streaming基于simhash算法做新闻信息流去重，附scala代码
dreamBoat的博客
01-12 790
simhash算法做新闻去重
Spark-Streaming:Spark Streaming实时解析flume和kafka传来的josn数据写入mysql
05-03
Spark Streaming实时解析flume和kafka传来的josn数据写入mysql 注意，以下文件不提供 配置c3p0-config.xml链接，链接数据库 配置log4j.properties、my.properties 另，还需将您的spark和hadoop安装文件下的core-site...
使用kafka进行spark-streaming-with：将Apache Spark流与Apache Kafka集成的独立示例
02-05
这个示例将帮助你理解如何在实际应用中将Spark Streaming与Kafka结合，实现实时数据处理。 总之，Apache Spark Streaming和Apache Kafka的集成使得开发者能够构建高效、可扩展的实时数据处理系统。通过Scala的简洁...
Spark踩坑记——SparkStreaming+Kafka
02-25
在WeTest舆情项目中，需要对每天千万级的游戏评论信息进行词频统计，在生产者一端，我们...（如有任何纰漏欢迎补充来踩，我会第一时间改正^v^）用sparkstreaming流式处理kafka中的数据，第一步当然是先把数据接收过来，
spark streaming流式处理kafka中的数据（java）
RedStarOfSleep's Blog
07-19 6624
spark streaming是spark中用来处理流式数据的，用来对接各类消息队列是极好的。spark streaming并不是真正实时的流式处理，它本质上还是批处理，只是每一个批次间隔的时间很短。 我是用java来写的。跟大佬们的scala不能比，没有scala简洁。。 先是maven需要依赖的spark-kafka包： &lt;dependency&gt; &lt;gro...
通过Spark向Kafka写入数据
SuperBoy_Liang的博客
11-09 2551
1、·将KafkaProducer利用lazy val的方式进行包装 package cn.com.m.util import java.util.concurrent.Future import org.apache.kafka.clients.producer.{KafkaProducer, ProducerRecord, RecordMetadata} class KafkaSink[K, V](createProducer: () => KafkaProducer[K, V]) ext
Spark写入kafka（批数据和流式）
最新发布
中长跑路上的crush
01-21 1454
【代码】Spark写入kafka（批数据和流式）
Spark Streaming + Kafka 实现实时数据传输
Samue1_Zhu的博客
02-24 1928
Spark Streaming + Kafka 实现实时数据传输 版本说明： Spark 3.0.0 Kafka 2.12 zookeeper 3.5.7 文章目录Spark Streaming + Kafka 实现实时数据传输一、集群端二、IDEA端 一、集群端 前提：配置好并启动三台节点的zookeeper 在三个结点分别配置Kafka ①解压安装包，在安装目录/home/kafka-2.12下创建logs文件夹 ②修改./config/vi server.properties配置文件 -----
Spark实时项目第一天-日志采集|SpringBoot接受日志请求|将数据发送到kafka
SmallScorpion
05-08 356
文件 application.properties: # 外部配置打开 # logging.config=./logback.xml #业务日期 mock.date=2020-04-01 #模拟数据发送模式 mock.type=http #http模式下，发送的地址 mock.url=http://localhost:8080/applog #启动次数 mock.startup.count=10000 #设备最大值 mock.max.mid=50 #会员最大值 mock.max.uid=500 #商品
spark读取hbase数据发送到kafka
siwangxiaoxuesheng的博客
04-27 1832
代码 package com.*.spark import java.text.SimpleDateFormat import com.alibaba.fastjson.JSONObject import org.apache.hadoop.conf.Configuration import org.apache.hadoop.hbase.client.{Result, Scan} import org.apache.hadoop.hbase.io.ImmutableBytesWritable impo
二十二 Spark与Kafka数据互相访问
张金玉的专栏
01-05 299
啊
Spark Streaming实时流处理项目实战笔记——使用KafkaSInk将Flume收集到的数据输出到Kafka
优质后端技术知识记录
12-03 225
Flume配置文件 a1.sources = r1 a1.sinks = k1 a1.channels = c1 a1.sources.r1.type = avro a1.sources.r1.bind = hadoop a1.sources.r1.port = 44444 a1.sinks.k1.type = org.apache.flume.sink.kafka.KafkaSink a...
基于Spark的应用水印技术和流数据去重
需要远程指导仿真实验、代码有问题的，请后台私信或者关注公众号
07-04 723
掌握Spark结构化流中的水印技术。   掌握Spark结构化流中数据去重操作。1、在Spark结构化流程序中处理延迟到达的数据。   2、在Spark结构化流程序中处理重复到达的数据。在现实世界中，流数据往往会不按顺序到达，以及因为网络拥挤、网络中断或数据生成器（如移动设备等）不在线而延迟到达。在流处理引擎中，水印是一种常用的技术，用于处理延迟数据，以及限制维护它所需的状态数量。   从结构化流的角度来看，水印是event time的移动阈值，它落后于目前所见的最新事件时间。当新数据以一个较新的事件时间到
spark-7-spark streaming向kafka生产数据
qq_20466211的博客
12-19 1597
如何正确使用pyspark将数据发送到kafka经纪人? 从kafka主题中接收数据，对该数据进行一些转换，然后将转换后的数据放在另一个kafka主题中。 1 参数写在代码里 #encoding=utf8 from pyspark import SparkConf, SparkContext from operator import add import sys from pyspark.streaming import StreamingContext from pyspark.streaming.kaf
SparkStreaming处理Kafka数据：实战与优化
在实际项目中，结合业务需求和系统环境，选择合适的集成方案并进行细致的优化，才能充分发挥SparkStreaming与Kafka的组合优势，实现高效稳定的大数据实时处理。作者鼓励读者针对遇到的问题提出建议，共同完善和优化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值