从零开始学习HBase - 一文详解HBase常用API

HBase常用API总结

❤️ 使用的HBase版本为 1.31

1. pom.xml文件:

 <!-- 配置 Hbase 的依赖 -->
    <dependencies>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-server</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>1.3.1</version>
        </dependency>

        <!-- 配置hadoop的依赖-->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>2.7.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>2.7.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-hdfs</artifactId>
            <version>2.7.5</version>
        </dependency>
    </dependencies>

2.HBUtils

package com.wangt.hbase.utils;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;

/**
 * @author 王天赐
 * @create 2019-08-01 19:59
 */
public class HBUtils {

    // 配置文件对象
    private static Configuration conf = null;
    // HBase 连接对象
    private static Connection connection = null;
    // 用于管理HBase 表 .命名空间的对象
    private static HBaseAdmin admin = null;

    /**
     * 获取 HBase Configuration 对象
     *
     * @return
     */
    public static Configuration getHBaseConfiguration() {
        // 创建 HBase 配置文件对象
        conf = HBaseConfiguration.create();
        // 设置 Hbase 依赖的 Zookeeper ip 以及端口
        conf.set("hbase.zookeeper.quorum", "222.22.91.81");
        conf.set("hbase.zookeeper.property.clientPort", "2181");
        return conf;
    }

