SparkStreaming读取Kafka的数据并写入到HBase

最新推荐文章于 2022-04-15 17:44:14 发布
最新推荐文章于 2022-04-15 17:44:14 发布
阅读量2.3k 收藏 17
点赞数 1
分类专栏： spark 文章标签： SparkStreaming Kafka HBase读写
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43823423/article/details/103278316
版权

1、编写HBase工具类

package HBaseDao;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.client.HBaseAdmin;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Put;
import java.io.IOException;

/*
*
*   操作Hbase的工具类
* */
public class HBaseUtils {
    HBaseAdmin admin = null;
    Configuration configuration = null;
    /*
     *  私有化构造器
     * */
    private HBaseUtils() {
        configuration = new Configuration();
        configuration.set("hbase.zookeeper.quorum","qyl01,qyl02,qyl03");
        configuration.set("hbase.rootdir","hdfs:///hbase");
        try{
            admin = new HBaseAdmin(configuration);
        }
        catch(IOException e){
            e.printStackTrace();
        }
    }
    private static HBaseUtils instance = null;

    public static HBaseUtils getInstance() {
        if (null == instance){
            instance = new HBaseUtils();
        }
        return instance;
    }
    /*
    *   根据表名获取HBase实例
    *   @param tableName
    *   @return
    * */
    public HTable getTable(String tableName){
        HTable table  = null ;
        try {
            table  = new HTable(configuration, tableName);
        }catch (IOException e){
            e.printStackTrace();
        }
        return table;
    }

    /**
     * 添加一条记录到HBase表
     * @param tableName 表名
     * @param rowkey rowkey
     * @param cf columnFamily
     * @param column 列
     * @param value 写入的值
     */
    public void put(String tableName,String rowkey,String cf,String column,String value){
        HTable table = getTable(tableName);
        Put put = new Put(rowkey.getBytes());
        put.add(cf.getBytes(),column.getBytes(),value.getBytes());

        try{
            table.put(put);
        }catch (IOException e){
            e.printStackTrace();
        }
    }
    /*
    * 插入一条数据到HBase中进行操作
    * */
/*
    public static void main(String[] args) {
        String tableName = "course_clickcount";
        String rowkey = "20191111_188";
        String cf = "info";
        String column = "click_count";
        String value = "2";
        HBaseUtils.getInstance().put(tableName,rowkey,cf,column,value);

      }
*/
}

2、编写HBase操作类

package HBaseDao

import java.io.IOException

import org.apache.hadoop.hbase.client.Get
import org.apache.hadoop.hbase.util.Bytes

import scala.collection.mutable.ListBuffer

/*
* 操作hbase的dao
* */
object ClickCourseCountDao {
    /*
    * hbase中的各参数，参照个人配置
    * */
  val tableName = "course_clickcount"
  val cf = "info"
  val column = "clickcount"


  /*
  * 插入结果数据的方法
  * */
  def save(List:ListBuffer[ClickCoursCount]):Unit = {
       val htable = HBaseUtils.getInstance().getTable(tableName)
       for(clk <- List){
         htable.incrementColumnValue(
           clk.dayCourse.getBytes(),
           cf.getBytes(),
           column.getBytes(),
           clk.clickCount
         )
       }
  }
  /*
  * 取出tableName中column对应的value的数据
  * */
  def count(dayCourse:String):Long = {
    val htable = HBaseUtils.getInstance().getTable(tableName)
    val get = new Get(dayCourse.getBytes())
    val value = htable.get(get).getValue(cf.getBytes(),column.getBytes())
    if(null == value){
      0L
    }else{
      Bytes.toLong(value)
    }
  }




  def main(args: Array[String]): Unit = {
      val listbuffer = new ListBuffer[ClickCoursCount]
     /*
     * 插入数据测试
     * */
      listbuffer.append(ClickCoursCount("20191111_88",1L))
      listbuffer.append(ClickCoursCount("20191111_88",2L))
      listbuffer.append(ClickCoursCount("20191111_88",2L))
      save(listbuffer)

     println(count("20191111_88")+"------"+count("20191111_88"))

  }
}
  /*
  * 点击量的实体类
  * */
case class ClickCoursCount(dayCourse:String,clickCount:Long)

3、编写SparkStreaming代码读取Kafka的数据写入HBase

package com.bonc.qyl.Spark

