Hbase之基础知识

---

一、HBase 逻辑结构

存储数据稀疏，数据存储多维，不同的行具有不同的列。
数据存储整体有序，按照RowKey的字典序排列，RowKey为Byte数组

二、HBase 物理存储结构

物理存储结构即为数据映射关系，而在概念视图的空单元格，底层实际根本不存储。

三、HBase 数据模型

3.1、Name Space

命名空间，类似于关系型数据库的 database 概念，每个命名空间下有多个表。HBase 两个自带的命名空间，分别是 hbase 和 default，hbase 中存放的是 HBase 内置的表，default表是用户默认使用的命名空间。

3.2、Table

HBase 中的每个列都由 Column Family(列族)和 Column Qualifier（列限定符）进行限定，例如 info：name，info：age。建表时，只需指明列族，而列限定符无需预先定义。

3.3、Row

HBase 中的每个列都由 Column Family(列族)和 Column Qualifier（列限定符）进行限定，例如 info：name，info：age。建表时，只需指明列族，而列限定符无需预先定义。

3.4、Time Stamp

用于标识数据的不同版本（version），每条数据写入时，系统会自动为其加上该字段，其值为写入 HBase 的时间。

3.5、Cell

由{rowkey, column Family：column Qualifier, timestamp} 唯一确定的单元。cell 中的数据全部是字节码形式存贮。

四、HBase 基础架构

4.1、基础架构

4.2、架构角色

4.2.1、Master

实现类为 HMaster，负责监控集群中所有的 RegionServer 实例。主要作用如下：
1、管理元数据表格 hbase:meta，接收用户对表格创建修改删除的命令并执行
2、监控 region 是否需要进行负载均衡，故障转移和 region 的拆分。通过启动多个后台线程监控实现上述功能：
（1）LoadBalancer 负载均衡器周期性监控 region 分布在 regionServer 上面是否均衡，由参数 hbase.balancer.period 控制周期时间，默认 5 分钟。
（2）CatalogJanitor 元数据管理器定期检查和清理 hbase:meta 中的数据。meta 表内容在进阶中介绍。
（3）MasterProcWAL master 预写日志处理器把 master 需要执行的任务记录到预写日志 WAL 中，如果 master 宕机，让 backupMaster
读取日志继续干。

4.2.2、Region Server

Region Server 实现类为 HRegionServer，主要作用如下:
（1）负责数据 cell 的处理，例如写入数据 put，查询数据 get 等
（2）拆分合并 region 的实际执行者，有 master 监控，有regionServer 执行。

五、HBASE API读写

5.1、依赖

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <hbase.version>2.4.0</hbase.version>
</properties>
<dependency>
    <groupId>org.apache.hbase</groupId>
    <artifactId>hbase-client</artifactId>
    <version>${hbase.version}</version>
</dependency>

<dependency>
    <groupId>org.apache.hbase</groupId>
    <artifactId>hbase-server</artifactId>
    <version>${hbase.version}</version>
</dependency>

5.2、相关代码

package com.hpsk.hbase;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
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;

/**
 * DDL:
 * 1.判断表是否存在
 * 2.创建表
 * 3.创建命名空间
 * 4.删除表
 * DML:
 * 5.插入数据
 * 6.查数据(get)
 * 7.扫描数据(san)
 * 8.删除数据
 */
