10分钟玩转Hbase CRUD

HBase操作基本类

类名	用途	获取方式
Configuration	HBase的配置类	HBaseConfiguration.create
Connection	连接	ConnectionFactory.createConnection(conf)
Admin	HBase的操作API	Connection.getAdmin
Table	用来链接HBase的单表	Connection.getTable()
Get	用来查询HBase的单行数据	new Get(rowkey.getBytes())
Put	保存单行数据	new Put(rowkey.getBytes())
Delete	删除单行数据	new Delete(rowkey.getBytes())

示例代码：

import org.apache.hadoop.conf.Configuration
import org.apache.hadoop.hbase.{HBaseConfiguration, TableName}
import org.apache.hadoop.hbase.client._

object HBaseUtil {

  // 读取配置文件
  val conf: Configuration = HBaseConfiguration.create

  // 创建连接
  val conn: Connection = ConnectionFactory.createConnection(conf)

  // 创建HBase管理类
  val admin: Admin = conn.getAdmin

  /**
    * 获得表,如果表不存在则创建
    *
    * @param tableNameStr     表名
    * @param columnFamilyName 列族名
    * @return
    */
  def getTable(tableNameStr: String, columnFamilyName: String): Table = {

    // 获取 TableName
    val tableName: TableName = TableName.valueOf(tableNameStr)

    //判断表是否可用
    if (!admin.tableExists(tableName)) {
      // 构建TableDescriptorBuilder
      val tableDescriptor: TableDescriptorBuilder = TableDescriptorBuilder.newBuilder(tableName)

      // 构建列族 ColumnFamilyDescriptor
      val columnFamily: ColumnFamilyDescriptor = ColumnFamilyDescriptorBuilder.newBuilder(columnFamilyName.getBytes).build()
      tableDescriptor.setColumnFamily(columnFamily)
      // 创建表
      admin.createTable(tableDescriptor.build())
    }

    // 返回表
    conn.getTable(tableName)
  }

存储数据**

创建putData方法

• 调用getTable获取表
• 构建Put对象
• 添加列、列值
• 对table执行put操作
• 启动编写main进行测试

•   /**
        * 保存数据
        *
        * @param tableNameStr     表名
        * @param rowkey           rowkey
        * @param columnFamilyName 列族名
        * @param columnName       列名
        * @param columnValue      列值
        */
    def putData(tableNameStr: String,
                rowkey: String,
                columnFamilyName: String,
                columnName: String,
                columnValue: String
               ) = {
        val table = getTable(tableNameStr, columnFamilyName)
  
    try {
        // Put
        val put = new Put(rowkey.getBytes())
        // 参数1: 列族 参数2: 列名 参数3: 列值
        put.addColumn(columnFamilyName.getBytes, columnName.getBytes, columnValue.getBytes)
        // 保存数据
        table.put(put)
    } catch {
        case ex: Exception => {
            ex.printStackTrace()
        }
    } finally {
        // 关闭table
        table.close()
   	 }
    }
  

获取数据**

1. 使用Connection获取表

2. 创建getData方法

   • 调用getTable获取表
   • 构建Get对象
   • 对table执行get操作，获取result
   • 使用Result.getValue获取列族列对应的值
   • 捕获异常
   • 关闭表

3. 启动hhbase

4. 启动编写main进行测试

