StrutsStreaming消费kafka的数据sink全过程

最新推荐文章于 2022-10-10 15:01:49 发布
最新推荐文章于 2022-10-10 15:01:49 发布
阅读量806 收藏
点赞数
分类专栏： Spark 文章标签： kafka spark 大数据 hdfs cloudera
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AyubLIbra/article/details/106624775
版权

前言：
kafka的消息是通过fileBeat采集Nginx的日志进kafka。
spark消费kafka的数据

1、源消息：

{
    "@timestamp":"2020-04-18T09:30:41.525Z",
    "@metadata":{
        "beat":"filebeat",
        "type":"_doc",
        "version":"7.2.0",
        "topic":"bigdata_nginx_access"
    },
    "message":"192.168.25.1 - - [18/Apr/2020:14:15:45 +0800] "GET /nocar/Download?a=520&g=520p&b=h&p=123456 HTTP/1.1" 200 103580 "-""
}

2、依赖 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.test.bigdata</groupId>
    <artifactId>scalaspark</artifactId>
    <version>1.0-SNAPSHOT</version>


    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <scala.version>2.11.8</scala.version>
        <spark.version>2.4.0</spark.version>
        <hadoop.version>3.0.0</hadoop.version>
        <jackson.version>2.6.2</jackson.version>
        <encoding>UTF-8</encoding>
    </properties>


    <repositories>
        <repository>
            <id>scala-tools.org</id>
            <name>Scala-Tools Maven2 Repository</name>
            <url>http://scala-tools.org/repo-Releases</url>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>scala-tools.org</id>
            <name>Scala-Tools Maven2 Repository</name>
            <url>http://scala-tools.org/repo-Releases</url>
        </pluginRepository>
    </pluginRepositories>

    <dependencies>

        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-hive_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-streaming-kafka-0-8_2.11 -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-kafka-0-10_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql-kafka-0-10_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>${hadoop.version}</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.44</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>${jackson.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.1.41</version>
        </dependency>



    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/config</directory>
                <includes>
                    <include>**/*.properties</include>
                </includes>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <classifier>dist</classifier>
                    <appendAssemblyId>true</appendAssemblyId>
                    <descriptorRefs>
                        <descriptor>jar-with-dependencies</descriptor>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.2.2</version>
                <executions>
                    <execution>
                        <id>scala-compile-first</id>
                        <phase>process-resources</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <scalaVersion>${scala.version}</scalaVersion>
                    <recompileMode>incremental</recompileMode>
                    <useZincServer>true</useZincServer>
                    <args>
                        <arg>-unchecked</arg>
                        <arg>-deprecation</arg>
                        <arg>-feature</arg>
                    </args>
                    <jvmArgs>
                        <jvmArg>-Xms1024m</jvmArg>
                        <jvmArg>-Xmx1024m</jvmArg>
                    </jvmArgs>
                    <javacArgs>
                        <javacArg>-source</javacArg>
                        <javacArg>${java.version}</javacArg>
                        <javacArg>-target</javacArg>
                        <javacArg>${java.version}</javacArg>
                        <javacArg>-Xlint:all,-serial,-path</javacArg>
                    </javacArgs>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.antlr</groupId>
                <artifactId>antlr4-maven-plugin</artifactId>
                <version>4.3</version>
                <executions>
                    <execution>
                        <id>antlr</id>
                        <goals>
                            <goal>antlr4</goal>
                        </goals>
                        <phase>none</phase>
                    </execution>
                </executions>
                <configuration>
                    <outputDirectory>src/test/java</outputDirectory>
                    <listener>true</listener>
                    <treatWarningsAsErrors>true</treatWarningsAsErrors>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>

3、代码：

package com.test.kafka

import java.util.concurrent.TimeUnit
import java.util.regex.{Matcher, Pattern}

import com.google.gson.Gson
import org.apache.spark.sql.streaming.{OutputMode, StreamingQuery, StreamingQueryException, Trigger}
import org.apache.spark.sql.{DataFrame, Dataset, SparkSession}

object StrutsSparkTest {

  def main(args: Array[String]): Unit = {

    //System.setProperty("hadoop.home.dir", "D:\\Software\\hadoop-common-2.6.0-bin-master\\")
    //创建sparkSession
    val spark: SparkSession = SparkSession.builder()
      .appName("struts_spark")
      .master("local[*]")
      .getOrCreate()
    spark.sparkContext.setLogLevel("WARN")

    import spark.implicits._
    //kafka
    val topic = "WordCount"
    val kafkaCluer = "192.168.25.121:9092,192.168.25.122:9092,192.168.25.123:9092"
    //source创建
    val df: DataFrame = spark.readStream.format("kafka")
      .option("kafka.bootstrap.servers", kafkaCluer)
      .option("subscribe", topic)
      .option("startingOffsets", "latest")
      .load()
    val kafkaDF: Dataset[(String, String)] = df.selectExpr("CAST(key AS STRING)", "CAST(value AS STRING)").as[(String, String)]
    //channel  过滤一些脏消息
    val msg: DataFrame = kafkaDF.map(record =>handleMessage2CaseClass(record._2)).filter((_: Msg).!=(null))
      .select("message")
      .filter({ row =>
          //ip的提取和判断
          val strings: Array[String] = row.toString.split(" ")
          isIp(strings(0)) && strings.length>10
      })
    //拆分nginx日志
    val nginx: Dataset[nginxDesc] = msg.map(nginx => {
      val strings: Array[String] = nginx.toString.split(" ")
      if (strings(6).contains("?")) {
        val urlStr: Array[String] = strings(6).split("\\?")
        strings(6) = urlStr(0) //urlStr
        strings(7) = urlStr(1) //param
      }
      if (strings(3).contains("[")){
        val formatter = new SimpleDateFormat("dd/MMM/yyyy:hh:mm:ss", Locale.ENGLISH)
        val date: Date = formatter.parse(strings(3).replace("[", ""))
        val format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
        strings(3)=format.format(date)   //nginxTime
      }
      if (strings(5).contains("\""))
        strings(5) = strings(5).replace("\"", "") //get post method
      if (strings(0).contains("["))
        strings(0) = strings(0).replace("[", "") //ip
      nginxDesc(strings(0), strings(3), strings(5), strings(6), strings(7), strings(8).toInt, strings(9).toInt)
    })

    //创建流式数据写入格式对象
    //sink
//    val query: StreamingQuery = nginx.writeStream
//      .outputMode("append")
//      .format("console")
//      .start()
    /*输出路径*//*输出路径*/
    val outputPath = "F:\\tmp\\spark\\data"
    val checkpointLocation = "F:\\tmp\\spark\\checkpoint"

    // Sink：存入本地csv,主要为了验证
    val query: StreamingQuery = nginx.writeStream
      .format("csv")
      .option("path", outputPath)
      .option("checkpointLocation", checkpointLocation)
      .outputMode(OutputMode.Append)
      .trigger(Trigger.ProcessingTime(1, TimeUnit.MINUTES))
      .start()

    try
      query.awaitTermination()
    catch {
      case e: StreamingQueryException =>
        e.printStackTrace()
    }
  }


  /**
    * 使用正则判断IP
    */
  def isIp(addr:String): Boolean={
    if(addr.length() < 7 || addr.length() > 15 || "".equals(addr))
      return false
    val pat: Pattern = Pattern.compile("([1-9]|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])(\\.(\\d|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])){3}")
    val mat: Matcher = pat.matcher(addr)
    mat.find()
  }

  /***
    *
    * @param ip  ip
    * @param nginxTime  时间
    * @param method   方法
    * @param urlStr   url
    * @param http     http
    * @param status   状态
    * @param flow     流量
    */
  case class nginxDesc(ip:String, nginxTime:String, method:String, urlStr:String, http:String,
                       status:Int,flow:Int )

  /**样例类
    *
    * @param timestamp 时间
    * @param metadata 信息
    * @param message 消息
    */
  case class Msg(timestamp:String,metadata:String ,message:String)

  /**
    * 转换json
    * @param jsonStr json
    * @return  类
    */
  def handleMessage2CaseClass(jsonStr: String): Msg = {
    val gson = new Gson()
    try{
      gson.fromJson(jsonStr, classOf[Msg])
    } catch {
      case ex: Exception =>
        ex.printStackTrace() // 打印到标准err
        System.err.println("exception===>: ...") // 打印到标准err
        //主要为了返回对象
        Msg(null,null,null)
    }

  }


}

