Hbase

01. HBase简介

定义：HBase 是一种分布式、可扩展、支持海量数据存储的 NoSQL 数据库。

1.1. HBase数据模型

  • 逻辑结构

    其中包括：列族，rowkey，region，store

    1. 一个列族可以包含多个列
    2. 一个region可以包括多个列族
    3. 一个store包括一个列族

    image-20220125101908063

  • 物理存储结构

    1. Habse通过cell来定义一个具体的数据
    2. 数据顺序按照row key的字典序来排序

    image-20220125102158111

  • 数据模型

    1. Name Space
      命名空间，类似于关系型数据库的 DatabBase 概念，每个命名空间下有多个表。HBase有两个自带的命名空间，分别是 hbase和 default，hbase 中存放的是 HBase 内置的表，default 表是用户默认使用的命名空间。
    2. Region
      类似于关系型数据库的表概念。不同的是，HBase 定义表时只需要声明列族即可，不需要声明具体的列。这意味着，往 HBase 写入数据时，字段可以动态、按需指定。因此，和关系型数据库相比，HBase 能够轻松应对字段变更的场景。
    3. Row
      HBase 表中的每行数据都由一个RowKey 和多个 Column（列）组成，数据是按照 RowKey的字典顺序存储的，并且查询数据时只能根据 RowKey 进行检索，所以 RowKey 的设计十分重要。
    4. Column
      HBase 中的每个列都由 Column Family(列族)和 Column Qualifier（列限定符）进行限定，例如 info：name，info：age。建表时，只需指明列族，而列限定符无需预先定义
    5. Time Stamp
      用于标识数据的不同版本（version），每条数据写入时，如果不指定时间戳，系统会自动为其加上该字段，其值为写入 HBase 的时间。
    6. Cell
      由{rowkey, column Family：column Qualifier, time Stamp} 唯一确定的单元。cell 中的数据是没有类型的，全部是字节码形式存贮。

1.2. 基础架构

架构角色主要包括Region Server【对于数据的操作，mysql中的DML语言】,Master【对于表的操作，mysql中的DDL语言】,Zookeeper,HDFS

image-20220125102756468

  1. Region Server
    Region Server 为 Region 的管理者，其实现类为 HRegionServer，主要作用如下:
    • 对于数据的操作：get, put, delete；
    • 对于 Region 的操作：splitRegion、compactRegion。
  2. Master
    Master 是所有 Region Server 的管理者，其实现类为 HMaster，主要作用如下：
    • 对于表的操作：create, delete, alter
    • 对于RegionServer的操作：分配regions到每个RegionServer，监控每个RegionServer的状态，负载均衡和故障转移。
  3. Zookeeper
    HBase 通过 Zookeeper 来做 Master 的高可用、RegionServer 的监控、元数据的入口以及集群配置的维护等工作。
  4. HDFS
    HDFS 为 HBase 提供最终的底层数据存储服务，同时为 HBase 提供高可用的支持。

02. HBase快速入门

2.1. HBase的安装部署

  • zookeeper的正常部署

    bin/zkServer.sh start

  • Hadoop的正常部署

    sbin/start-dfs.sh

  • Hbae解压

    解压路径为/opt/module文件夹下

    tar -zxvf hbase-1.3.1-bin.tar.gz -C /opt/module

  • 修改Hbase的配置文件

    (1) hbase-env.sh 修改内容

    export JAVA_HOME=/opt/module/jdk1.6.0_144
    export HBASE_MANAGES_ZK=false

    (2) hbase-site.xml 修改内容：

    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
    <configuration>
    	<property>
    			<name>hbase.rootdir</name>
    			<value>**hdfs://hadoop102:9000/HBase**</value>
    	</property>

    	<property>
    		<name>hbase.cluster.distributed</name>
    		<value>true</value>
    	</property>

    <!-- 0.98 后的新变动，之前版本没有.port,默认端口为 60000 -->
    	<property>
    			<name>hbase.master.port</name>
    			<value>16000</value>
    	</property>

    	<property>
    			<name>hbase.zookeeper.quorum</name>
    			<value>**hadoop102,hadoop103,hadoop104**</value>

    	</property>

    	<property>
    			<name>hbase.zookeeper.property.dataDir</name>
    			<value>/opt/module/zookeeper-3.4.10/zkData</value>
    	</property>
    </configuration>

    3）regionservers：

    hadoop102
    hadoop103
    hadoop104

    4）软连接 hadoop 配置文件到 HBase：

    ln -s /opt/module/hadoop-2.7.2/etc/hadoop/core-site.xml /opt/module/hbase/conf/core-site.xml

    ln -s /opt/module/hadoop-2.7.2/etc/hadoop/hdfs-site.xml /opt/module/hbase/conf/hdfs-site.xml

  • HBase 远程发送到其他集群

    在hbase的安装路径下

    xsync hbase/

  • Hbase服务的启动

    bin/start-hbase.sh

  • 查看Hbase页面

    启动成功后，可以通过“host:port”的方式来访问 HBase 管理页面，例如：http://hadoop102:16010

