Streaming消费Kafka数据,存入HBase(详细案例,附HBase工具类)

最新推荐文章于 2023-03-23 10:30:47 发布
最新推荐文章于 2023-03-23 10:30:47 发布
阅读量768 收藏 8
点赞数 2
分类专栏： 案例 文章标签： kafka streaming hbase spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yang_1103002408/article/details/109073798
版权

前言

0.闲话少说,直接上代码
1.自定义的Kafka生产者实时向Kafka发送模拟数据;
2.Streaming使用Direct模式拉取Kafka中数据,经处理后存入HBase.

一、依赖文件(注意HBase版本对应)

<!-- 指定仓库位置，依次为aliyun、cloudera和jboss仓库 -->
    <repositories>
        <repository>
            <id>aliyun</id>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        </repository>
        <repository>
            <id>cloudera</id>
            <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
        </repository>
    </repositories>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <encoding>UTF-8</encoding>
        <scala.version>2.11.8</scala.version>
        <scala.compat.version>2.11</scala.compat.version>
        <hadoop.version>2.7.4</hadoop.version>
        <spark.version>2.2.0</spark.version>
    </properties>

    <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.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>2.7.4</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-streaming-kafka-0-10_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>1.2.0-cdh5.14.0</version>
        </dependency>
    </dependencies>

二、Producer

package kafka_streaming_hbase

import java.util.Properties
import org.apache.kafka.clients.producer.{KafkaProducer, ProducerRecord}

/*
* @Auther  Yang
* @Date  13:56 2020/10/10
* 向指定的Kafka主题发送模拟数据
*/
object ProducerTest {
  def main(args: Array[String]): Unit = {
  //kafka参数配置
    val topic = "MyTest"
    val prop = new Properties()
    prop.put("bootstrap.servers", "node01:9092")
    prop.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer")
    prop.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer")
	//创建Kafka的Producer
    val producer = new KafkaProducer[String, String](prop)
    val content: Array[String] = new Array[String](5)
    content(0) = "apache hadoop hive"
    content(1) = "sqoop flume spark"
    content(2) = "hello world flink"
    content(3) = "hive flume sqoop"
    content(4) = "hbase spark kafka"
    //随机向Kafka指定Topic发送数据
    while (true) {
      val i: Int = (math.random * 5).toInt
      producer.send(new ProducerRecord[String, String](topic, content(i)))
      println(content(i))
      Thread.sleep(2000)
    }
  }
}

三、Consumer(自动维护偏移量版本)

package kafka_streaming_hbase

import java.util.UUID

import kafka_streaming_hbase.utils.HbaseUtils
import org.apache.hadoop.hbase.client.Put
import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010._
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

/*
* @Auther  Yang
* @Date  18:22 2020/10/13
* Streaming拉取Kafka数据处理写入HBase
*/
object Streaming2HBase {
  def main(args: Array[String]): Unit = {
    //实际开发中需要传参
    /*if (args.length != 4) {
      println("请输入参数:<1><2><3><4>")
      System.exit(1)
    }*/
    //1.Streaming环境准备
    val conf: SparkConf = new SparkConf().setAppName("Kafka_Streaming_HBase").setMaster("local[*]")
    val sc: SparkContext = new SparkContext(conf)
    sc.setLogLevel("error")
    val ssc = new StreamingContext(sc, Seconds(4))

    //2.准备kafka参数
    val kafkaParams: Map[String, Object] = Map[String, Object](
      "bootstrap.servers" -> "node01:9092", //Kafka集群地址
      "key.deserializer" -> classOf[StringDeserializer], //key的反序列化类型
      "value.deserializer" -> classOf[StringDeserializer], //value的反序列化类型
      "group.id" -> "spark", //消费者组id
      "auto.offset.reset" -> "latest", //偏移量自动重置位置
      "enable.auto.commit" -> (true: java.lang.Boolean), //自动提交偏移量到Kafka的默认主题__consumer_offsets
    )
    val topics: Array[String] = Array("MyTest") //要订阅的主题

    //3.获取Kafka数据源
    val kafkaDStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(
      ssc,
      LocationStrategies.PreferConsistent,
      ConsumerStrategies.Subscribe(topics, kafkaParams)
    )

    //4.拉取到的数据做WordCount
    val word_count: DStream[(String, Int)] = kafkaDStream.flatMap(_.value().split("\\s+")).map((_, 1)).reduceByKey(_ + _)

    //5.给WordCount后的数据添加UUID随机数,作为Rowkey(实际开发中Rowkey根据业务需求设计)
    val input: DStream[(String, String, Int)] = word_count.map(word_one => (UUID.randomUUID().toString, word_one._1, word_one._2))

    //6.数据落地,发送至HBase
    input.foreachRDD(rdd => {
      rdd.foreach(x => {
        val put = new Put(x._1.getBytes())
        put.addColumn("info".getBytes(), "word".getBytes(), x._2.getBytes())
        put.addColumn("info".getBytes(), "count".getBytes(), x._3.toString.getBytes())
        HbaseUtils.put("MyTest", put)
      })
    })

    //7.启动程序,并等待关闭
    ssc.start()
    ssc.awaitTermination()
  }
}