import HBaseDao.{ClickCoursCount, ClickCourseCountDao}
import kafka.serializer.StringDecoder
import org.apache.spark.SparkConf
import org.apache.spark.streaming.dstream.DStream
import org.apache.spark.streaming.kafka.KafkaUtils
import org.apache.spark.streaming.{Seconds, StreamingContext}

import scala.collection.mutable.ListBuffer

/*
*  flume + kafka +SparkStreaming +HBase
* */
object ProjectStreaming {
  def main(args: Array[String]): Unit = {
    /*
    *    实际项目中 应该是传入参数，这里不做演示了
    * if(args.length != 2){
      System.err.println("Usage ProjectStreaming: <brokers> <topics>")
      System.exit(1)
    }
   */

    /*
    * 建立连接
    * */
    System.setProperty("HADOOP_USER_NAME","qyl")
    val conf = new SparkConf().setMaster("local[2]").setAppName("ProjectStreaming")
    val ssc = new StreamingContext(conf,Seconds(5))
    ssc.checkpoint("hdfs:///flume-kafka-direct")

    /*
    *  读取kafka中的数据
    * */
    val kafkaParams = Map[String,String]("metadata.broker.list" -> "qyl01:9092,qyl02:9092,qyl03:9092","auto.offset.reset" -> "smallest")
    val topics = Set("flume-kafka-sparkStreaming-HBase1")
    val kafkaDStream: DStream[String] = KafkaUtils.createDirectStream
      [String, String, StringDecoder, StringDecoder](ssc,kafkaParams,topics).map(_._2)

    /*
  * 数据过滤
  * 数据格式
  * 132.168.89.224    2018-07-13 05:53:02 "GET /class/145.html HTTP/1.1"  200 https://search.yahoo.com/search?p=Flink实战
  * */
    val   cleanData : DStream[ClickLog]  = kafkaDStream.map { x =>
      val strArr = x.split("\t")
        val ip = strArr(0)
        val time = strArr(1).substring(0,10).trim()
        val refer = strArr(2).split(" ")(1)
        val status = strArr(3).toInt
        val searchArr = strArr(4).replaceAll("//", "/").split("/")
        var searchUrl = ""
        if (searchArr.length > 2) {
          searchUrl = searchArr(1)
        } else {
          searchUrl = searchArr(0)
        }
        (ip, time, refer, status, searchUrl)
    }.filter(_._3.startsWith("/class")).map { x =>
      // 145.html
      val referStr = x._3.split("/")(2)
      val refer = referStr.substring(0, referStr.lastIndexOf("."))
      ClickLog(x._1, x._2, refer, x._4, x._5)
    }
      /*
    * 需求：统计到今天为止，的访问量
    */

    cleanData.map(x =>(x.time +"_"+x.refer,1)).reduceByKey(_+_).foreachRDD{rdd =>{
      rdd.foreachPartition{rddPartition =>
        val list = new ListBuffer[ClickCoursCount]
        rddPartition.foreach{ pair =>
          list.append(ClickCoursCount(pair._1,pair._2))
        }
        /*
        * 写入数据到HBase
        * */
        ClickCourseCountDao.save(list)
      }
    }}


    ssc.start()
    ssc.awaitTermination()

  }
}

case class ClickLog(ip:String,time:String,refer:String,status:Int,searchUrl:String)