2.2. HBase shell操作

2.2.1. 基本操作

  • 进入Hbase 客户端命令行【bin/hbase shell】

  • 查看帮助命令【help】

  • 查看当前数据库中有哪些表【list】

2.2.2. 表的操作

  1. 创建表 【create 表名 列族】

  2. 插入数据列表【put 表名 rowkey 列族:列名 数据】

  3. 查看全表数据【scan 并表明】

  4. 查看表结构【describe 表名】

  5. 更新指定字段的数据【put 表名 rowkey 列族:列名 修改后的数据】

  6. 查看“指定行”或“指定列族：列”的数据【get 表名 rowkey （列族:列） || get 表名 rowkey ｛列族:列， VERSION=>X}，指定查看版本数】

  7. 统计表数据行数【count 表名】

  8. 删除数据【delete 表名 rowkey （列族:列）】

    注意：对于命令行来说，删除某一行数据不能用delete，只能用deleteall，但是Java客户端可以直接删

  9. 清空表数据【truncate 表明】

    注意：清空表的操作顺序为先 disable 表名，然后再 truncate。

  10. 删除表【drop 表名】

    注意：删除表的操作顺序为先 disable 表名，然后再drop。

  11. 表更表信息

    将 info 列族中的数据存放 3 个版本：

    alter ‘student’,{NAME=>’info’,VERSIONS=>3}

03. HBase进阶

3.1. 架构原理

image-20220125131748965

  1. StoreFile
    保存实际数据的物理文件，StoreFile 以 HFile 的形式存储在 HDFS 上。每个 Store 会有一个或多个 StoreFile（HFile），数据在每个 StoreFile 中都是有序的。
  2. Me mStore【写缓存】
    由于 HFile 中的数据要求是有序的，所以数据是先存储在 MemStore 中，排好序后，等到达刷写时机才会刷写到 HFile，每次刷写都会形成一个新的 HFile。
  3. WAL【HLog】
    由于数据要经 MemStore 排序后才能刷写到 HFile，但把数据保存在内存中会有很高的
    概率导致数据丢失，为了解决这个问题，数据会先写在一个叫做 Write-Ahead logfile 的文件
    中，然后再写入 MemStore 中。所以在系统出现故障的时候，数据可以通过这个日志文件重
    建。

3.2. 写流程

写流程需要知道写到哪台机器上，所以需要先请求meta表，meta表保存了表和机器的映射。

image-20220125132215629

流程：

  1. Client 先访问 zookeeper，获取 hbase:meta 表位于哪个 Region Server。
  2. 访问对应的 Region Server，获取 hbase:meta 表，根据读请求的 namespace:table/rowkey，
    查询出目标数据位于哪个 Region Server 中的哪个 Region 中。并将该 table 的 region 信息以
    及 meta 表的位置信息缓存在客户端的 meta cache，方便下次访问。
  3. 与目标 Region Server 进行通讯；
  4. 将数据顺序写入（追加）到 WAL；
  5. 将数据写入对应的 MemStore，数据会在 MemStore 进行排序；
  6. 向客户端发送 ack；
  7. 等达到 MemStore 的刷写时机后，将数据刷写到 HFile。