四、Consumer(手动维护偏移量版本)

package kafka_streaming_hbase

import java.util.UUID

import kafka_streaming_hbase.utils.HbaseUtils
import org.apache.hadoop.hbase.client.Put
import org.apache.kafka.clients.consumer.ConsumerRecord
import org.apache.kafka.common.serialization.StringDeserializer
import org.apache.spark.rdd.RDD
import org.apache.spark.streaming.dstream.{DStream, InputDStream}
import org.apache.spark.streaming.kafka010._
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}

/*
* @Auther  Yang
* @Date  18:22 2020/10/13
* Streaming拉取Kafka数据处理写入HBase
*/
object Streaming2HBase2 {
  def main(args: Array[String]): Unit = {
    //实际开发中需要传参
    /*if (args.length != 4) {
      println("请输入参数:<1><2><3><4>")
      System.exit(1)
    }*/
    //1.Streaming环境准备
    val conf: SparkConf = new SparkConf().setAppName("Kafka_Streaming_HBase").setMaster("local[*]")
    val sc: SparkContext = new SparkContext(conf)
    sc.setLogLevel("error")
    val ssc = new StreamingContext(sc, Seconds(4))

    //2.准备kafka参数
    val kafkaParams: Map[String, Object] = Map[String, Object](
      "bootstrap.servers" -> "node01:9092", //Kafka集群地址
      "key.deserializer" -> classOf[StringDeserializer], //key的反序列化类型
      "value.deserializer" -> classOf[StringDeserializer], //value的反序列化类型
      "group.id" -> "spark", //消费者组id
      "auto.offset.reset" -> "latest", //偏移量自动重置位置
      "enable.auto.commit" -> (false: java.lang.Boolean) //自动提交偏移量到Kafka的默认主题__consumer_offsets中
      //"auto.commit.interval.ms" -> "1000" //自动提交的时间间隔
    )
    val topics: Array[String] = Array("MyTest") //要订阅的主题

    //3.获取Kafka数据源
    val kafkaDStream: InputDStream[ConsumerRecord[String, String]] = KafkaUtils.createDirectStream(
      ssc,
      LocationStrategies.PreferConsistent,
      ConsumerStrategies.Subscribe(topics, kafkaParams)
    )

    //4.拉取到的数据做WordCount
    kafkaDStream.foreachRDD(rdd => {
      if (rdd.count() > 0) {
        val word_count: RDD[(String, Int)] = rdd.flatMap(_.value().split("\\s+"))
          .map((_, 1))
          .reduceByKey(_ + _)
        val result: RDD[(String, String, Int)] = word_count.map(x => (UUID.randomUUID().toString, x._1, x._2))
        result.foreach(x => {
          val put = new Put(x._1.getBytes())
          put.addColumn("info".getBytes(), "word".getBytes(), x._2.getBytes())
          put.addColumn("info".getBytes(), "word".getBytes(), x._3.toString.getBytes())
          HbaseUtils.put("MyTest", put)
        })

        //4.1 获取该批次rdd的偏移量
        val offsetRanges: Array[OffsetRange] = rdd.asInstanceOf[HasOffsetRanges].offsetRanges
        //4.2 提交该批次的偏移量
        kafkaDStream.asInstanceOf[CanCommitOffsets].commitAsync(offsetRanges)
      }
    })

    //7.启动程序,并等待关闭
    ssc.start()
    ssc.awaitTermination()
  }
}

五、附HBase工具类

package kafka_streaming_hbase.utils;

import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * Hbase 操作工具类
 * 
 * @author yang
 * @version 1.0.0
 * @createDate 2019-05-03
 *
 */