    /**
     * 获取 HBase 连接对象
     *
     * @return HBase 连接对象
     */
    public static Connection getConnection() {
        // 获取 HBase Configuration 对象
        conf = getHBaseConfiguration();
        try {
            // 获取 HBase 连接对象
            connection = ConnectionFactory.createConnection(conf);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return connection;
    }

    /**
     * 释放 Connection 和 HBaseAdmin 连接
     *
     * @param connection Connection 对象
     * @param admin      HBaseAdmin 对象
     */
    public static void release(Connection connection, Admin admin) {

        // 关闭 HBaseAdmin 对象
        if (admin != null) {
            try {
                admin.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 关闭 HBase 连接
        if (connection != null) {
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 将数据封装进 Put 对象中
     *
     * @param rowKey rowKey的值
     * @param cf     列族名
     * @param cn     列名
     * @param value  列名对应的参数
     * @return 封装后的 Put 对象
     */
    public static Put EncapsulationDataToPutObject(String rowKey, String cf, String cn, String value) {
        // 创建 Put 对象
        Put put = new Put(Bytes.toBytes(rowKey));
        // 添加数据
        put.addColumn(Bytes.toBytes(cf), Bytes.toBytes(cn), Bytes.toBytes(value));
        // 返回 put 对象
        return put;
    }
}

1.查看表是否存在

package com.wangt.hbase.common;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.HBaseAdmin;

import java.io.IOException;

/**
 * 判断表是否存在
 * @author 王天赐
 * @create 2019-08-01 15:10
 */
public class TableExist {

    // 声明 Hbase 配置文件对象
    private static Configuration conf  = null;

    // 创建 Configuration 对象 并设置 连接zookeeper参数
    static {
        // 使用 HBaseConfiguration 的单例方法实例化
        conf = HBaseConfiguration.create();
        // 设置 HBase依赖的 zookeeper ip
        conf.set("hbase.zookeeper.quorum", "222.22.91.81");
        // 设置 zookeeper 端口
        conf.set("hbase.zookeeper.property.clientPort", "2181");
    }

    /**
     * 获取 HBaseConfiguration 对象
     * @return  HBaseConfiguration 对象
     */
    public static Configuration getHBaseConfiguration(){
        return conf;
    }

    /**
     * 获取 HBaseAdmin 对象
     * @return HBaseAdmin 对象
     * @Excepation IOException
     */
    public static HBaseAdmin getHBaseAdmin() throws IOException {

        // 在 Hbase 中 管理 访问表 需要先创建 HBaseAdmin 表
        // 1.获取 配置文件对象
        Configuration conf = getHBaseConfiguration();
        // 2.创建 连接对象
        Connection connection = ConnectionFactory.createConnection(conf);
        // 3.使用 Connection 对象创建 HBaseAdmin
        HBaseAdmin admin = (HBaseAdmin) connection.getAdmin();

        return  admin;
    }

    public static void main(String[] args) throws IOException {

        String tableName = "dog";
        HBaseAdmin admin = getHBaseAdmin();
        // 获取所有的表的信息
        TableName[] tableNames = admin.listTableNames();
        // 打印所有表名
        for (TableName name : tableNames) {
            System.out.println(name.getNameAsString());
        }
        // 判断某个表是否存在
        System.out.println("dog 表是否存在 " + (admin.tableExists("dog") ? "存在" : "不存在"));

        if(admin.tableExists("Person")){
            System.out.println("Person 表存在");
        }else{
            System.out.println("Person 表不存在");
        }
    }

}

2.创建表

package com.wangt.hbase.common;

import com.wangt.hbase.utils.HBUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.client.HBaseAdmin;

import java.io.IOException;

/**
 * @author 王天赐
 * @create 2019-08-01 16:09
 */
public class CreateTable {

    public static void main(String[] args) throws IOException {
        // 1.获取 Hbase 连接对象
        Connection connection = HBUtils.getConnection();
        // 2.获取 HBaseAdmin 对象用于管理和访问表
        Admin admin = connection.getAdmin();
        // 3.判断 要创建的表是否存在 (新API)
        boolean isExist = admin.tableExists(TableName.valueOf("Person"));
        //3.如果表不存在 则创建表
        if(!isExist){
            // 3.1 创建表属性对象 直接传入 String 类型的 table name 的方法已经过时
            HTableDescriptor descriptor = new HTableDescriptor(TableName.valueOf("Person"));
            // 3.2 创建多个列族
            // 1.创建列族名数组
            String[] columnFamily = new String[]{"info01" , "info02"};
            // 2.向表属性对象中添加列族
            for (String cf : columnFamily) {
                // 1.创建列描述对象
                HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(cf);
                // 2.将列描述对象添加到表属性描述对象中
                descriptor.addFamily(hColumnDescriptor);
            }
            // 4.根据对表的配置创建表
            admin.createTable(descriptor);
            System.out.println("表 Person 创建成功");

        }

        // 释放链接
        HBUtils.release(connection, admin);
    }
}

3.删除表

package com.wangt.hbase.common;

import com.wangt.hbase.utils.HBUtils;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;

import java.io.IOException;

/**
 * 测试 删除表的操作
 * @author 王天赐
 * @create 2019-08-02 10:01
 */
public class DeleteTable {

    public static void main(String[] args) throws IOException {

        // 创建 Admin 对象
        Connection connection = HBUtils.getConnection();
        Admin admin = connection.getAdmin();

        TableName deleteTable = TableName.valueOf("person");
        // 判断 表是否存在
        boolean isExist = admin.tableExists(deleteTable);
        // 如果 表存在则删除
        if (isExist){
            // 将表标记为删除状态
            admin.disableTable(deleteTable);
            // 删除表
            admin.deleteTable(deleteTable);
            System.out.println("表已删除");
        }else {
            System.out.println("表不存在 , 无法删除");
        }

    }
}

4.添加数据

package com.wangt.hbase.common;

import com.wangt.hbase.utils.HBUtils;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;

/**
 * 添加表数据
 * @author 王天赐
 * @create 2019-08-02 10:21
 */
public class PutTableData {

    public static void main(String[] args) throws IOException {
        // 1.获取 Hbase 连接对象
        Connection connection = HBUtils.getConnection();
        // 过时 API
        // HTable personTable = new HTable(connection.getConfiguration(), TableName.valueOf("Person"));
        // 2.获取 Table 对象
        Table personTable = connection.getTable(TableName.valueOf("Person"));
        // 3.创建 Put 对象 添加的数据是 封装在 put 对象中的
        Put put = new Put(Bytes.toBytes("1001"));
        // 4.添加数据 对应格式 => 列族 , 列名 , 值
        put.addColumn(Bytes.toBytes("info01"), Bytes.toBytes("name"), Bytes.toBytes("李白"));
        put.addColumn(Bytes.toBytes("info01"), Bytes.toBytes("age"), Bytes.toBytes("19"));
        put.addColumn(Bytes.toBytes("info01"), Bytes.toBytes("sex"), Bytes.toBytes("男"));
        // 5.添加数据
        personTable.put(put);
        System.out.println("添加成功");
        // 6.释放连接
        HBUtils.release(connection, null);

    }
}

5.批量添加数据

package com.wangt.hbase.common;

import com.wangt.hbase.utils.HBUtils;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;

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

/**
 * 批量添加表数据
 *
 * @author 王天赐
 * @create 2019-08-02 10:21
 */
public class PutMultipleTableData {

    /**
     * 将数据封装进 Put 对象中
     *
     * @param rowKey rowKey的值
     * @param cf     列族名
     * @param cn     列名
     * @param value  列名对应的参数
     * @return 封装后的 Put 对象
     */
    public static Put EncapsulationDataToPutObject(String rowKey, String cf, String cn, String value) {
        // 创建 Put 对象
        Put put = new Put(Bytes.toBytes(rowKey));
        // 添加数据
        put.addColumn(Bytes.toBytes(cf), Bytes.toBytes(cn), Bytes.toBytes(value));
        // 返回 put 对象
        return put;
    }

    public static void main(String[] args) throws IOException {
        // 获取 Hbase 连接对象
        Connection connection = HBUtils.getConnection();
        // 获取 Table 对象
        Table personTable = connection.getTable(TableName.valueOf("Person"));
        // 用于存放封装成 Put 对象的list集合
        List<Put> puts = new ArrayList<>();

        for (int i = 1000 ; i <= 1040 ; i++){
            if(puts.size() >= 10){
                // 当数据达到10条的时候 将数据写入表中
                personTable.put(puts);
                // 清空集合
                puts.clear();
            }
            // 将数据封装成 put 对象
            Put put = EncapsulationDataToPutObject(i + "", "info01", "name", "maomao No." + i);
            // 添加进 put 集合
            puts.add(put);
        }

        // 释放连接
        HBUtils.release(connection, null);

    }
}

6.删除数据

package com.wangt.hbase.common;

import com.wangt.hbase.utils.HBUtils;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;

/**
 * 删除数据
 * @author 王天赐
 * @create 2019-08-02 11:08
 */
public class DeleteTableData {


    public static void main(String[] args) throws IOException {

        // 获取 数据库连接
        Connection connection = HBUtils.getConnection();
        // 获取 Table 对象
        Table personTable = connection.getTable(TableName.valueOf("Person"));
        // deleteAll 删除一个 rowkey中所有的数据
        // 封装 Delete 对象
        Delete delete = new Delete(Bytes.toBytes("1001"));
        // 注意 : 使用addColumn添加信息删除数据的时候 只会删除最新版本的数据 ! 哪怕数据只有一个 版本 也会删除新的版本的数据 ,
        // 数据会退回到上一个版本的数据 一般使用 addColumns 可以把所有版本的数据全部删除
        // 当然也可以使用 addColumn
        //delete.addColumn(, , );
        delete.addColumns(Bytes.toBytes("info01"), Bytes.toBytes("name"));
        // 删除数据
        personTable.delete(delete);
        System.out.println("删除成功....");

        // 删除 指定 Rowkey的全部数据
        Delete delete01 = new Delete(Bytes.toBytes("1000"));
        // 删除不存在的数据 不会报错
        personTable.delete(delete01);


        System.out.println("删除成功...");

        // 释放连接
        HBUtils.release(connection, null);

    }
}

⭐️特别注意 :

1. addColumn : 使用addColumn添加信息删除数据的时候 只会删除最新版本的数据 ! 哪怕数据只有一个 版本 也会删除新的版本的数据 ,数据会退回到上一个版本的数据 一般使用 addColumns 可以把所有版本的数据全部删除 一般需要删除指定版本的时候 可以使用这个 , 一般删除都使用 addClumns

7.扫描全表数据

package com.wangt.hbase.common;

import com.wangt.hbase.utils.HBUtils;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;

/**
 * 全表扫描数据
 * @author 王天赐
 * @create 2019-08-02 16:14
 */
public class ScanData {

    public static void main(String[] args) throws IOException {

        // 获取 Hbase 连接对象
        Connection connection = HBUtils.getConnection();
        // 获取 表对象
        Table table = connection.getTable(TableName.valueOf("Person"));
        // 构建扫描对象
        Scan scan = new Scan();
        ResultScanner results = table.getScanner(scan);
        // 遍历扫描结果对象
        for (Result result : results) {
            // 获取单元格数组
            Cell[] cells = result.rawCells();
            // 从单元格数组中遍历得到数据
            for (Cell cell : cells) {
                // 一般使用 CellUtils 获取数据
                // 获取 rowKey
                String rowKey = Bytes.toString(CellUtil.cloneRow(cell));
                // 获取 列族
                String cf = Bytes.toString(CellUtil.cloneFamily(cell));
                // 获取 列名
                String cn = Bytes.toString(CellUtil.cloneQualifier(cell));
                // 获取 对应列的值
                String value = Bytes.toString(CellUtil.cloneValue(cell));
                System.out.println(
                      "[" +  rowKey + "," + cf + "," + cn + "," + value + "]"
                );
            }
        }
        // 释放链接
        HBUtils.release( connection,null);
    }
}

8.获取指定列数据

package com.wangt.hbase.common;

import com.wangt.hbase.utils.HBUtils;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;

/**
 * 获取 单行数据
 * @author 王天赐
 * @create 2019-08-02 16:47
 */
public class GetRowData {

    public static void main(String[] args) throws IOException {
        // 获取 Hbase 连接对象
        Connection connection = HBUtils.getConnection();
        // 获取 表对象
        Table table = connection.getTable(TableName.valueOf("Person"));

        // 构建 Get 对象 封装要获取的行的信息
        Get get = new Get(Bytes.toBytes("1006"));
        // 设置 指定的列族 和 列名
        //get.addColumn(Bytes.toBytes("info01"), Bytes.toBytes("name"));
        Result result = table.get(get);
        Cell[] cells = result.rawCells();

        // 遍历数据
        // 从单元格数组中遍历得到数据
        for (Cell cell : cells) {
            // 一般使用 CellUtils 获取数据
            // 获取 rowKey
            String rowKey = Bytes.toString(CellUtil.cloneRow(cell));
            // 获取 列族
            String cf = Bytes.toString(CellUtil.cloneFamily(cell));
            // 获取 列名
            String cn = Bytes.toString(CellUtil.cloneQualifier(cell));
            // 获取 对应列的值
            String value = Bytes.toString(CellUtil.cloneValue(cell));
            System.out.println(
                    "[" +  rowKey + "," + cf + "," + cn + "," + value + "]"
            );
        }

        table.close();
        // 释放链接
        HBUtils.release( connection,null);
    }
}

更新中… 😄