3.3. MemStore Flush

刷写规则：不同的列族是相互独立的，会刷写到不同的文件中。因此图中store对应一个storeFile组。

image-20220125132919132

刷写时机：主要从容量和时间两个方面进行限制。

  • 容量

    （1）针对单个region来说

    • 当某个 memstroe 的大小达到了 hbase.hregion.memstore.flush.size （默认值 128M ），其所在 region 的所有 memstore 都会开始刷写。【开始写入磁盘】
    • 当 memstore 的大小达到了hbase.hregion.memstore.flush.size*hbase.hregion.memstore.block.multiplier(默认值 4 )时，会阻止继续往该 memstore 写数据。【阻止客户端往memstore中写】

    （2）针对region server来说

    • 当 region server 中 memstore 的总大小达到java_heapsize*hbase.regionserver.global.memstore.size(0.4 )* hbase.regionserver.global.memstore.size.lower.limit (0.95)时，region 会按照其所有 memstore 的大小顺序（由大到小）依次进行刷写。直到 region server中所有 memstore 的总大小减小到上述值以下。【开始写入磁盘】

    • 当 region server 中 memstore 的总大小达到 java_heapsize*hbase.regionserver.global.memstore.size （默认值 0.4 ）
      时，会阻止继续往所有的 memstore 写数据。【阻止客户端往memstore中写】

  • 时间

    到达自动刷写的时间，也会触发 memstore flush。自动刷新的时间间隔由该属性进行
    配置 hbase.regionserver.optionalcacheflushinterval （默认 1 小时）。

3.4. 读流程

因为Hbase有多版本（按照时间戳分辨）和刷写磁盘，因此不能单单看缓存，也需要和HFile中读取数据来一起对时间戳进行比较，返回时间戳最大的那个版本。当磁盘数据的时间戳比内存数据额时间戳大，也会返回磁盘内的数据，因此不能先读内存，而是将磁盘内的HFile和内存以及读缓存一起查询。

image-20220125134508267

  1. Client 先访问 zookeeper，获取 hbase:meta 表位于哪个 Region Server。
  2. 访问对应的 Region Server，获取 hbase:meta 表，根据读请求的 namespace:table/rowkey，
    查询出目标数据位于哪个 Region Server 中的哪个 Region 中。并将该 table 的 region 信息以
    及 meta 表的位置信息缓存在客户端的 meta cache，方便下次访问。
  3. 与目标 Region Server 进行通讯；
  4. 分别在 Block Cache（读缓存），MemStore 和 Store File（HFile）中查询目标数据，并将
    查到的所有数据进行合并。此处所有数据是指同一条数据的不同版本（time stamp）或者不
    同的类型（Put/Delete）。
  5. 将从文件中查询到的数据块（Block，HFile 数据存储单元，默认大小为 64KB）缓存到
    Block Cache。
  6. 将合并后的最终结果返回给客户端。

3.5. StoreFile Compaction

​ 由于memstore每次刷写都会生成一个新的HFile，且同一个字段的不同版本（timestamp）和不同类型（Put/Delete）有可能会分布在不同的HFile中，因此查询时需要遍历所有的HFile。为了减少 HFile 的个数，以及清理掉过期和删除的数据，会进行 StoreFile Compaction。
​ Compaction 分为两种，分别是 Minor Compaction 和 Major Compaction。Minor Compaction会将临近的若干个较小的 HFile 合并成一个较大的 HFile，但不会清理过期和删除的数据。Major Compaction 会将一个 Store 下的所有的 HFile 合并成一个大 HFile，并且会清理掉过期和删除的数据。

​ 对于删除标记，在刷写到磁盘时并不会删掉这个标记，因为在磁盘中可能还存在该字段的旧值。只有当major compaction时，才会将数据和标记同时删掉。

image-20220125135018888

3.6. Region Split