public class HbaseUtils {

    // ===============Common=====================================

    /**
     * 根据表名获取Table对象
     * 
     * @param name 表名，必要时可指定命名空间，比如：“default:user”
     * @return Hbase Table 对象
     * @throws IOException 有异常抛出，由调用者捕获处理
     */
    public static Table getTable(String name) throws IOException {
        TableName tableName = TableName.valueOf(name);
        Connection connection = ConnectionFactory.createConnection();
        return connection.getTable(tableName);
    }

    // =============== Put =====================================

    /**
     * 根据rowKey生成一个Put对象
     * 
     * @param rowKey rowKey
     * @return Put对象
     */
    public static Put createPut(String rowKey) {
        return new Put(Bytes.toBytes(rowKey));
    }

    /**
     * 在Put对象上增加Cell
     * 
     * @param put Put对象
     * @param cell cell对象
     * @throws IOException 有异常抛出，由调用者捕获处理
     */
    public static void addCellOnPut(Put put, Cell cell) throws IOException {
        put.add(cell);
    }

    /**
     * 在Put对象上增加值
     * 
     * @param put Put对象
     * @param family 列簇
     * @param qualifier 列
     * @param value 字符串类型的值
     */
    public static void addValueOnPut(Put put, String family, String qualifier, String value) {
        addValueOnPut(put, family, qualifier, Bytes.toBytes(value));
    }

