spark：sparkstreaming 0.10版本 案例1：从 kafka 采集数据，并存储到 Hbase Demo示例 / 案例2：实时更新mysql

最新推荐文章于 2022-10-08 18:15:39 发布
最新推荐文章于 2022-10-08 18:15:39 发布
阅读量731 收藏 1
点赞数
分类专栏： sparkStreaming spark 文章标签： spark sparkstreaming kafka hbase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38750084/article/details/106851029
版权

 

SparkStreaming中参数配置释义：


1.分区策略
LocationStrategies 分配分区策略，LocationStrategies：根据给定的主题和集群地址创建consumer
创建DStream，返回接收到的输入数据
LocationStrategies.PreferConsistent：持续的在所有Executor之间均匀分配分区 (均匀分配，选中的每一个Executor都会分配 partition)
LocationStrategies.PreferBrokers: 如果executor和kafka brokers 在同一台机器上，选择该executor。
LocationStrategies.PreferFixed: 如果机器不是均匀的情况下，可以指定特殊的hosts。当然如果不指定，采用 LocationStrategies.PreferConsistent模式


2.auto.offset.reset
earliest：当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
latest：当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，消费新产生的该分区下的数据
none：topic各分区都存在已提交的offset时，从offset后开始消费；只要有一个分区不存在已提交的offset，则抛出异常

3. key.serializer 和 value.serialize
其实这个是kafka封装好的，把字符串进行序列化，这就是为什么在ProducerRecord中可以输入字符串进行传输。
同时，我们在Consumer端也需要添加这样两个参数，这两个参数是进行反序列化的作用的，
就是接收到kafka传递给你的数据之后，进行反序列化操作

4.
//指定kafka哪个分区从哪条记录开始消费
ConsumerStrategies.Subscribe[String, String](topics, kafkaParams,Map(new TopicPartition(topics(0),0)->90L))

 

================

pom：

<?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.tzb.bigdata</groupId>
    <artifactId>spark-test</artifactId>
    <!--<packaging>pom</packaging>-->
    <version>1.0</version>
    <!--<modules>-->
    <!--<module>hbase</module>-->
    <!--</modules>-->

    <properties>
        <scala.version>2.10.6</scala.version>
        <hadoop.version>2.6.0</hadoop.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>2.1.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_2.11</artifactId>
            <version>2.1.1</version>
        </dependency>
        <!--<dependency>-->
        <!--<groupId>org.apache.spark</groupId>-->
        <!--<artifactId>spark-sql_2.10</artifactId>-->
        <!--<version>1.6.0</version>-->
        <!--</dependency>-->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-hive_2.11</artifactId>
            <version>2.1.1</version>
        </dependency>
        <dependency>
            <groupId>com.typesafe.play</groupId>
            <artifactId>play-mailer_2.11</artifactId>
            <version>7.0.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.41</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming_2.11</artifactId>
            <version>2.1.1</version>
        </dependency>
        <!--=========================spark-streaming-kafka===========================-->
        <!--0.8版本版本-->
        <!--<dependency>-->
            <!--<groupId>org.apache.spark</groupId>-->
            <!--<artifactId>spark-streaming-kafka-0-8_2.11</artifactId>-->
            <!--<version>2.1.1</version>-->
        <!--</dependency>-->

        <!--0.10版本 新版本-->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-kafka-0-10_2.11</artifactId>
            <version>2.3.0</version>
            <exclusions>
                <exclusion>
                    <artifactId>scala-library</artifactId>
                    <groupId>org.scala-lang</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--======================================================================-->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>0.11.0.2</version>
        </dependency>


        <!--<dependency>-->
        <!--<groupId>org.scala-lang</groupId>-->
        <!--<artifactId>scala-library</artifactId>-->
        <!--<version>2.10.6</version>-->
        <!--</dependency>-->
        <!--<dependency>-->
        <!--<groupId>org.apache.hadoop</groupId>-->
        <!--<artifactId>hadoop-common</artifactId>-->
        <!--</dependency>-->

        <!--测试Hbase时再打开注释，否则idea本地连接测试环境会报错-->
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>2.0.1</version>
            <exclusions>
                <exclusion>
                    <groupId>com.fasterxml.jackson.core</groupId>
                    <artifactId>jackson-databind</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>net.sf.json-lib</groupId>
            <artifactId>json-lib</artifactId>
            <version>2.4</version>
            <classifier>jdk15</classifier>
        </dependency>
        <dependency>
            <groupId>org.neo4j.driver</groupId>
            <artifactId>neo4j-java-driver</artifactId>
            <version>4.0.0</version>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.5</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <!-- 去掉scope作用域，使用默认的compile，编译、测试、运行都有效的作用域 -->
            <!--<scope>test</scope>-->
        </dependency>
        <dependency>
            <groupId>net.minidev</groupId>
            <artifactId>json-smart</artifactId>
            <version>2.3</version>
        </dependency>
        <!-- 邮件发送 -->
        <!--<dependency>-->
        <!--<groupId>com.typesafe.play</groupId>-->
        <!--<artifactId>play-mailer_2.11</artifactId>-->
        <!--<version>7.0.0</version>-->
        <!--</dependency>-->
        <!--<dependency>-->
        <!--<groupId>org.apache.poi</groupId>-->
        <!--<artifactId>poi</artifactId>-->
        <!--<version>3.12</version>-->
        <!--</dependency>-->
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.10.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-catalyst -->
        <!--<dependency>-->
        <!--<groupId>org.apache.spark</groupId>-->
        <!--<artifactId>spark-catalyst_2.11</artifactId>-->
        <!--<version>2.3.0</version>-->
        <!--<scope>test</scope>-->
        <!--</dependency>-->
        <!--中文分词器-->
        <dependency>
            <groupId>com.huaban</groupId>
            <artifactId>jieba-analysis</artifactId>
            <version>1.0.2</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.68</version>
        </dependency>
        <!--es-->
        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch-spark-20_2.11</artifactId>
            <version>6.2.4</version>
        </dependency>
        <!--poi excel-->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>3.12</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>spark-test</finalName>
        <plugins>
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.2.2</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <!--<version>3.0.0</version>-->
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>WordCount</mainClass>
                        </manifest>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>