​ 默认情况下，每个 Table 起初只有一个 Region，随着数据的不断写入，Region 会自动进
行拆分。刚拆分时，两个子 Region 都位于当前的 Region Server，但处于负载均衡的考虑，
HMaster 有可能会将某个 Region 转移给其他的 Region Server。
Region Split 时机：

  1. 当1个region中的某个Store下所有StoreFile的总大小超过hbase.hregion.max.filesize，
    该 Region 就会进行拆分（0.94 版本之前）。
  2. 当 1 个 region 中 的某 个 Store 下所有 StoreFile 的总 大 小超过 Min(R^2 *
    “hbase.hregion.memstore.flush.size”,hbase.hregion.max.filesize”)，该 Region 就会进行拆分，其中 R 为当前 Region Server 中属于该 Table 的region个数（0.94 版本之后）

04. HBase API

4.1. 环境准备

导入hbase依赖

org.apache.hbase hbase-server 1.3.1 org.apache.hbase hbase-client 1.3.1

4.2. HBase API

4.2.1. 获取 Configuration

配置集群信息

1
2
3
4
5
6
7
public static Configuration conf;
static{
//使用 HBaseConfiguration 的单例方法实例化
conf = HBaseConfiguration.create();
conf.set("hbase.zookeeper.quorum", "192.166.9.102"); // 和集群配置的ip相同
conf.set("hbase.zookeeper.property.clientPort", "2181");
}

4.2.2. 判断表是否存在

对表据进行操作时，首先需要获得**HBaseAdmin**对象

1
2
3
4
5
public static boolean isTableExist(String tableName) throws Exception {
    //在 HBase 中管理、访问表需要先创建 HBaseAdmin 对象
    HBaseAdmin admin = new HBaseAdmin(conf);
    return admin.tableExists(tableName);
}

4.2.3. 创建表

创建表时，表名需要通过TableName.valueOf转换为字节

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void createTable(String tableName, String... columnFamily) throws Exception {
    HBaseAdmin admin = new HBaseAdmin(conf);
    //判断表是否存在
    if (isTableExist(tableName)) {
        System.out.println("表" + tableName + "已存在");
    } else {
        //创建表属性对象,表名需要转字节
        HTableDescriptor descriptor = new HTableDescriptor(TableName.valueOf(tableName));
        //创建多个列族
        for (String cf : columnFamily) {
            descriptor.addFamily(new HColumnDescriptor(cf));
        }
        //根据对表的配置，创建表
        admin.createTable(descriptor);
        System.out.println("表" + tableName + "创建成功！");
    }
}

4.2.4. 删除表

1
2
3
4
5
6
7
8
9
10
public static void dropTable(String tableName) throws Exception {
    HBaseAdmin admin = new HBaseAdmin(conf);
    if (isTableExist(tableName)) {
        admin.disableTable(tableName);
        admin.deleteTable(tableName);
        System.out.println("表" + tableName + "删除成功！");
    } else {
        System.out.println("表" + tableName + "不存在！");
    }
}

4.2.5. 插入数据

对数据进行操作时，首先需要获得**HTable**对象

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void addRowData(String tableName, String rowKey,
                              String columnFamily, String column,
                              String value) throws IOException {
    //创建 HTable 对象
    HTable hTable = new HTable(conf, tableName);
    //向表中插入数据，创建Put对象
    Put put = new Put(Bytes.toBytes(rowKey));
    //向 Put 对象中组装数据
    put.add(Bytes.toBytes(columnFamily), Bytes.toBytes(column), Bytes.toBytes(value));
    hTable.put(put);
    hTable.close();
    System.out.println("插入数据成功");
}

4.2.6. 删除多行数据

1
2
3
4
5
6
7
8
9
10
public static void deleteMultiRow(String tableName, String... rows) throws IOException {
    HTable hTable = new HTable(conf, tableName);
    List<Delete> deleteList = new ArrayList<Delete>();
    for (String row : rows) {
        Delete delete = new Delete(Bytes.toBytes(row));
        deleteList.add(delete);
    }
    hTable.delete(deleteList);
    hTable.close();
}

4.2.7. 获取所有数据