    /**
     * 在Put对象上增加值
     * 
     * @param put Put对象
     * @param family 列簇
     * @param qualifier 列
     * @param value 字节数组类型的值，可以是任意对象序列化而成
     */
    public static void addValueOnPut(Put put, String family, String qualifier, byte[] value) {
        put.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier), value);
    }

    /**
     * 在Put对象上增加值
     * 
     * @param put Put对象
     * @param family 列簇
     * @param qualifier 列
     * @param ts Timestamp时间戳
     * @param value 字符串类型的值
     */
    public static void addValueOnPut(Put put, String family, String qualifier, long ts, String value) {
        addValueOnPut(put, family, qualifier, ts, Bytes.toBytes(value));
    }

    /**
     * 在Put对象上增加值
     * 
     * @param put Put对象
     * @param family 列簇
     * @param qualifier 列
     * @param ts Timestamp时间戳
     * @param value 字节数组类型的值，可以是任意对象序列化而成
     */
    public static void addValueOnPut(Put put, String family, String qualifier, long ts, byte[] value) {
        put.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier), ts, value);
    }

    /**
     * 按表名插入一个Put对象包含的数据
     * 
     * @param tableName 表名，必要时可指定命名空间，比如：“default:user”
     * @param put 要插入的数据对象
     * @throws IOException 有异常抛出，由调用者捕获处理
     */
    public static void put(String tableName, Put put) throws IOException {
        try (
                Table table = getTable(tableName);
        ) {

            table.put(put);
        }
    }

    /**
     * 按表名批量插入Put对象包含的数据
     * 
     * @param tableName 表名，必要时可指定命名空间，比如：“default:user”
     * @param puts 要插入的数据对象集合
     * @throws IOException 有异常抛出，由调用者捕获处理
     */
    public static void put(String tableName, List<Put> puts) throws IOException {
        try (
                Table table = getTable(tableName);
        ) {

            table.put(puts);
        }
    }

    // =============== Get =====================================

    /**
     * 根据rowKey生成一个查询的Get对象
     * 
     * @param rowKey rowKey
     * @return Get 对象
     */
    public static Get createGet(String rowKey) {
        return new Get(Bytes.toBytes(rowKey));
    }

    /**
     * 对查询的Get对象增加指定列簇
     * 
     * @param get
     * @param family
     */
    public static void addFamilyOnGet(Get get, String family) {
        get.addFamily(Bytes.toBytes(family));
    }

    /**
     * 对查询的Get对象增加指定列簇和列
     * 
     * @param get
     * @param family
     * @param qualifier
     */
    public static void addColumnOnGet(Get get, String family, String qualifier) {
        get.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
    }

    /**
     * 根据表名和rowKey查询结果（包含全部列簇和列）
     * 
     * @param tableName 表名，必要时可指定命名空间，比如：“default:user”
     * @param rowKey 查询rowKey
     * @return 查询结果Result
     * @throws IOException 有异常抛出，由调用者捕获处理
     */
    public static Result get(String tableName, String rowKey) throws IOException {
        Get get = createGet(rowKey);
        return get(tableName, get);
    }

    /**
     * 根据表名和rowKey数组批量查询结果（包含全部列簇和列）
     * 
     * @param tableName 表名，必要时可指定命名空间，比如：“default:user”
     * @param rowKeys 查询rowKey数组
     * @return 查询结果Result数组
     * @throws IOException 有异常抛出，由调用者捕获处理
     */
    public static Result[] get(String tableName, String[] rowKeys) throws IOException {
        List<Get> gets = new ArrayList<Get>();
        for (String rowKey : rowKeys) {
            gets.add(createGet(rowKey));
        }
        return get(tableName, gets);
    }

    /**
     * 根据表名和Get对象查询结果
     * 
     * @param tableName 表名，必要时可指定命名空间，比如：“default:user”
     * @param get Hbase查询对象
     * @return 查询结果Result
     * @throws IOException 有异常抛出，由调用者捕获处理
     */
    public static Result get(String tableName, Get get) throws IOException {
        try (
                Table table = getTable(tableName);
        ) {

            return table.get(get);
        }
    }

    /**
     * 根据表名和Get对象数组查询结果
     * 
     * @param tableName 表名，必要时可指定命名空间，比如：“default:user”
     * @param gets 多个Hbase查询对象组成的数组
     * @return 查询结果Result数组
     * @throws IOException 有异常抛出，由调用者捕获处理
     */
    public static Result[] get(String tableName, List<Get> gets) throws IOException {
        try (
                Table table = getTable(tableName);
        ) {
            return table.get(gets);
        }
    }

    // =============== Scan =====================================

    /**
     * 根据startRow和stopRow创建扫描对象
     * 
     * @param startRow 扫描开始行，结果包含该行
     * @param stopRow 扫描结束行，结果不包含该行
     * @return Scan对象
     */
    /*public static Scan createScan(String startRow, String stopRow) {
        Scan scan = new Scan();
        scan.withStartRow(Bytes.toBytes(startRow));
        scan.withStopRow(Bytes.toBytes(stopRow));
        return scan;
    }*/

    /**
     * 对扫描对象设置列簇
     * 
     * @param scan 扫描对象
     * @param family 列簇
     */
    public static void addFamilyOnScan(Scan scan, String family) {
        scan.addFamily(Bytes.toBytes(family));
    }

    /**
     * 对扫描对象设置列
     * 
     * @param scan 扫描对象
     * @param family 列簇
     * @param qualifier 列簇下对应的列
     */
    public static void addColumnOnScan(Scan scan, String family, String qualifier) {
        scan.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
    }

    /**
     * 根据表名和扫描对象扫描数据
     * 
     * @param tableName 表名，必要时可指定命名空间，比如：“default:user”
     * @param scan 扫描对象
     * @return 扫描结果集对象ResultScanner
     * @throws IOException 有异常抛出，由调用者捕获处理
     */
    public static ResultScanner scan(String tableName, Scan scan) throws IOException {
        try (
                Table table = getTable(tableName);
        ) {
            return table.getScanner(scan);
        }
    }

    /**
     * 根据表名、开始行和结束行扫描数据（结果包含开始行，不包含结束行，半开半闭区间[startRow, stopRow)）
     * 
     * @param tableName 表名，必要时可指定命名空间，比如：“default:user”
     * @param startRow 扫描开始行
     * @param stopRow 扫描结束行
     * @return 扫描结果集对象ResultScanner
     * @throws IOException 有异常抛出，由调用者捕获处理
     */
    /*public static ResultScanner scan(String tableName, String startRow, String stopRow) throws IOException {
        return scan(tableName, createScan(startRow, stopRow));
    }*/

    // =============== Delete =====================================

    /**
     * 根据rowKey生成一个查询的Delete对象
     * 
     * @param rowKey rowKey
     * @return Delete对象
     */
    public static Delete createDelete(String rowKey) {
        return new Delete(Bytes.toBytes(rowKey));
    }

    /**
     * 在Delete对象上增加Cell
     * 
     * @param delete Delete对象
     * @param cell cell对象
     * @throws IOException 有异常抛出，由调用者捕获处理
     */
    /*public static void addCellOnDelete(Delete delete, Cell cell) throws IOException {
        delete.add(cell);
    }*/

    /**
     * 对删除对象增加指定列簇
     * 
     * @param delete Delete对象
     * @param family 列簇
     */
    public static void addFamilyOnDelete(Delete delete, String family) {
        delete.addFamily(Bytes.toBytes(family));
    }

    /**
     * 对删除对象增加指定列簇和列
     * 
     * @param delete Delete对象
     * @param family 列簇
     * @param qualifier 列
     */
    public static void addColumnOnDelete(Delete delete, String family, String qualifier) {
        delete.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
    }

    /**
     * 按表名删除一个Delete对象指定的数据
     * 
     * @param tableName 表名，必要时可指定命名空间，比如：“default:user”
     * @param delete Delete对象
     * @throws IOException 有异常抛出，由调用者捕获处理
     */
    public static void delete(String tableName, Delete delete) throws IOException {
        try (
                Table table = getTable(tableName);
        ) {
            table.delete(delete);
        }
    }

    /**
     * 按表名批量删除Delete对象集合包含的指定数据
     * 
     * @param tableName 表名，必要时可指定命名空间，比如：“default:user”
     * @param deletes Delete对象集合
     * @throws IOException 有异常抛出，由调用者捕获处理
     */
    public static void delete(String tableName, List<Delete> deletes) throws IOException {
        try (
                Table table = getTable(tableName);
        ) {
            table.delete(deletes);
        }
    }

}

