在Spark上通过自定义RDD访问HBase

最新推荐文章于 2024-01-31 08:54:37 发布
最新推荐文章于 2024-01-31 08:54:37 发布
阅读量176 收藏
点赞数
分类专栏： spark

这里介绍一个在Spark上使用自定义RDD获取HBase数据的方案。

这个方案的基础是我们的HBase表的行键设计。行键设计大概是这样子的：标签ID+时间戳+随机码。平时的需求主要是导出指定标签在某个时间范围内的全部记录。根据需求和行键设计确定下实现的大方向：使用行键中的时间戳进行partition并界定startRow和stopRow来缩小查询范围，使用HBase API创建RDD获取数据，在获取的数据的基础上使用SparkSQL来执行灵活查询。
创建Partition

这里我们要自定义的RDD主要的功能就是获取源数据，所以需要自定义实现Partition类：

private[campaign] class QueryPartition(idx: Int, val start: Long, val stop: Long) extends Partition {
override def index: Int = idx
}
1
2
3

private[campaign] class QueryPartition(idx: Int, val start: Long, val stop: Long) extends Partition {
override def index: Int = idx
}

前面我们说过，主要是依赖行键中的时间戳来进行partition的，所以在自定义的QueryPartition类中保留了两个长整型构造参数start和stop来表示起止时间。剩下的构造参数idx作用是标记分区的索引。

这样，自定义RDD中的getPartitions()方法该如何实现也就很清楚了：

override protected def getPartitions: Array[Partition] = {
var tmp = unit.startTime
var i = 0
val partitions = ArrayBufferPartition
while (tmp < unit.stopTime) {
val stopTime = tmp + TimeUnit.HOURS.toMillis(1L)
partitions += new QueryPartition(i, tmp, stopTime)
i = i + 1
tmp = stopTime
}
partitions.toArray
}
1
2
3
4
5
6
7
8
9
10
11
12

override protected def getPartitions: Array[Partition] = {
var tmp = unit.startTime
var i = 0
val partitions = ArrayBufferPartition
while (tmp < unit.stopTime) {
val stopTime = tmp + TimeUnit.HOURS.toMillis(1L)
partitions += new QueryPartition(i, tmp, stopTime)
i = i + 1
tmp = stopTime
}
partitions.toArray
}

在上面代码中的第六行可以看到getPartitions()方法是按每小时一个区间进行partition的。

代码中的unit是一个查询单元，封装了一些必要的查询参数，包括存储数据的表、要查询的标签ID以及起止时间。大致是这样的：

class QueryUnit(val table: String,
val tagId: String,
val startTime: Long,
val stopTime: Long) extends Serializable {
}
1
2
3
4
5

class QueryUnit(val table: String,
val tagId: String,
val startTime: Long,
val stopTime: Long) extends Serializable {
}

注意，QueryUnit这个类需要实现Serializable接口。
查询HBase

因为要实现灵活查询的需求，所以需要将HBase表中符合需求的数据的所有列都取出来。我们可以考虑使用List[Map[String, String]]这样一种结构来暂时保存数据。根据这个需求实现的自定义HBaseClient的代码如下：

import com.typesafe.config.ConfigFactory
import org.apache.hadoop.hbase._
import org.apache.hadoop.hbase.client._
import org.apache.hadoop.hbase.filter.Filter
import org.apache.hadoop.hbase.util.Bytes
import scala.collection.JavaConversions._
import scala.collection.mutable
import scala.collection.mutable.ListBuffer