全表扫描用scan

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void getAllRows(String tableName) throws IOException {
    HTable hTable = new HTable(conf, tableName);
    //得到用于扫描 region 的对象
    Scan scan = new Scan();
    //使用 HTable 得到 resultcanner 实现类的对象
    ResultScanner resultScanner = hTable.getScanner(scan);
    for (Result result : resultScanner) {
        for (Cell cell : result.rawCells()) {
            System.out.println(" 行 键 :" + Bytes.toString(CellUtil.cloneRow(cell)));
            System.out.println(" 列 族 " + Bytes.toString(CellUtil.cloneFamily(cell)));
            System.out.println(" 列 :" + Bytes.toString(CellUtil.cloneQualifier(cell)));
            System.out.println(" 值 :" + Bytes.toString(CellUtil.cloneValue(cell)));
        }
    }
}

4.2.8. 获取某一行数据

指定查看用get

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void getRow(String tableName, String rowKey) throws
        IOException{
    HTable hTable = new HTable(conf, tableName);
    Get get = new Get(Bytes.toBytes(rowKey));
    //get.setMaxVersions();显示所有版本
    //get.setTimeStamp();显示指定时间戳的版本
    Result result = hTable.get(get);
    for(Cell cell : result.rawCells()){
        System.out.println(" 行 键 :"  + Bytes.toString(result.getRow()));
        System.out.println(" 列 族 "  + Bytes.toString(CellUtil.cloneFamily(cell)));
        System.out.println(" 列 :"  + Bytes.toString(CellUtil.cloneQualifier(cell)));
        System.out.println(" 值 :"  + Bytes.toString(CellUtil.cloneValue(cell)));
        System.out.println("时间戳:" + cell.getTimestamp());
    }
}

4.2.9. 获取某一行某一列数据

1
2
3
4
5
6
7
8
9
10
11
12
public static void getRowQualifier(String tableName, String rowKey, String family, String qualifier) throws IOException{
    HTable table = new HTable(conf, tableName);
    Get get = new Get(Bytes.toBytes(rowKey));
    get.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
    Result result = table.get(get);
    for(Cell cell : result.rawCells()){
        System.out.println(" 行 键 :"  + Bytes.toString(result.getRow()));
        System.out.println(" 列 族 "  + Bytes.toString(CellUtil.cloneFamily(cell)));
        System.out.println(" 列 :"  + Bytes.toString(CellUtil.cloneQualifier(cell)));
        System.out.println(" 值 :"  + Bytes.toString(CellUtil.cloneValue(cell)));
    }
}

05. HBase 优化

5.1. 高可用

在 HBase 中 HMaster 负责监控 HRegionServer 的生命周期，均衡 RegionServer 的负载，如果 HMaster 挂掉了，那么整个 HBase 集群将陷入不健康的状态，并且此时的工作状态并不会维持太久。所以 HBase 支持对 HMaster 的高可用配置。配置如下：

1．关闭 HBase 集群（如果没有开启则跳过此步）
bin/stop-hbase.sh
2．在 conf 目录下创建 backup-masters 文件
touch conf/backup-masters
3．在 backup-masters 文件中配置高可用 HMaster 节点
echo hadoop103 > conf/backup-masters
4．将整个 conf 目录 scp 到其他节点
scp -r conf/hadoop103:/opt/module/hbase/
scp -r conf/hadoop104:/opt/module/hbase/
5．打开页面测试查看

5.2. 预分区

5.3. rowkey的设计

06. HBase实战之微博

6.1. 需求分析

  1. 微博用户的内容浏览，数据库表设计
  2. 用户社交体现：关注用户，取关用户【粉丝数和关注列表】
  3. 拉取关注的人的微博内容【打开界面的初始化界面】

6.2. 代码实现

6.2.1. 代码结构

  • 创建命名空间。
  • 创建表：分别是内容表【不同用户所发的微博】，用户关系表【粉丝关注列表】以及微博内容接收邮件表【每次打开界面拉去关注人的微博】
  • 发送微博【将微博信息保存在内容表】
  • 关注用户【需要影响用户的关注数和另个用户的分析，影响用户关系表】
  • 移除用户【取关，同上】
  • 拉取微博内容【通过微博内容接收邮件表展示微博】
数据库
learn

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！