</project>

直接上代码：

案例1：

标签：hbase

DataChangeStreaming：
package com.tzb.sparkstreaming.prod

import java.io.{FileNotFoundException, IOException}
import java.util
import com.alibaba.fastjson.{JSON, JSONObject}
import com.tzb.utils.{ConfigUtils, HBaseUtil, StringUtil}
import net.sf.json.JSONArray
import org.apache.hadoop.hbase.TableExistsException
import org.apache.hadoop.hbase.client._
import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.log4j.{Level, Logger}
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.InputDStream
import org.apache.spark.streaming.kafka010._
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.slf4j
import org.slf4j.LoggerFactory

import scala.collection.mutable.ArrayBuffer

/**
  * <!--测试Hbase时再打开注释，否则idea本地连接测试环境会报错-->
  * SparkStreaming 版本0.10
  * 注：本程序是将sparkstreaming和kafka、hbase结合起来使用的示例，测试环境 kafka和kafka依赖的zk为210机器，hbase和hbase依赖的zk为211机器
  *
  * 本地以及210 linux测试机都已测试成功：
  * 打开kafkatool向某个主题中推送数据
  * 执行main方法，开始消费数据
  * kafkaTool发送json消息示例：
  * {
  * "tableName": "hbasetable6",
  * "option": "put",
  * "rowKey": "1001",
  * "families": [
  * "info1",
  * "info2"],
  * "cols_data": {
  * "name":"tom",
  * "age":"20"
  * }
  * }
  * 如何查看自己消费者分组 对应的 topic 的offset：
  * https://blog.51cto.com/13639264/2135877
  * [root@xg kafka_2.11-2.0.0]# bin/kafka-consumer-groups.sh --bootstrap-server 10.21.0.210:9092 --group testgroup --describe
  * Consumer group 'testgroup' has no active members.
  * TOPIC           PARTITION  CURRENT-OFFSET  LOG-END-OFFSET  LAG             CONSUMER-ID     HOST            CLIENT-ID
  * testTopic       0          8               9               1               -               -               -
  *
  * 更改指定消费者分组对应topic的offset：未生效？？
  * bin/kafka-consumer-groups.sh --bootstrap-server 10.21.0.210:9092  --group testgroup --topic testTopic--execute --reset-offsets --to-offset 9
  *
  * 打包测试（成功）：
  * spark-submit --master yarn-client --conf spark.driver.memory=2g --class com.tzb.sparkstreaming.prod.DataChangeStreaming --executor-memory 8G --num-executors 5 --executor-cores 2 /var/lib/hadoop-hdfs/spride_sqoop_beijing/bi_table/test/spark-test-jar-with-dependencies.jar >> /var/lib/hadoop-hdfs/spride_sqoop_beijing/bi_table/test/sparkstreaming_datachange.log
  * 线上跑的话要把代码里的kafka以及zk，hbase等组件的ip或域名，改为线上的，同时提交任务时把 spark-submit 改为 spark-submit2，命令后边加个&符号，则为后台启动程序，当前窗口可关闭。
  *
  * 如何停止任务：
  * 如果想停止掉这个任务则：ps -ef | grep DataChangeStreaming，并将端口kill掉即可。
  */