scan HBase中的数据,发现数据插入进来了!

注意:

1.HBase先建表:

create 'MyTest','info'

2.HBase-Client的依赖注意对应版本,版本不对会报反序列化异常
3.启动顺序zookeeper->hdfs->kafka->HBase,使用HBase shell管理查看HBase

吾发长存
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基于spark streaming+kafka+hbase的日志统计分析系统源码+项目说明.zip
01-15
【资源说明】 1、该资源包括项目的全部源码，下载可以直接使用！ 2、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设...基于spark streaming+kafka+hbase的日志统计分析系统源码+项目说明.zip
数据从kafka倒Hbase
qq_43012693的博客
01-16 237
需要文件： user_friends.csv 文件路径： /opt/flume/conf/jobkb09/dataSource/userFriend/ /opt/flume/conf/jobkb09/dataChannel/userFriend/ /opt/flume/conf/jobkb09/checkpointFile/userFriend/ 一、实现flume读取文件到kafka 1、配置flume userFriend.sources=userFriendSource userFriend.cha
使用Spark Structured Streaming将Kafka的数据写入到Hudi数据湖中
czladamling的博客
03-23 388
使用Spark Structured Streaming将Kafka的数据写入到Hudi数据湖中。
SparkStreaming消费Kafka，数据实时写入Hbase集群，Java版本
wunanliu的采坑日记
07-03 791
SparkStreaming消费Kafka，数据实时写入Hbase集群，Java代码
spark streaming 读kafka写入hbase报错
eyeofeagle的博客
11-30 1025
使用spark streaming消费kafka topic系消息， 再写入到hbase中， 使用spark submit 他job时，报了一些错误， 此处归纳一下： 1, io.netty.handler.codec.EncoderException: java.lang.NoSuchMethodError: io.netty.channel.DefaultFileRegion.(Ljava/i...
spark streaming 结合kafka 精确消费一次将结果保存到hbase
xiaohu21的博客
12-06 949
spark streaming 结合kafka 精确消费一次将结果保存到hbase 1. 环境 scala 2.12.12 jdk 1.8 idea 2020.1 maven 3.6.3 spark 3.0.1 kafka 0.10 hadoop 3.2.1 hbase 2.2.5 （另外一个明细数据幂等处理，保存到habse） redis 5.0 pom <!-- 定义了一些常量 --> <properties> <maven.compiler.s
Kafka集成Spark Streaming并写入数据到HBase
01-17
使用方法： 请使用eclipse的maven导入方式导入，代码在http://blog.csdn.net/q79969786/article/details/42793487有介绍
SparkStreaming_HBase:将从Kafka收集过来的数据保存到HBase中
04-20
SparkStreaming_HBase将从Kafka收集过来的数据保存到HBase中数据来源：日志生成器。 编写一个python工程，用于产生行为日志，每运行一次，产生所设定的数量数据，使用Linux的定时器，每隔60s执行一次，行为日志保存...
基于Kafka+SparkStreaming+HBase某信贷实时数据采集存储
02-11
项目以宜信贷风控系统实时数据采集系统为背景，主要描述了技术架构、核心技术难点及代码实现全过程，涉及技术包括但不限于：Kafka\zookeeper,Spark，SparkStreaming，HBase，实时访问技术，爬虫技术等
基于Spark streaming+Kafka+Redis/HBase的GBDT+LR推荐排序模型
最新发布
12-28
1、资源内容：基于Spark streaming+Kafka+Redis/HBase的GBDT+LR推荐排序模型 2、代码特点：内含运行结果，不会运行可私信，参数化编程、参数可方便更改、代码编程思路清晰、注释明细，都经过测试运行成功，功能ok的...
spark-streaming消费kafka写入hbase踩坑实战
qq_34936033的博客
02-11 1028
场景 otter同步mysql的数据到kafka，spark-streaming消费kafka，采用motator异步写hbase。mysql的insert，update，delete特别频繁，每秒都有大量的insert，delete，update 以下都是基于同一条数据操作 1. 坑 Delete(byte [] row), Put(byte[] row)， bufferedmu...
spark-streaming消费kafka写hbase代码实战调优
qq_34936033的博客
02-11 335
1、处理逻辑 通过新增map集合来提升处理性能 2、资源配置 --executor-cores 3 \ --num-executors 5\ --executor-memory 2G \ --driver-memory 2G \ 3、测试场景 这个topic有15个分区，并且数据量挺大，所以需要15个core处理，从earliest消费写到测试表，4千万的数据量 第三次...
kafka通过spark-streaming往hbase里写数据
qq_28286027的博客
03-20 1052
1.启动kafka： ]# ./bin/kafka-server-start.sh config/server.properties 2 查看topic list ./bin/kafka-topics.sh --list --zookeeper localhost:2181 3.streaming代码： package com.badou.streaming import org.ap...
kafka数据导入hbase
热门推荐
桃花惜春风
08-24 1万+
我们在使用kafka处理数据的过程中会使用kafka跟一下数据库进行交互，Hbase就是其中的一种。下面给大家介绍一下kafka中的数据是如何导入Hbase的。 本文的思路是通过consumers把数据消费到Hbase中。 首先在Hbase中创建表，创建表可以在Hbase客户端创建也可以通过API创建，这里介绍通过API创建表的方法： 创建CreatTableTest类 ...
Flink学习笔记（五）：与kafka、HBase整合案例
gentlewei的博客
02-09 1592
文章目录案例1.从kafka读取数据再写入kafka案例2.从kafka读取数据写入hbase案例3.从kafka读取数据写入Mysql 案例1.从kafka读取数据再写入kafka 环境： flink版本：1.7.2 kafka版本：2.1.1 flink与kafka交互有多种方式，本案例通过dataStream的addSource和addSink的方式与kafka交互。flink默认支持k...
Kafka数据写入Hbase (含设计模式简单使用)
小财迷嘻嘻的博客
01-15 1123
设计模式详解可以看菜鸟教程：https://www.runoob.com/design-pattern/singleton-pattern.html 我们将kafka的数据写进HBase中，都是在一个main方法中的，这显然是个小白做法，下面我们用设计模式实现，降低依赖，降低耦合，增加代码的可重用性。 pom依赖： <dependency> <groupId>org.apache.kafka</groupId> <artifactId&gt
CC00016.bdpositions——|Hadoop&实时数仓.V16|——|项目.v16|ODS层处理|将kafka中的维表写入DIM层.V4|
yanqi_vip
04-15 194
一、启动相关服务 ### --- 启动相关服务 ~~~ # 启动zookeeper服务 [root@hadoop01 ~]# ./zk.sh start ~~~ # 启动kafka服务：所有节点 [root@hadoop01 ~]# kafka-server-start.sh -daemon /opt/yanqi/servers/kafka_2.12/config/s...
scala版本,spark将HDFS上的数据同步到hbase
AyubLIbra的博客
03-10 2231
1 spark将HDFS上的数据同步到hbase 将hdfs数据转换为hfile, 快速导入hbase 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="htt
请帮我写一个flink将kafka数据存入hbase，语言使用scala2.12，flink版本为1.14.0
03-25
以下是一个简单的示例代码，通过Flink将Kafka数据存入HBase： ``` import org.apache.flink.api.common.functions.MapFunction import org.apache.flink.api.common.serialization.SimpleStringSchema import org....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值