public class HbaseApiTest {
    private static Connection connection = null;
    private static Admin admin = null;
    static {
        try {
            // 1.获取配置信息
            Configuration configuration = HBaseConfiguration.create();
            configuration.set("hbase.zookeeper.quorum", "hadoop102,hadoop103,hadoop104");
            // 2.创建连接对象
            connection = ConnectionFactory.createConnection(configuration);
            // 3.创建管理员对象
            admin = connection.getAdmin();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    // 1.判断表是否存在
    public static boolean isTableExist(String tableName) throws IOException {
        return admin.tableExists(TableName.valueOf(tableName));
    }

    // 2.创建表
    public static void createTable(String tableName, String ... cfs) throws IOException {
        // 1.判断是否存在列簇信息
        if (cfs.length <= 0) {
            System.out.println("请设置列簇信息！");
            return;
        }
        // 2.判断表是否存在
        if(isTableExist(tableName)) {
            System.out.println(tableName + "表已存在！");
            return;
        }

        // 3.创建集合用于存放ColumnFamilyDescriptor对象,并遍历cfs放入其中
        List<ColumnFamilyDescriptor> columnFamily = new ArrayList<>();
        for (String cf : cfs) {
            columnFamily.add(ColumnFamilyDescriptorBuilder.newBuilder(cf.getBytes()).build());
        }
        // 4.创建tableDescriptor，并添加列簇信息
        TableDescriptor tableDescriptor = TableDescriptorBuilder
                .newBuilder(TableName.valueOf(tableName))
                .setColumnFamilies(columnFamily)
                .build();

        // 5.创建表
        admin.createTable(tableDescriptor);
        System.out.println("table：" + tableName + "创建成功！");
    }

    // 3.创建命名空间
    public static void createNameSpace(String ns) {
        NamespaceDescriptor namespaceDescriptor = NamespaceDescriptor.create(ns).build();
        try {
            admin.createNamespace(namespaceDescriptor);
        } catch (NamespaceExistException e) {
            System.out.println(ns + "命名空间已存在！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 4.删除表
    public static void dropTable(String tableName) throws IOException {
        TableName tb = TableName.valueOf(tableName);
        // 1.判断表是否存在
        if(!isTableExist(tableName)) {
            System.out.println(tableName + "表不存在！");
            return;
        }

        // 2.下线表
        admin.disableTable(tb);

        // 3.删除表
        admin.deleteTable(tb);
        System.out.println(tableName + "表删除表成功！");
    }

    // 5.插入数据
    public static void putData(String tableName, String rowKey, String cf,String cn ,String value) throws IOException {
        // 1.获取表对象
        Table table = connection.getTable(TableName.valueOf(tableName));
        // 2.创建put对象
        Put put = new Put(Bytes.toBytes(rowKey));
        // 3.给put对象赋值
        put.addColumn(Bytes.toBytes(cf), Bytes.toBytes(cn), Bytes.toBytes(value));
        // 4.插入数据
        table.put(put);
        // 5.关闭表连接
        table.close();
    }

    // 6.查数据(get)
    public static Result getData(String tableName, String rowKey, String cf,String cn) throws IOException {
        // 1.获取table对象
        Table table = connection.getTable(TableName.valueOf(tableName));
        // 2.创建get对象
        Get get = new Get(Bytes.toBytes(rowKey));
        // 3.给get对象赋值
//        get.addColumn(Bytes.toBytes(cf), Bytes.toBytes(cn));
//        get.getMaxVersions();
        // 4.查看数据
        Result result = table.get(get);
        for (Cell cell : result.rawCells()) {
            System.out.println("CF: " + Bytes.toString(CellUtil.cloneFamily(cell)) +
                               ", CN: " + Bytes.toString(CellUtil.cloneQualifier(cell)) +
                               ", Value: " + Bytes.toString(CellUtil.cloneValue(cell)));
        }
        // 5.关闭表连接
        table.close();
        return result;
    }

    // 7.扫描数据(scan)
    public static ResultScanner scanData(String tableName, String startRowKey, String endRowKey) throws IOException {
        // 1.获取table对象
        Table table = connection.getTable(TableName.valueOf(tableName));
        // 2.创建scan对象
        Scan scan = new Scan();
        // 3.给scan赋值
        scan.withStartRow(Bytes.toBytes(startRowKey));
        scan.withStopRow(Bytes.toBytes(endRowKey));
        // 4.扫描数据
        ResultScanner resultScanner = table.getScanner(scan);
        for (Result result : resultScanner) {
            for (Cell cell : result.rawCells()) {
                System.out.println("CF: " + Bytes.toString(CellUtil.cloneFamily(cell)) +
                        ", CN: " + Bytes.toString(CellUtil.cloneQualifier(cell)) +
                        ", Value: " + Bytes.toString(CellUtil.cloneValue(cell)));
            }
        }

        // 5.关闭表连接
        table.close();

        return resultScanner;
    }

    // 8.删除数据
    public static void deleteData(String tableName, String rowKey, String cf,String cn) throws IOException {
        // 1.获取table对象
        Table table = connection.getTable(TableName.valueOf(tableName));
        // 2.创建Delete对象
        Delete delete = new Delete(Bytes.toBytes(rowKey));
        // 3.给delete对象赋值
//        delete.addColumns(Bytes.toBytes(cf), Bytes.toBytes(cn));
//        delete.addFamily(Bytes.toBytes(cf));
        // 4.删除数据
        table.delete(delete);
        System.out.println("删除表：" + tableName + "数据成功！");
    }

    // 关闭资源
    public static void close(){
        if (connection != null) {
            try {
                connection.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (admin != null) {
            try {
                admin.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws IOException {
        // 1.测试表是否存在
//        System.out.println(isTableExist("GMALL_REALTIME:DIM_ACTIVITY_INFO"));
        // 2.测试创建表
//        createTable("stu1", "info", "info1");
        // 3.测试创建命名空间
//        createNameSpace("hello");
        // 4.测试删除表
//        dropTable("stu");
        // 5.测试插入数据
//        putData("stu1","1001","info1","age", "18");
//        putData("stu1","1002","info","name", "lisi");
//        putData("stu1","1003","info","sex", "male");
        // 6.查看数据
//        System.out.println(getData("stu", "1001", "", ""));
        // 7.测试扫描数据
        System.out.println(scanData("stu1", "1001", "1005"));
        // 8.删除数据
        deleteData("stu1","1001","info","sex");

        // 关闭资源
        close();
    }
}