4、结果：

1、第一次更新
2020/06/09 只是打印的消息体。
在这里插入图片描述
2、第二次更新
2020/06/10，优化了消息源的判断，异常捕捉，拆分nginx日志
在这里插入图片描述
3、第三次更新
2020/06/11，优化了数据的sink,验证数据
在这里插入图片描述
在这里插入图片描述

数据分析小白入门指南

Ayub
关注
专栏目录
【Spark实战系列】structuredstreaming 消费 kafka 数据实现简单的 wordcount
JasonLee实时计算
08-19 2824
最近也是有很多同学问我,StructuredStreaming结合kafka的使用,我简单的写了一个wordcount的demo,后续会有更加具体和详细的介绍,今天先来一个简单的demo吧.代码在本地可以直接跑通. 添加依赖: <dependency> <groupId>org.apache.spark</groupId> ...
flume系列之：flume消费kafka数据到其他kafka集群Topic的生产参数配置
zhengzaifeidelushang的博客
01-16 764
flume系列之：flume消费kafka数据到其他kafka集群Topic的生产参数配置一、声明source、channel、sink二、通过channel关联source、sink三、source配置四、interceptor拦截器配置五、channel配置六、sink配置七、flume消费kafka topic数据到kafka topic完整啊的生产参数配置 一、声明source、channel、sink agent-optics-prod.sources = source1 agent-optics
Structured Streaming 消费Kafka 解析与测试
zeng6325998的博客
07-08 1306
参考资料 http://spark.apache.org/docs/2.4.1/structured-streaming-kafka-integration.html 前言 现在Flink很火，但是自己还没有系统性的了解Structured Streaming ，今天将相关Structured Streaming消费kafka相关下了解下 准备工作 我这里写了个消费kafka的样例代码,可以正常的往kafka消费数据 Properties props = new Properties(); .
使用Structured Streaming消费Kafka数据
Mophistoliu的博客
06-08 2819
由于工作需要，在数据收集上牵扯到多个维度的爬虫数据。之前的流程是：爬虫工程师通过文件方式保存爬取的数据，交付给我们做数据清洗处理，再导入到数据库。为了降低交互过程中的时间成本，提高效率，我们开始引入流处理的方式。 之前的模式： 使用流处理之后的模式： 通过kafka-python包的生产者写入数据 首先，需要对爬虫脚本进行改造。原先的写入文件代码部分可以不需要改动，只要对爬取到的数据增加写入k...
Streaming消费Kafka数据的两种方式
小黑的博客
03-20 1259
1.receiver模式 Receiver接收固定时间间隔的数据，放在Spark executors内存中操作，使用kafka高级API，自动维护偏移量，达到固定时间才能进行处理，效率低下，并且容易丢失数据。 数据备份两次，保存到hdfs，每次使用须从hdfs读取，导致效率低下。 如果数据量特别大的情况下，容量不够就会造成数据丢失。receiver通过WAL，设置本地存储，会存放到本地，保证数据不...
struct streaming
kevin
10-22 704
https://blog.csdn.net/dongyunlon/article/details/79037366 详细说：水印与window函数 https://blog.csdn.net/lovechendongxing/article/details/81748553?utm_source=blogxgwz6
flume-ng-kafka-sink:将数据发布到 Apache Kafka 的 Apache Flume Sink 实现
06-13
Flume-NG-Kafka-Sink 这是一个 Sink 实现，可以将数据发布到主题。 目标是将 Flume 与 Kafka 集成，以便基于拉式的处理系统（如可以处理来自各种 Flume 源（如 Syslog）的数据。 这现在是官方 Flume 发行版（从 v...
初学者——用Flink消费kafka数据
Fighting_hyt的博客
09-02 8626
一、Flink基本了解 Apache Flink其核心是用Java和Scala编写的分布式流数据流引擎。Flink以数据并行和流水线方式执行任意流数据程序，Flink的流水线运行时系统可以执行批处理和流处理程序。 二、环境说明 scala、 flink 、 kafka、 hadoop 三、主要代码 1. 初始化flink流处理的运行环境 //初始化flink流处理的运行环境 StreamExecutionEnvironment env = StreamExecutionEnvironment.getExec
java 多线程消费kafka_使用两种多线程模式消费kafka数据
weixin_35433448的博客
02-16 2318
使用两种多线程模式消费数据KafkaProducer是线程安全的,然而 KafkaConsumer却是非线程安全的。 Kafka Consumer中定义了一个 acquire(方法,用来检测当前是否只有一个线程在操作,若有其他线程正在操作则会抛出 Concurrentmodifcationexception异常:java.util.ConcurrentModificationException: ...
python kafka消费不到数据_logstash无法消费kafka数据
weixin_39793434的博客
12-17 3294
通过在控制台执行logstash，可以看到正常连接到kafka，但数据一直无法消费，然后过大约5分钟后连接就断开了，也能看到明显的提示[WARN ][org.apache.kafka.clients.consumer.internals.AbstractCoordinator][main] [Consumer clientId=logstsh-0, groupId=gc] This member ...
Spring 集成 Kafka的配置文件及代码讲解
04-12
这里是自己结合spring项目的配置。按照上面的配置可以实现生产发送消息。消费者接受消息。分类设计等
Struts2+spring+mybatis(Maven)整合
04-12
Struts2,spring,mybatis,maven整合框架,环境基于各个工具最新版
kafka环境搭建并和spring整合
11-07
分别介绍了kafka单机版，集群版环境搭建和常用配置和命令，并有和spring整合开发的简单示例。
StrutsStreaming实时cube：5个维度
wuzhilon88的专栏
09-02 273
第一步拼接 all#字段 select to_utc_timestamp(exec_time, 'PDT') as ftime, substr(exec_time, 0, 10) as Fexec_date, substr(exec_time, 12, 5) as Fexec_hhmm, concat('ALL', '#', headers_host) as Fs...
Structed Streaming集成kafka
qq_45769990的博客
05-09 260
读取kafka数据 // 构建SparkSession实例对象，相关配置进行设置 val spark: SparkSession = SparkSession.builder() .appName(this.getClass.getSimpleName.stripSuffix("$")) .master("local[2]") // 设置Shuffle时分区数目 .config("spark.sql.shuffle.partitions", "2"
Structure streaming-kafka sink
Knight
06-23 225
import org.apache.spark.sql.SparkSession object KafkaSink { def main(args: Array[String]): Unit = { val spark = SparkSession .builder() .master("local[*]") .appName("test") .getOrCreate() import spark.implicits._ val
【秒懂StructuredStreaming】手把手教你写StructuredStreaming + Kafka程序
热门推荐
Spark技术咖的博客
08-16 2万+
上一篇博客《StructuredStreaming是何方神圣》已经介绍了StructuredStreaming的相关概念，这篇博客我们介绍基于StructuredStreaming进行实时流算子开发，并将结果输出到kafka中。 StructuredStreaming使用的数据类型是DataFrame和Dataset。 从Spark 2.0开始，DataFra...
kafka 1.0 中文文档（十）：kafka streaming
memoordit的专栏
01-22 1133
1运行demo 1准备输入的主题并启动Kafka生产者 2启动Wordcount应用程序 3处理一些数据 4停止应用程序 2流处理程序编程指南 建立一个Maven项目 编写第二个Streams应用程序Line Split 编写第三个Streams应用程序Wordcount 9.1运行demoKafka Streams是用于构建关键任务实时应用程序和微服务的客户端库，输入和（或）输出数据存储在Kafk
Structured Streaming系列-4、集成 Kafka
不积跬步无以至千里，不积小流无以成江河
10-10 1032
Structured Streaming系列-4、集成 Kafka
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值