4、pom.xml文件

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.bonc.qyl.Spark</groupId>
  <artifactId>Kafka_SparkStreaming_Hbase</artifactId>
  <version>1.0-SNAPSHOT</version>
  <inceptionYear>2008</inceptionYear>
    <properties>
        <project.build.sourceEncoding>UTF8</project.build.sourceEncoding>
        <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>
        <spark.version>2.3.2</spark.version>
        <hadoop.version>2.7.7</hadoop.version>
        <mysql.version>5.1.46</mysql.version>
        <kafka.version>1.1.0</kafka.version>
        <junit.version>4.12</junit.version>
        <streaming.kafka.version>2.3.2</streaming.kafka.version>
        <scala.compat.version>2.11</scala.compat.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.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-graphx_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>

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

        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>${hadoop.version}</version>
        </dependency>

        <!-- SparkStreaming和kafka做整合 -->
        <!--<dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-kafka_2.11</artifactId>
            <version>1.6.3</version>
        </dependency>-->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-kafka-0-8_2.11</artifactId>
            <version>${streaming.kafka.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming-flume_2.11</artifactId>
            <version>${spark.version}</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.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.kafka/kafka -->
        <!--<dependency>-->
        <!--<groupId>org.apache.kafka</groupId>-->
        <!--<artifactId>kafka_2.11</artifactId>-->
        <!--<version>${kafka.version}</version>-->
        <!--</dependency>-->

        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.hbase/hbase-client -->
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>1.2.6</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-server</artifactId>
            <version>1.2.6</version>
        </dependency>

        <!--<dependency>-->
        <!--<groupId>org.spark-project.spark</groupId>-->
        <!--<artifactId>unused</artifactId>-->
        <!--<version>1.0.0</version>-->
        <!--<scope>compile</scope>-->
        <!--</dependency>-->

        <!-- https://mvnrepository.com/artifact/com.101tec/zkclient -->
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.3</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.12</version>
            <type>pom</type>
        </dependency>

    </dependencies>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>net.alchim31.maven</groupId>
                    <artifactId>scala-maven-plugin</artifactId>
                    <version>3.2.2</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.5.1</version>
                </plugin>
            </plugins>
        </pluginManagement>
        <plugins>
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>scala-compile-first</id>
                        <phase>process-resources</phase>
                        <goals>
                            <goal>add-source</goal>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>scala-test-compile</id>
                        <phase>process-test-resources</phase>
                        <goals>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <executions>
                    <execution>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-shade-plugin</artifactId>
                    <version>2.3</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

 

逆水行舟如何
关注
  • 1
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
SparkStreaming（java）读取Kafka（kerberos）写入Hbase（kerberos）
EdwardWang_的博客
04-28 2598
使用SparkStreaming（java）读取开启kerberos的Kafka的数据写入Hbase
SparkStreaming消费Kafka，数据实时写入Hbase集群，Java版本
wunanliu的采坑日记
07-03 813
SparkStreaming消费Kafka，数据实时写入Hbase集群，Java代码
SparkStreaming读取Kafka对接Flume抽取到的数据库数据并保存到HBase中，Hive映射HBase进行查询
象在舞的技术专栏
06-10 1532
最近公司在做实时流处理方面的工作，具体需求是：将关系型数据库（MySQL、Oracle）中的相关数据表实时的导入到HBase中，并使用Hive映射HBase进行数据查询。公司使用的是CDH6.3.1搭建的大数据集群~ 一、配置Flume，抽取数据到Kafka 在之前，我写过一篇《Flume抽取Oracle中的数据到Kafka》的文章，里面详细的介绍了如何配置连接Oracle数据库，那么这里就以MySQL数据库为例吧，其实两者的配置大同小异，只不过改几个连接串即可，这里详细的就不...
Kafka集成Spark Streaming并写入数据到HBase
01-17
使用方法： 请使用eclipse的maven导入方式导入，代码在http://blog.csdn.net/q79969786/article/details/42793487有介绍
Kafka和Spark Streaming Java版本集成并将数据实时写入HBase及代码
12-26 2821
问题导读 1.Kafka和Spark Streaming Java版本集成并将数据实时写入HBase，pom.xml是如何配置的？ 2.HBaseCounterIncrementor.java都实现了什么功能？ 3.SparkStreamingFromFlumeToHBaseExample.java实现了哪些功能？ Kafka和Spark Streaming J
SparkStreaming_HBase:将从Kafka收集过来的数据保存到HBase中
04-20
SparkStreaming_HBase将从Kafka收集过来的数据保存到HBase中数据来源：日志生成器。 编写一个python工程，用于产生行为日志，每运行一次，产生所设定的数量数据，使用Linux的定时器，每隔60s执行一次，行为日志保存...
spark streamming消费kafka数据存入hbase示例代码
05-15
这个示例代码是用 Scala 编写的，用于演示如何使用 Spark Streaming 消费来自 Kafka 的数据，并将这些数据存储到 HBase 数据库中。Kafka 是一个分布式流处理平台，而 HBase 是一个基于 Hadoop 的非关系型数据库，...
基于spark streaming和kafka，hbase的日志统计分析系统.zip
最新发布
03-14
最后，Spark Streaming将处理结果写入HBase，以便后续查询。 值得注意的是，Spark Streaming与Kafka的集成非常紧密，可以使用Direct Stream模式直接从Kafka主题读取数据，避免了额外的消息队列。此外，Spark与HBase...
Spark拉取Kafka的流数据，转插入HBase中
weixin_33843409的博客
05-07 245
Spark拉取Kafka的流数据，转插入HBase中 pom.xml文件样例 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://mav...
使用Spark streaming 获取 kafka的json数据分析并用Hbase保存结果
gonefuture的学习博客
04-23 8523
使用Spark streaming 连接 kafka分析并用Hbase保存结果 kafka发送的数据是json格式 {"userId":20400,"day":"2017-03-01","begintime":1488326400000,"endtime":1488327000000,"data":[{"package":"com.browser1
Kafka和Spark Streaming Java版本集成并将数据实时写入HBase
q79969786的专栏
01-17 1万+
Kafka和Spark Streaming Java版本集成并将数据实时写入HBase mvn配置pom.xml <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://mave
用Java从Kafka读取数据到HBase
m0_64416846的博客
04-15 2668
1，添加依赖 <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> </dependency> <dependency> <groupId>org.apache.hbase</groupId> <artifactId>
Kafka+SparkStreaming解析Json数据并插入Hbase，包含部分业务逻辑
lwb314的专栏
03-01 8886
以下代码是在学习Spark时候自己写的例子，还不成熟，仅供记录和参考下边直接上代码,我在我觉得有用的位置加了比较详细的注解import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.hadoop.hbase.client.P...
aop 多数据源
TimeShare1的博客
10-16 246
此方法是在需要使用的地方加上自定义注解@DataSource 根据注解下这个方法的传参 注意: (规定参数命名) 配置文件yml spring: datasource: type: com.zaxxer.hikari.HikariDataSource hikari: minimum-idle: 5 maximum-pool-size: 15 auto-commit: true idle-timeout: 30000 poo
Spark Streaming从Kafka自定义时间间隔内实时统计行数、TopN并将结果存到hbase中
小强签名设计 的博客
08-02 3714
一、统计kafka的topic在10秒间隔内生产数据的行数并将统计结果存入到hbase中 先在hbase中建立相应的表： create 'linecount','count' 开启kafka集群并建立相应的topic： [hadoop@h71 kafka_2.10-0.8.2.0]$ bin/kafka-topics.sh --create --zookeeper h71:2181,h
sparkstreaming+kafka+Hbase 实现实时数据写入Hbase
weixin_41684423的博客
04-16 620
安装kafka、sparkstreaming、hbase参考我之前写的文章 基于maven hadoop 2.7.5 hive 1.3.2 spark 2.4.7 代码：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-instanc
kafka通过spark-streaming往hbase里写数据
qq_28286027的博客
03-20 1059
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...
Spark Streaming接收kafka数据，输出到HBase
热门推荐
Nougats的博客
06-24 1万+
需求 Kafka + SparkStreaming + SparkSQL + HBase 输出TOP5的排名结果 排名作为Rowkey，word和count作为Column 实现
sparkstreaming读取kafka的数据并写入到hbase
03-16
Spark Streaming可以通过Kafka Direct方式读取Kafka的数据，并将数据写入到HBase中。 具体步骤如下： 1. 创建Spark Streaming上下文 ```scala val conf = new SparkConf().setAppName("KafkaToHBase") val ssc = new StreamingContext(conf, Seconds(5)) ``` 2. 创建Kafka Direct流 ```scala val kafkaParams = Map[String, String]( "metadata.broker.list" -> "localhost:9092", "group.id" -> "test-group" ) val topics = Set("test-topic") val kafkaStream = KafkaUtils.createDirectStream[String, String, StringDecoder, StringDecoder]( ssc, kafkaParams, topics) ``` 3. 解析Kafka数据 ```scala val messages = kafkaStream.map(_._2) ``` 4. 将数据写入HBase ```scala messages.foreachRDD(rdd => { rdd.foreachPartition(partition => { val hbaseConf = HBaseConfiguration.create() val connection = ConnectionFactory.createConnection(hbaseConf) val table = connection.getTable(TableName.valueOf("test-table")) partition.foreach(record => { val put = new Put(Bytes.toBytes(record)) put.addColumn(Bytes.toBytes("cf"), Bytes.toBytes("col"), Bytes.toBytes(record)) table.put(put) }) table.close() connection.close() }) }) ``` 5. 启动Spark Streaming ```scala ssc.start() ssc.awaitTermination() ``` 以上就是使用Spark Streaming读取Kafka的数据并写入到HBase的步骤。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值