object DataChangeStreaming {
  // 设置日志的级别
  Logger.getLogger("org.apache").setLevel(Level.ERROR)
  val logger: slf4j.Logger = LoggerFactory.getLogger(this.getClass.getSimpleName)

  def main(args: Array[String]): Unit = {
    val sparkConf: SparkConf = new SparkConf()
      .setAppName(this.getClass.getSimpleName)
      .setMaster("local[*]")

    val ssc: StreamingContext = new StreamingContext(sparkConf, Seconds(5))

    //策略
    val preferredHosts: LocationStrategy = LocationStrategies.PreferConsistent

    //kafka topic
    val topics = Array("testTopic")
    val groupId = "testgroup"
    val kafkaParams: Map[String, Object] = Map[String, Object](
      "bootstrap.servers" -> ConfigUtils.brokers,  //kafka producer 生产者地址
      "key.deserializer" -> classOf[StringDeserializer].getName,
      "value.deserializer" -> classOf[StringDeserializer].getName,
      "group.id" -> groupId,
      //latest, earliest, none
      "auto.offset.reset" -> "earliest",
      "enable.auto.commit" -> "false" // 不自动提交
    )

    val stream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream[String, String](
      ssc,
      preferredHosts,
      ConsumerStrategies.Subscribe[String, String
最低0.47元/天 解锁文章
花和尚也有春天
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Spark实战系列】sparkstreaming 消费 kafka0.10 中的 LocationStrategies 和 ConsumerStrategies 代表的是什么含义?
JasonLee实时计算
03-13 5868
LocationStrategies 新的Kafka使用者API将预先获取消息到缓冲区。因此，出于性能原因，Spark集成将缓存的消费者保留在执行程序上（而不是为每个批处理重新创建它们），并且更喜欢在具有适当使用者的主机位置上安排分区，这一点很重要。 在大多数情况下，您应该使用LocationStrategies.PreferConsistent，如上所示。这将在可用执行程序之间均匀分配分区。...
流式数据采集和计算（五）：Spark Streaming开发范例
叶子叶来
01-22 5398
一、使用foreach实现socket的实时读取并写入mysql中： -------------------------------- import java.sql.DriverManager import org.apache.spark.SparkConf import org.apache.spark.streaming.{Seconds, StreamingConte...
Kafka 本地策略 LocationStragies:PreferConsistent
RayfunC的博客
04-27 4464
创建 Direct 方式的 Stream 注意导入的包名称以及版本是 org.apache.spark.streaming.kafka010 Scala 代码： import org.apache.kafka.clients.consumer.ConsumerRecord import org.apache.kafka.common.serialization.StringDeserial...
【大数据开发】Kafka——Spark2.x中消费者LocationStrategies、ConsumerStrategies的几种方式
白色风车
10-28 1142
一、LocationStrategy 大多数情况下，需要使用LocationStrategies.PreferConsistent，这会把partition平均分配到可用的executor上。如果executor和kafka的broker在同一台机器上，就要使用PreferBrokers，这样which will prefer to schedule partitions on the Kafka leader for that partition。最后，如果在partition中又严重的倾斜，使用Pref
Spark Streaming + Kafka Integration Guide 位置策略和消费策略译文
吟啸徐行
03-13 4238
LocationStrategies 位置策略 The new Kafka consumer API will pre-fetch messages into buffers. Therefore it is important for performance reasons that the Spark integration keep cached consumers on execut
SparkStreaming消费Kafka的两种方式
别人笑我太疯癫，我笑他人看不穿。
03-05 3190
一，receiver方式读取 这种方式使用Receiver来获取数据。Receiver是使用Kafka的高层次Consumer API来实现数据的消费。 receiver方式从Kafka中获取的数据都是存储在Spark Executor的内存中的，然后Spark Streaming启动的job会去处理那些数据。 但是在默认的配置下，这种方式可能会因为底层的失败而丢失数据，因为消费时kafka的高级API是不会去维护偏移量的 要启用高可靠机制，让数据零丢失，启用Spark Streaming的预写日志机制（W
SparkStreaming_HBase:将从Kafka收集过来的数据保存到HBase中
04-20
SparkStreaming_HBase将从Kafka收集过来的数据保存到HBase中数据来源：日志生成器。 编写一个python工程，用于产生行为日志，每运行一次，产生所设定的数量数据，使用Linux的定时器，每隔60s执行一次，行为日志保存...
MichaelG.Noll：整合Kafka到SparkStreaming——代码示例和挑战
03-03
本文，Verisign实验室大规模数据分析基础设施的技术主管Michael通过示例对Kafka整合到SparkStreaming进行了详细讲解，更分享了该领域的现状和一些注意点。作者MichaelG.Noll是瑞士的一位工程师和研究员，效力于...
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...
SparkStreaming：Spark Streaming + Flume + Kafka + HBase + Hadoop + Zookeeper实现实时日志分析统计； SpringBoot + Echarts实现数据可视化展示
02-05
生成的数据主要是模拟某学习网站学习视频课程的访问量（其中*以“ / class”开头的表示实战课程，然后通过流水线Flume + Kafka + SparkStreaming进行实时日志的收集，HBase来存储数据）*注意事项（使用的软件工具及...
SparkStreaming实时数仓——数据采集
平平无奇小码农~
11-11 882
文章目录一、实时需求概述1.1 实时需求与离线需求的比较离线需求实时需求1.2 实时需求和离线需求的对比1.1.1 离线架构1.1.2 实时架构二、模拟日志数据2.1 模拟数据需要用到的文件列表2.1.1 修改application.properties2.1.2 修改logback.xml落盘工具使用logback, 类似于log4j2.2 生成模拟数据2.3 创建日志服务器2.3.1 在project中创建springboot子模块2.3.2 创建cont
一零三五、Spark-streaming实现获取流数据
最新发布
10-08 917
nc是netcat的简称，原本是用来设置路由器,我们可以利用它向某个端口发送数据。程序运行时，终端开启9999端口模拟输入。控制台每隔10秒获取一次流数据，如图。虚拟机终端安装netcat。
Spark Streaming Demo练习
huonan_123的博客
11-16 1378
1.Spark Streaming WC 的简单统计练习 2. Basic Source For text files streamingContext.textFileStream(dataDirectory) 3.包括 通过 DataFrame SparkSQL 统计
SparkStreaming 整合kafka Demo
qq_41676216的博客
07-13 303
SparkStreaming 整合kafka Demo 这里使用的是低级API，因为高级API非常不好用，需要繁琐的配置，也不够自动化，却和低级API的效果一样，所以这里以低级API做演示 你得有zookeeper和kafka 我这里是3台节点主机 架构图 与高级API的区别,简单并行(不需要创造多个输入流，它会自动并行读取kafka的数据)，高效（不会像receiver数据被copy两次),一次性语义（缺点：无法使用zookeeper的监控工具） 1.创建maven工程 首先..
SparkStreaming 4个实用Demo的详细记录
0117
08-13 856
文章目录目标一：updateStateByKey算子的使用 本文将会介绍四个Demo案例，分别是updateStateByKey算子的使用，SparkStreaming写入mysql，窗口函数的使用和黑名单的过滤，然后会将代码分享到github 目标一：updateStateByKey算子的使用 首先我们先看看官网对于这个算子的介绍： 大意是，此算子可以在保持任意状态下去更新信息，但是有两个要...
SparkStreaming-实时数据采集
吃鱼的博客
10-19 911
1.SparkStreaming的架构 2.实例 一个实时计算的wordcount object WordCount { def main(args: Array[String]): Unit = { //使用sparkstreaming来完成wordcount //spark的配置对象 val conf = new SparkConf().setMaster("l...
SparkStreaming---简单demo(NetCat)
shall潇の菜园
06-22 308
本文主要讲：利用 SparkStreaming 方式读取并处理 通过Netcat方式获得的数据 文章目录一、导入依赖二、编写程序三、测试 一、导入依赖 <dependency> <groupId>org.apache.spark</groupId> <artifactId>spark-core_2.11</artifactId> <version>2.4.7</version> </dependency.
spark读kafka数据 hbase存储
mllhxn的专栏
07-27 884
  package spark88.utils import kafka.common.TopicAndPartition import kafka.message.MessageAndMetadata import kafka.serializer.StringDecoder import kafka.utils.ZkUtils import org.apache.hadoop.hbase...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值