object HBaseClient {
private val config = ConfigFactory.load()
private val conn = getConnection

/**
   * 扫描HBase并返回结果
   */
def scan(tableName: String, filter: Filter, startRow: String, stopRow: String): List[Map[String, String]] = {
	val s = buildScan(filter, startRow, stopRow)
	val t = conn.getTable(TableName.valueOf(tableName))
	scan(t, s)
}

/**
   * 执行扫描
   */
private def scan(table: Table, scan: Scan): List[Map[String, String]] = {
	val scanner = table.getScanner(scan)
	val ite = scanner.iterator()
	val result = new ListBuffer[Map[String, String]]
	while (ite.hasNext) {
		val map = new mutable.ListMap[String, String]
		ite.next().listCells().foreach(c => map += readCell(c))
		result += map.toMap
	}
	result.toList
}
  
/**
   * 读取单元格
   */
private def readCell(cell: Cell) = {
	val qualifier = Bytes.toString(CellUtil.cloneQualifier(cell))
	val value = Bytes.toString(CellUtil.cloneValue(cell))
	(qualifier, value)
}
  
/**
   * 构建Scan实例
   */
private def buildScan(filter: Filter, startRow: String, stopRow: String): Scan = {
	val scan = new Scan()
	scan.setMaxVersions
	scan.setCaching(2000)
	scan.setCacheBlocks(false)
	if (null != filter) scan.setFilter(filter)
	if (null != startRow) scan.setStartRow(Bytes.toBytes(startRow))
	if (null != stopRow) scan.setStartRow(Bytes.toBytes(stopRow))
	scan
}
  
/**
   * 获取连接
   */
  private def getConnection: Connection = {
    val conf = HBaseConfiguration.create()
    conf.set(HConstants.ZOOKEEPER_QUORUM, config.getString("hbase.zookeeper"))
    conf.set(HConstants.ZOOKEEPER_ZNODE_PARENT, config.getString("hbase.pnode"))
    ConnectionFactory.createConnection(conf)
 }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

import com.typesafe.config.ConfigFactory
import org.apache.hadoop.hbase._
import org.apache.hadoop.hbase.client._
import org.apache.hadoop.hbase.filter.Filter
import org.apache.hadoop.hbase.util.Bytes
import scala.collection.JavaConversions._
import scala.collection.mutable
import scala.collection.mutable.ListBuffer

object HBaseClient {
private val config = ConfigFactory.load()
private val conn = getConnection

/**
   * 扫描HBase并返回结果
   */
def scan(tableName: String, filter: Filter, startRow: String, stopRow: String): List[Map[String, String]] = {
	val s = buildScan(filter, startRow, stopRow)
	val t = conn.getTable(TableName.valueOf(tableName))
	scan(t, s)
}

/**
   * 执行扫描
   */
private def scan(table: Table, scan: Scan): List[Map[String, String]] = {
	val scanner = table.getScanner(scan)
	val ite = scanner.iterator()
	val result = new ListBuffer[Map[String, String]]
	while (ite.hasNext) {
		val map = new mutable.ListMap[String, String]
		ite.next().listCells().foreach(c => map += readCell(c))
		result += map.toMap
	}
	result.toList
}
  
/**
   * 读取单元格
   */
private def readCell(cell: Cell) = {
	val qualifier = Bytes.toString(CellUtil.cloneQualifier(cell))
	val value = Bytes.toString(CellUtil.cloneValue(cell))
	(qualifier, value)
}
  
/**
   * 构建Scan实例
   */
private def buildScan(filter: Filter, startRow: String, stopRow: String): Scan = {
	val scan = new Scan()
	scan.setMaxVersions
	scan.setCaching(2000)
	scan.setCacheBlocks(false)
	if (null != filter) scan.setFilter(filter)
	if (null != startRow) scan.setStartRow(Bytes.toBytes(startRow))
	if (null != stopRow) scan.setStartRow(Bytes.toBytes(stopRow))
	scan
}
  
/**
   * 获取连接
   */
  private def getConnection: Connection = {
    val conf = HBaseConfiguration.create()
    conf.set(HConstants.ZOOKEEPER_QUORUM, config.getString("hbase.zookeeper"))
    conf.set(HConstants.ZOOKEEPER_ZNODE_PARENT, config.getString("hbase.pnode"))
    ConnectionFactory.createConnection(conf)
 }

}

在代码中使用了typesafe的Config类来记录一些信息，比如zookeeper连接信息。

查询HBase这块儿没什么好说的。继续好了。
自定义RDD

前面的两节为自定义实现RDD类做了一些铺垫，包括进行partition的方式，以及一个查询hbase的工具类HBaseClient。实际上我们已经完成实现了自定义RDD的一个抽象方法getPartitions。

自定义RDD需要继承Spark的一个抽象类RDD。

在继承抽象类RDD的同时，需要为它提供两个构造参数，一个是SparkContext实例，一个是父RDD列表。我们要自定义的RDD的是用来获取源数据的，没有父RDD，所以父RDD列表可以直接设置为Nil。

抽象类RDD还有两个抽象方法需要实现，分别是getPartitions()和compute()。getPartitions()方法用来对原始的任务进行分片，可以将原始任务切割成不同的partition，以便进行分布式处理。compute()方法则是实现了对切割出的partition进行处理的逻辑。

getPartitions()方法的实现前面已经提过了，现在看看compute()方法的实现：

/**
* 查询HBase
*/
private def query(part: QueryPartition) = {
val filter = new PrefixFilter(Bytes.toBytes(unit.tagId))
val startRow = unit.tagId+part.start
val stopRow = unit.tagId+part.stop
val results = HBaseClient.scan(unit.table, filter, startRow, stopRow)
results.map(e => JSONObject(e).toString())
}

/**
* 执行计算
*/
override def compute(split: Partition, context: TaskContext): Iterator[String] = {
val part = split.asInstanceOf[QueryPartition]
val results = query(part)
new InterruptibleIterator(context, results.iterator)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/**
* 查询HBase
*/
private def query(part: QueryPartition) = {
val filter = new PrefixFilter(Bytes.toBytes(unit.tagId))
val startRow = unit.tagId+part.start
val stopRow = unit.tagId+part.stop
val results = HBaseClient.scan(unit.table, filter, startRow, stopRow)
results.map(e => JSONObject(e).toString())
}

/**
* 执行计算
*/
override def compute(split: Partition, context: TaskContext): Iterator[String] = {
val part = split.asInstanceOf[QueryPartition]
val results = query(part)
new InterruptibleIterator(context, results.iterator)
}

可以看到，compute()方法就是在getPartitions()方法创建的时间区间QueryPartition上对HBase中的表进行查询，并将查询出的结果封装成json字符串列表。
编写驱动类

至此，工作已经完成了大半，可以看看驱动类是怎么写的了：

import com.typesafe.config.ConfigFactory
import org.apache.hadoop.io.compress.GzipCodec
import org.apache.spark.SparkContext
import org.apache.spark.sql.SQLContext

object HBaseQueryDriver {
def main(args: Array[String]): Unit = {
SparkUtils.runJob(start, args, SparkUtils.initSparkContext(“CustomQueryJob”), “CustomQueryJob”)
}

def start(args: Array[String], sc: SparkContext) = {
	val Array(topic, tagId, startTime, stopTime, sql) = args
	new HBaseQueryDriver(topic, tagId, startTime.toLong, stopTime.toLong, sql).query(sc)
}

}

class HBaseQueryDriver(table: String, tagId: String, startTime: Long, stopTime: Long, sql: String) {
private val config = ConfigFactory.load()
private val outPath = config.getString(“out.path”)
private val tmpPath = config.getString(“tmp.path”)
def query(sc: SparkContext) = {
val unit = new QueryUnit(table, tagId, startTime, stopTime)
val dataRDD = new QueryRDD(sc, unit)
val sqlContext = new SQLContext(sc)
sqlContext.read.json(dataRDD).registerTempTable(table)
Hdfs.delete(outPath)
Hdfs.delete(tmpPath)
sqlContext.sql(sql).map(row => row.mkString(",")).saveAsTextFile(tmpPath)
sc.textFile(tmpPath).coalesce(1, true).saveAsTextFile(outPath, classOf[GzipCodec])
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import com.typesafe.config.ConfigFactory
import org.apache.hadoop.io.compress.GzipCodec
import org.apache.spark.SparkContext
import org.apache.spark.sql.SQLContext

object HBaseQueryDriver {
def main(args: Array[String]): Unit = {
SparkUtils.runJob(start, args, SparkUtils.initSparkContext(“CustomQueryJob”), “CustomQueryJob”)
}

def start(args: Array[String], sc: SparkContext) = {
	val Array(topic, tagId, startTime, stopTime, sql) = args
	new HBaseQueryDriver(topic, tagId, startTime.toLong, stopTime.toLong, sql).query(sc)
}

}

class HBaseQueryDriver(table: String, tagId: String, startTime: Long, stopTime: Long, sql: String) {
private val config = ConfigFactory.load()
private val outPath = config.getString(“out.path”)
private val tmpPath = config.getString(“tmp.path”)
def query(sc: SparkContext) = {
val unit = new QueryUnit(table, tagId, startTime, stopTime)
val dataRDD = new QueryRDD(sc, unit)
val sqlContext = new SQLContext(sc)
sqlContext.read.json(dataRDD).registerTempTable(table)
Hdfs.delete(outPath)
Hdfs.delete(tmpPath)
sqlContext.sql(sql).map(row => row.mkString(",")).saveAsTextFile(tmpPath)
sc.textFile(tmpPath).coalesce(1, true).saveAsTextFile(outPath, classOf[GzipCodec])
}
}

驱动类的任务是在创建的QueryRDD上使用SparkSQL执行查询，并将查询结果保存到HDFS上。

代码中的SparkUtil只是将经常使用的初始化SparkContext以及执行Spark任务的行为封装了一下，是这样实现的：

object SparkUtils extends Logging {
/**
* 执行作业
/
def runJob(job: (Array[String], SparkContext) => Unit,
args: Array[String],
context: SparkContext,
errorMsg: String = “任务执行失败”): Unit = {
val startTime = System.currentTimeMillis()
try {
job(args, context)
} catch {
case ex: Throwable => ex.printStackTrace(); throw ex
} finally {
log.info(“Cost Time: %s”.format(System.currentTimeMillis() - startTime))
}
}
/*
* 初始化spark上下文
/
def initSparkContext(appName: String, master: String = null): SparkContext = {
val sparkConf = new SparkConf().setAppName(appName)
sparkConf.set(“spark.files.userClassPathFirst”, “true”)
if (null == sparkConf.get(“spark.master”, null) && null == master)
sparkConf.set(“spark.master”, "local[]")
if (null != master) sparkConf.set(“spark.master”, master)
new SparkContext(sparkConf)
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

object SparkUtils extends Logging {
/**
* 执行作业
/
def runJob(job: (Array[String], SparkContext) => Unit,
args: Array[String],
context: SparkContext,
errorMsg: String = “任务执行失败”): Unit = {
val startTime = System.currentTimeMillis()
try {
job(args, context)
} catch {
case ex: Throwable => ex.printStackTrace(); throw ex
} finally {
log.info(“Cost Time: %s”.format(System.currentTimeMillis() - startTime))
}
}
/*
* 初始化spark上下文
/
def initSparkContext(appName: String, master: String = null): SparkContext = {
val sparkConf = new SparkConf().setAppName(appName)
sparkConf.set(“spark.files.userClassPathFirst”, “true”)
if (null == sparkConf.get(“spark.master”, null) && null == master)
sparkConf.set(“spark.master”, "local[]")
if (null != master) sparkConf.set(“spark.master”, master)
new SparkContext(sparkConf)
}
}

好了，就这样！！
–重写 RDD
class QueryRDD(sc: SparkContext, tableName: String, startRow: String, endRow: String, splitKeys: Array[String]) extends RDD[Map[String,String]](sc, Nil)
{

#重写该方法用于计算每一个 partition
override def compute(split: Partition, context: TaskContext): Iterator[Map[String,String]] =
{
val part = split.asInstanceOf[QueryPartition]
val results = query(part)
new InterruptibleIterator(context, results.iterator)
}

#重写该方法用于获取 partition
override protected def getPartitions: Array[Partition] =
{
val partitions = ArrayBufferPartition
for (splitKey <- splitKeys)
{
partitions += new QueryPartition(splitKey)
}
partitions.toArray
}

private def query(partition: QueryPartition) =
{
val splitKey = partition.split
val filter = null #该参数可以不为 null,即可在 scan 的同时进行 filter
val start = splitKey + startRow
val end = splitKey + endRow
HBaseClient.scan(tableName, filter, start, end)
}
}

#实现自己的 partition
class QueryPartition(splitKey: String) extends Partition
{
def split: String = splitKey

override def index: Int = splitKey.substring(0, 3).toInt

override def hashCode(): Int = index
}

以上是重写 RDD,hbase 的具体 scan 操作,在我上面的链接里可以找到,我照搬了过来.但是要注意他的 58 行,要把 startRow 改成 stopRow,不然的话其他代码写得再好都白费啦

余生与猫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spark自定义RDD
u013939918的博客
07-21 556
一、为什么需要自定义RDD 1. spark提供了很多方法读数据源，比如我们当前可以从hdfs文件、jdbc、mongo、hbase等等将数据包装成RDD供我们后续进行处理。如果我们想要读memcache中的数据恐怕就没有现成的了，需要我们自己实现自己的RDD。 2. RDD是一种弹性分布式数据集，本质就是对数据的封装与抽象。讲道理我们可以将任何我们想要的数据按照我们的业务情况将数据进行分片，而不是对spark的API深度依赖。 二、搭建项目 本demo完成功能： ...
[Spark]自定义RDD
I have a adream
12-27 431
scala源程序 //MyRDDTest.scala package org.apache.spark.myrdd { import org.apache.spark.{Partition, SparkContext, TaskContext} import scala.reflect.ClassTag import org.apache.spark.rdd._ private...
spark 自定义RDD，通过j2ssh远程读取文件
wang972779876的博客
06-04 221
如何自定义RDD 1.引用依赖 <dependencies> <!-- https://mvnrepository.com/artifact/org.apache.spark/spark-core --> <dependency> <groupId>org.apache.spark</groupId> <artifactId>spark-core_2.
Spark RDD 资料
01-31
假设有一个文本文件 `hello.txt`，Spark 会将其读入成为一个 RDD，然后通过一系列的 Transformation 操作（如 `flatMap`, `map` 和 `reduceByKey` 或 `foldByKey` 等）处理数据，最后通过 Action 操作（如 `collect`...
基于Spark+Flume + Kafka + Hbase的实时日志分析及异常检测系统.zip
12-24
在本系统中，Flume负责从各种数据源（如服务器、应用服务器等）收集日志数据，通过自定义配置，可以实现灵活的数据采集策略，确保日志数据的实时性与完整性。 其次，Kafka是由LinkedIn开源的高吞吐量、分布式的发布...
spark使用java读取hbase数据做分布式计算.pdf
11-24
在大数据处理场景中，常常需要将HBase中的数据作为输入进行分析和计算，这就涉及到了Spark与HBase的集成。本示例介绍如何使用Java来实现这一功能。 首先，为了在Spark中读取HBase数据，我们需要借助`...
spark面试题整理.pdf
最新发布
05-15
- Lineage是指Spark中RDD之间的依赖关系，它帮助Spark在发生失败时重新计算丢失的数据分区。 9. **广播变量和累加器** - **广播变量**：用于共享只读数据，以减少网络传输开销。 - **累加器**：用于并行计算场景...
Spark理论和PySpark.pdf
01-22
Spark是一个分布式计算框架，它允许在集群环境中处理大量数据，支持批处理、流处理、交互式查询和机器学习等多种任务。Spark的核心设计目标是速度、易用性和可伸缩性。 2. **Spark的特点和优势** - **速度**：...
hbase-rdd：Spark RDD从HBase读取，写入和删除
02-05
hbase-rdd：Spark RDD从HBase读取，写入和删除
scala API 操作hbase表
01-11
最近看了hbase的源码根据源码写了一些scala调动hbase表的API，话不多说直接上代码！Hadoop的版本是2.7.3，scala版本是2.1.1，hbase的版本是1.1.2 如果版本不同可以修改pom的依赖项，但要注意版本冲突。 并且在scala，maven项目中，还有创建一个resources包（这个网上多的是）主要是放core-site,xml和hdfs-site.xml以及hbase-site.xml
spark: 简单的自定义RDD分区器
amadeus_liu2的博客
01-31 440
二、使用自定义分区器。
Spark基础学习笔记：创建RDD
py20010218的博客
06-19 433
Spark基础学习笔记：创建RDD
Spark RDD 自定义分区器
congge_study的博客
04-30 677
Spark 自定义分区器
Spark-RDD操作Hbase
Knight
06-18 308
由于 org.apache.hadoop.hbase.mapreduce.TableInputFormat 类的实现，Spark 可以通过Hadoop输入格式访问HBase。这个输入格式会返回键值对数据，其中键的类型为org. apache.hadoop.hbase.io.ImmutableBytesWritable，而值的类型为org.apache.hadoop.hbase.client. Result。 （1）添加依赖 <dependency> <groupId>org.apa
[Spark]自定义RDD的计算函数
I have a adream
12-27 898
MyRDDTest.scala package org.apache.spark.myrdd { import org.apache.spark.{Partition, SparkContext, TaskContext} import scala.reflect.ClassTag import org.apache.spark.rdd._ private[myrdd] cl...
SparkRDD 读写HBase
qq_34341930的博客
04-23 285
首先导入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
spark 存入hbase_Spark rdd写入Hbase
weixin_33402215的博客
01-12 195
I am able to read the messages from Kafka using the below code:val ssc = new StreamingContext(sc, Seconds(50))val topicmap = Map("test" -> 1)val lines = KafkaUtils.createStream(ssc,"127.0.0.1:2181"...
Spark读取HbaseRDD详解：过程与源码分析
"Spark通过创建HbaseRDD来与HBase进行交互，这一过程涉及多个步骤，包括构建HbaseRDD、创建NewHadoopRDD以及在getPartitions方法中的操作。" 在Spark中，读取HBase数据的核心是创建一个HbaseRDD，这可以通过`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值