    /**
        * 查询数据
        *
        * @param tableNameStr     表名
        * @param rowkey           rowkey
        * @param columnFamilyName 列族名
        * @param columnName       列名
        */
    def getData(tableNameStr: String,
                rowkey: String,
                columnFamilyName: String,
                columnName: String) = {
   
    val table: Table = getTable(tableNameStr, columnFamilyName)
   
    try {
   
    // Get对象
    val get: Get = new Get(rowkey.getBytes)
    // 查询结果
    val result = table.get(get)
    // 结果不为空, 并且结果包含我们要查询的列
    if (result != null && result.containsColumn(columnFamilyName.getBytes, columnName.getBytes)) {
        // - 使用Result.getValue获取列族列对应的值
        val colValueBytes: Array[Byte] = result.getValue(columnFamilyName.getBytes, columnName.getBytes)
        Bytes.toString(colValueBytes)
    }else {
    ""
    }
    } catch {
        case ex: Exception =>
        ex.printStackTrace()
        ""
    } finally {
        // - 关闭表
        table.close()
    }
   

   }

批量存储数据**

创建putMapData方法

• 调用getTable获取表
• 构建Put对象
• 添加Map中的列、列值
• 对table执行put操作
• 捕获异常
• 关闭表
• 启动编写main进行测试

/**
    * 批量存储数据
    *
    * @param tableNameStr     表名
    * @param rowkey           rowkey
    * @param columnFamilyName 列族名
    * @param map              key/value集合
    */
def putMapData(tableNameStr: String,
               rowkey: String,
               columnFamilyName: String,
               map: Map[String, Any]
              ) = {
    val table = getTable(tableNameStr, columnFamilyName)

    try {
        //- 添加Map中的列、列值
        for ((columnName, columnValue) <- map) {
            // Put
            val put = new Put(rowkey.getBytes())
            put.addColumn(columnFamilyName.getBytes, columnName.getBytes, columnValue.toString.getBytes)
            table.put(put)
        }

    } catch {
        case ex: Exception => {
            ex.printStackTrace()
        }
    } finally {
        table.close()
    }
}

批量获取数据

创建putMapData方法

• 调用getTable获取表
• 构建Get对象
• 根据Get对象查询表
• 构建可变Map
• 遍历查询各个列的列值
• 过滤掉不符合的结果
• 把结果转换为Map返回
• 捕获异常
• 关闭表
• 启动编写main进行测试

/**
    * 批量获取列的数据
    *
    * @param tableNameStr 表名
    * @param rowkey       rowkey
    * @param columnFamily 列族
    * @param columnList   列的名字列表
    * @return
    */
def getMapData(tableNameStr: String, rowkey: String, columnFamily: String, columnList: List[String]): Map[String, String] = {
    // 根据表名和列族名获取表
    val table: Table = getTable(tableNameStr, columnFamily)

    try {
        // 创建Get对象
        val get: Get = new Get(rowkey.getBytes)

        // 根据Get对象查询表
        val result: Result = table.get(get)

        // 构建可变Map
        val valueMap = collection.mutable.Map[String, String]()

        // 遍历要查询的列集合
        columnList.map {
            col =>
            // 从表查询结果中,根据列族,列名提取出列值
            val values: Array[Byte] = result.getValue(columnFamily.getBytes, col.getBytes)

            // 列值不为空 , 则设置 k-> v
            if (values != null && values.size > 0) {
                col -> Bytes.toString(values)
            }
            else {
                "" -> ""
            }
        }.filter(_._1 != "").toMap  // 过滤掉key为""的内容,并转换为Map类型
    } catch {
        case e: Exception =>
        e.printStackTrace()
        Map[String, String]()
    } finally {
        table.close()
    }
}

删除数据**

创建deleteData方法

• 调用getTable获取表
• 构建Delete对象
• 对table执行delete操作
• 捕获异常
• 关闭表
• 启动编写main进行测试

/**
    * 删除数据
    *
    * @param tableNameStr     表名
    * @param columnFamilyName 列族名
    * @param rowkey           rowkey
    */
def deleteData(tableNameStr: String,
               columnFamilyName: String,
               rowkey: String
              ) = {
    // 获取表
    val table = getTable(tableNameStr, columnFamilyName)
    try {
        // 创建Delete对象
        val delete = new Delete(rowkey.getBytes)
        table.delete(delete)
    } catch {
        case ex: Exception =>
        ex.printStackTrace()
    } finally {
        table.close()
    }
}

main方法测试代码

object HBaseUtil {
    
    def main(args: Array[String]): Unit = {
    // 测试存入单列数据
    putData("test", "123", "info", "t1", "hello world")

    // 测试存入多列数据
    val map = Map(
      "t2" -> "scala",
      "t3" -> "hive",
      "t4" -> "sqoop"
    )
    putMapData("test", "123", "info", map)

    println(getData("test", "123", "info", "t1"))
    println(getData("test", "123", "info", "t2"))
    println(getData("test", "123", "info", "t3"))
    println(getData("test", "123", "info", "t4"))
        
    println(getMapData("test", "123", "info", List("t1", "t2","t3","t4")))

    deleteData("test", "123", "info")
  }

}