HBase学习笔记

2021-05-05

字数统计: 4.4k字 | 阅读时长≈ 18分

摘要：HBase基础。

前言：本篇文章主要是总结了一下学习HBase的过程中遇到的一些问题和知识点。

HBase

HBase是什么？

HBase是Apache Hadoop中的一个子项目，Hbase依托于Hadoop的HDFS作为最基本存储基础单元，通过使用hadoop的DFS工具就可以看到这些这些数据存储文件夹的结构,还可以通过Map/Reduce的框架(算法)对HBase进行操作，如下图所示：

HBase

HBASE是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统，利用HBASE技术可在廉价PC Server上搭建起大规模结构化存储集群。

HBASE的目标是存储并处理大型的数据，更具体来说是仅需使用普通的硬件配置，就能够处理由成千上万的行和列所组成的大型数据。

HBASE是Google Bigtable的开源实现，但是也有很多不同之处。比如：Google Bigtable使用GFS作为其文件存储系统，HBASE利用Hadoop HDFS作为其文件存储系统；Google运行MAPREDUCE来处理Bigtable中的海量数据，HBASE同样利用Hadoop MapReduce来处理HBASE中的海量数据；Google Bigtable利用Chubby作为协同服务，HBASE利用Zookeeper作为协同服务。

Hbase与传统数据库的对比

传统数据库遇到的问题：
1. 数据量很大的时候无法存储。
2. 没有很好的备份机制。
3. 数据达到一定数量开始缓慢，很大的话基本无法支撑。
HBASE优势：
1. 线性扩展，随着数据量增多可以通过节点扩展进行支撑。
2. 数据存储在hdfs上，备份机制健全。
3. 通过zookeeper协调查找数据，访问速度快。

HBase集群中的角色

一个或者多个主节点，Hmaster。
多个从节点，HregionServer。
HBase依赖项，zookeeper。

HBase数据模型
HBase数据模型1

HBase数据模型2

HBase的存储机制

HBase是一个面向列的数据库，在表中它由行排序。表模式定义只能列族，也就是键值对。一个表有多个列族以及每一个列族可以有任意数量的列。后续列的值连续存储在磁盘上。表中的每个单元格值都具有时间戳。总之，在一个HBase：

表是行的集合。
行是列族的集合。
列族是列的集合。
列是键值对的集合。

这里的列式存储或者说面向列，其实说的是列族存储，HBase是根据列族来存储数据的。列族下面可以有非常多的列，列族在创建表的时候就必须指定。

Row Key 行键

与nosql数据库一样，row key是用来表示唯一一行记录的主键，HBase的数据时按照RowKey的字典顺序进行全局排序的，所有的查询都只能依赖于这一个排序维度。访问HBASE table中的行，只有三种方式：

通过单个row key访问。
通过row key的range（正则）。
全表扫描。

Row key行键（Row key）可以是任意字符串(最大长度是64KB，实际应用中长度一般为10-1000bytes)，在HBASE内部，row key保存为字节数组。存储时，数据按照Row key的字典序(byte order)排序存储。设计key时，要充分排序存储这个特性，将经常一起读取的行存储放到一起(位置相关性)。

Columns Family 列族

列族：HBASE表中的每个列，都归属于某个列族。列族是表的schema的一部分(而列不是)，必须在使用表之前定义。列名都以列族作为前缀。例如courses：history，courses：math 都属于courses这个列族。

Cell 列

由{row key，columnFamily，version} 唯一确定的单元。cell中的数据是没有类型的，全部是字节码形式存储。

关键字：无类型、字节码

Time Stamp 时间戳

HBASE中通过rowkey和columns确定的为一个存储单元称为cell。每个cell都保存着同一份数据的多个版本。版本通过时间戳来索引。时间戳的类型是64位整型。时间戳可以由HBASE(在数据写入时自动)赋值，此时时间戳是精确到毫秒的当前系统时间。时间戳也可以由客户显示赋值。如果应用程序要避免数据版本冲突，就必须自己生成具有唯一性的时间戳。每个cell中，不同版本的数据按照时间倒序排序，即最新的数据排在最前面。

为了避免数据存在过多版本造成的管理(包括存储和索引)负担，HBASE提供了两种数据版本回收方式。一是保存数据的最后n个版本，而是保存最近一段时间内的版本(比如最近7天)。用户可以针对每个列族进行设置。

HBase原理

HBase系统架构体系图

组成部件说明

Client：

使用HBase RPC机制与HMaster和HRegionServer进行通信
Client与HMaster进行管理类操作
Client与HRegionServer进行数据读写类操作

Zookeeper：

Zookeeper Quorum存储-ROOT-表地址、HMaster地址
HRegionServer把自己以Ephedral方式注册到Zookeeper中，HMaster随时感知各个HRegionServer的健康状况
Zookeeper避免HMaster单点问题

Zookeeper的主要作用：客户端首先联系ZooKeeper子集群（quorum）（一个由ZooKeeper节点组成的单独集群）查找行健。上述过程是通过ZooKeeper获取含有-ROOT-的region服务器名（主机名）来完成的。通过含有-ROOT-的region服务器可以查询到含有.META.表中对应的region服务器名，其中包含请求的行健信息。这两处的主要内容都被缓存下来了，并且都只查询一次。最终，通过查询.META服务器来获取客户端查询的行健数据所在region的服务器名。一旦知道了数据的实际位置，即region的位置，HBase会缓存这次查询的信息，同时直接联系管理实际数据的HRegionServer。所以，之后客户端可以通过缓存信息很好地定位所需的数据位置，而不用再次查找.META.表。

HMaster：

HMaster没有单点问题，HBase可以启动多个HMaster，通过Zookeeper的Master Election机制保证总有一个Master在运行
主要负责Table和Region的管理工作：

管理用户对表的增删改查操作
管理HRegionServer的负载均衡，调整Region分布
Region Split后，负责新Region的分布
在HRegionServer停机后，负责失效HRegionServer上Region迁移

HRegionServer：

HBase中最核心的模块，主要负责响应用户I/O请求，向HDFS文件系统中读写

HBase系统架构体系图

HRegionServer管理一系列HRegion对象；
每个HRegion对应Table中一个Region，HRegion由多个HStore组成；
每个HStore对应Table中一个Column Family的存储；
Column Family就是一个集中的存储单元，故将具有相同IO特性的Column放在一个Column Family会更高效。

可以看到，client访问hbase上的数据并不需要master参与（寻址访问zookeeper和region server，数据读写访问region server），master仅仅维护table和region的元数据信息（table的元数据信息保存在zookeeper上），负载很低。HRegionServer存取一个子表时，会创建一个HRegion对象，然后对表的每个列族创建一个Store实例，每个Store都会有一个MemStore和0个或多个StoreFile与之对应，每个StoreFile都会对应一个HFile，HFile就是实际的存储文件。因此，一个HRegion（表）有多少个列族就有多少个Store。一个HRegionServer会有多个HRegion和一个HLog。

HRegion：

table在行的方向上分隔为多个Region。Region是HBase中分布式存储和负载均衡的最小单元，即不同的region可以分别在不同的Region Server上，但同一个Region是不会拆分到多个server上。

Region按大小分隔，每个表一般是只有一个region。随着数据不断插入表，region不断增大，当region的某个列族达到一个阀值（默认256M）时就会分成两个新的region。

每个region由以下信息标识：

<表名，startRowKey，创建时间>
由目录表(-ROOT-和.META.)记录该region的endRowKey
HRegion定位：Region被分配给哪个RegionServer是完全动态的，所以需要机制来定位Region具体在哪个region server。

HBase使用三层结构来定位region：

通过zookeeper里的文件/hbase/rs得到-ROOT-表的位置。-ROOT-表只有一个region。
通过-ROOT-表查找.META.表的第一个表中相应的region的位置。其实-ROOT-表是.META.表的第一个region；.META.表中的每一个region在-ROOT-表中都是一行记录。
通过.META.表找到所要的用户表region的位置。用户表中的每个region在.META表中都是一行记录。
注意：

-ROOT-表永远不会被分隔为多个region，保证了最多需要三次跳转，就能定位到任意的region。client会将查询的位置信息缓存起来，缓存不会主动失效，因此如果client上的缓存全部失效，则需要进行6次网络来回，才能定位到正确的region，其中三次用来发现缓存失效，另外三次用来获取位置信息。

table和region的关系

table默认最初只有一个region，随着记录数的不断增加而变大，起初的region会逐渐分裂成多个region，一个region有【startKey, endKey】表示，不同的region会被master分配给相应的regionserver管理。

region是hbase分布式存储和负载均衡的最小单元，不同的region分不到不同的regionServer。

注意：region虽然是分布式存储的最小单元，但并不是存储的最小单元。region是由一个或者多个store组成的，每个store就是一个column family。每个store又由memStore和1至多个store file 组成(memstore到一个阀值会刷新，写入到storefile，有hlog来保证数据的安全性，一个regionServer有且只有一个hlog)　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

HStore：

HBase存储的核心。由MemStore和StoreFile组成。MemStore是Stored Memory Buffer。
HLog：

引入HLog原因：在分布式系统环境中，无法避免系统出错或者宕机，一旦HRegionServer意外退出，MemStore中的内存数据就会丢失，引入HLog就是防止这种情况。

工作机制：
每个HRegionServer中都会有一个HLog对象，HLog是一个实现Write Ahead Log的类，每次用户操作写入MemStore的同时，也会写一份数据到HLog文件，HLog文件定期会滚动出新，并删除旧的文件(已持久化到StoreFile中的数据)。当HRegionServer意外终止后，HMaster会通过Zookeeper感知，HMaster首先处理遗留的HLog文件，将不同region的log数据拆分，分别放到相应region目录下，然后再将失效的region重新分配，领取到这些region的HRegionServer在Load Region的过程中，会发现有历史HLog需要处理，因此会Replay HLog中的数据到MemStore中，然后flush到StoreFiles，完成数据恢复。

搭建hbase

1、配置java环境变量

vim /etc/profile

set java environment
JAVA_HOME=/usr/java/jdk1.8.0_151
JRE_HOME=/usr/java/jdk1.8.0_151/jre
CLASS_PATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib
PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin
export PATH

使修改生效
source /etc/profile

java -version
如果出现版本信息，则安装成功

2、下载Hbase，http://archive.apache.org/dist/hbase/

3、配置Hbase环境变量

vim /etc/profile

HBASE_HOME=/opt/hbase
PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin:$HBASE_HOME/bin

使修改生效
source /etc/profile

hbase version
如果出现版本信息，则安装成功

4、单价模式配置hbase

vim /opt/hbase/conf/hbase-env.sh

末尾加上
export JAVA_HOME=/usr/java/jdk1.8.0_151
export HBASE_MANAGES_ZK=true

配置HBASE_MANAGES_ZK为true，表示由hbase自己管理zookeeper，不需要单独的zookeeper



vim /usr/local/hbase/conf/hbase-site.xml

在启动HBase前需要设置属性hbase.rootdir，用于指定HBase数据的存储位置，因为如果不设置的话，hbase.rootdir默认为/tmp/hbase-${user.name},这意味着每次重启系统都会丢失数据。此处设置为HBase安装目录下的hbase-tmp文件夹即（/usr/local/hbase/hbase-tmp）,添加配置如下：

<configuration>
    <property>
        <name>hbase.rootdir</name>
        <value>file:///opt/hbase/hbase-tmp</value>
    </property>
</configuration>

cd /opt/hbase
bin/start-hbase.sh
bin/hbase shell

5、配置外置的zookeeper

1	https://www-us.apache.org/dist/zookeeper/

JAVA实际操作


import com.google.common.collect.Lists;
import com.ypsx.miniTask.server.bean.StoresData;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.*;
import org.apache.hadoop.hbase.util.Bytes;

import java.io.IOException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Iterator;
import java.util.List;

public class ExampleForHbase{
    private static Configuration configuration;
    private static Connection connection;
    private static Admin admin;
    private static final String TABLENAME = "shopOrderStatisticsTest0";

    //建立连接
    public static void init(){
        configuration  = HBaseConfiguration.create();
        configuration.set("hbase.zookeeper.quorum","yp-ubuntu-server-1,yp-ubuntu-server-2,yp-ubuntu-server-3");
        configuration.set("hbase.zookeeper.port","2181");
        try{
            connection = ConnectionFactory.createConnection(configuration);
            admin = connection.getAdmin();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
    //关闭连接
    public static void close(){
        try{
            if(admin != null){
                admin.close();
            }
            if(null != connection){
                connection.close();
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    /**
     * 建表。HBase的表中会有一个系统默认的属性作为主键，主键无需自行创建，默认为put命令操作中表名后第一个数据，因此此处无需创建id列
     * @param myTableName 表名
     * @param colFamily 列族名
     * @throws IOException
     */
    public static void createTable(String myTableName,String[] colFamily) throws IOException {
        init();
        TableName tableName = TableName.valueOf(myTableName);
        if(admin.tableExists(tableName)){
            System.out.println("talbe is exists!");
        }else {
            HTableDescriptor hTableDescriptor = new HTableDescriptor(tableName);
            for(String str:colFamily){
                HColumnDescriptor hColumnDescriptor = new HColumnDescriptor(str);
                hTableDescriptor.addFamily(hColumnDescriptor);
            }
            admin.createTable(hTableDescriptor);
            System.out.println("create table success");
        }
        close();
    }
    /**
     * 删除指定表
     * @param tableName 表名
     * @throws IOException
     */
    public static void deleteTable(String tableName) throws IOException {
        init();
        TableName tn = TableName.valueOf(tableName);
        if (admin.tableExists(tn)) {
            admin.disableTable(tn);
            admin.deleteTable(tn);
        }
        close();
    }
    /**
     * 查看已有表
     * @throws IOException
     */
    public static void listTables() throws IOException {
        init();
        HTableDescriptor hTableDescriptors[] = admin.listTables();
        for(HTableDescriptor hTableDescriptor : hTableDescriptors){
            System.out.println(hTableDescriptor.getNameAsString());
        }
        close();
    }
    /**
     * 向某一行的某一列插入数据
     * @param tableName 表名
     * @param rowKey 行键
     * @param colFamily 列族名
     * @param col 列名（如果其列族下没有子列，此参数可为空）
     * @param val 值
     * @throws IOException
     */
    public static void insertRow(String tableName,String rowKey,String colFamily,String col,String val) throws IOException {
        init();
        Table table = connection.getTable(TableName.valueOf(tableName));
        Put put = new Put(rowKey.getBytes());
        put.addColumn(colFamily.getBytes(), col.getBytes(), val.getBytes());
        table.put(put);
        table.close();
        close();
    }
    /**
     * 删除数据
     * @param tableName 表名
     * @param rowKey 行键
     * @param colFamily 列族名
     * @param col 列名
     * @throws IOException
     */
    public static void deleteRow(String tableName,String rowKey,String colFamily,String col) throws IOException {
        init();
        Table table = connection.getTable(TableName.valueOf(tableName));
        Delete delete = new Delete(rowKey.getBytes());
        //删除指定列族的所有数据
        //delete.addFamily(colFamily.getBytes());
        //删除指定列的数据
        //delete.addColumn(colFamily.getBytes(), col.getBytes());
        table.delete(delete);
        table.close();
        close();
    }
    /**
     * 根据行键rowkey查找数据
     * @param tableName 表名
     * @param rowKey 行键
     * @param colFamily 列族名
     * @param col 列名
     * @throws IOException
     */
    public static void getData(String tableName,String rowKey,String colFamily,String col)throws  IOException{
        init();
        Table table = connection.getTable(TableName.valueOf(tableName));
        Get get = new Get(rowKey.getBytes());
        get.addColumn(colFamily.getBytes(),col.getBytes());
        Result result = table.get(get);
        showCell(result);
        table.close();
        close();
    }

    /**
     * 从指定行scan表
     *
     * @param shopId
     * @throws IOException
     */
    public static List<StoresData> scanTableByRow(String cityCode, String dayTime, String shopId, String[] stArr) throws IOException {
        init();
        HTableDescriptor hTableDescriptors[] = admin.listTables();
        List<String> tableList = Lists.newArrayList();
        //获取所有表名称
        for (int i = 0; i < hTableDescriptors.length; i++) {
            tableList.add(hTableDescriptors[i].getNameAsString());
        }

        List<StoresData> storesDataList = Lists.newArrayList();
        //判断需要查询的表是否存在
        if (tableList.contains(TABLENAME)) {
            Table table = connection.getTable(TableName.valueOf(TABLENAME));

            //定义scan条件
            Scan scan = new Scan();

            //过滤rowkey，${cityCode}_${dayTime}_${shopId},如C320100_20190910_100002445
            if (shopId.equals("")){
                scan.setRowPrefixFilter(Bytes.toBytes(cityCode + "_" + dayTime));
            }else {
                scan.setRowPrefixFilter(Bytes.toBytes(cityCode + "_" + dayTime + "_" + shopId));
            }

            //数据要满足全部过滤器才可以
            FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL);

            //过滤器1，用于过滤dayTime
            SingleColumnValueFilter filter1= new SingleColumnValueFilter(Bytes.toBytes("statistics"), Bytes.toBytes("dayTime"), CompareFilter.CompareOp.EQUAL, dayTime.getBytes());
            filter1.setFilterIfMissing(true); //默认为false， 没有此列的数据也会返回 ，为true则只返回name=lisi的数据
            filterList.addFilter(filter1);

            if (!shopId.equals("")){
                //过滤器2，用于过滤shopId
                SingleColumnValueFilter filter2 = new SingleColumnValueFilter(Bytes.toBytes("statistics"), Bytes.toBytes("shopId"), CompareFilter.CompareOp.EQUAL, shopId.getBytes());
                filter2.setFilterIfMissing(true); //默认为false， 没有此列的数据也会返回 ，为true则只返回name=lisi的数据
                filterList.addFilter(filter2);
            }

            scan.setFilter(filterList);

            ResultScanner scanner = table.getScanner(scan);
            // 遍历scanner
            Iterator<Result> iterator = scanner.iterator();
            while (iterator.hasNext()) {
                Result result = iterator.next();
                // 遍历result
                CellScanner cellScanner = result.cellScanner();
                StoresData storesData = new StoresData();
                storesData.setShopId(Integer.valueOf(shopId));
                storesData.setMerchantName(stArr[0]);
                storesData.setShopOrganizationCode(stArr[1]);
                storesData.setCityCode(cityCode);
                storesData.setDayTime(dayTime);
                while (cellScanner.advance()) {
                    Cell cell = cellScanner.current();
                    // System.out.println("行键:" + Bytes.toString(CellUtil.copyRow(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)));

                    // totalPayUserNumber  totalPayOrderNumber  totalPayPrice
                    String tempName = Bytes.toString(CellUtil.cloneQualifier(cell));
                    String tempValue = Bytes.toString(CellUtil.cloneValue(cell));
                    if (tempName.equals("totalPayUserNumber")){
                        storesData.setTotalPayUserNumber(Long.valueOf(tempValue));
                    }else if (tempName.equals("totalPayOrderNumber")){
                        storesData.setTotalPayOrderNumber(Long.valueOf(tempValue));
                    }else if (tempName.equals("totalPayPrice")){
                        storesData.setTotalPayPrice(Long.valueOf(tempValue));
                    }
                }

                //为客单价赋值
                if (storesData.getTotalPayPrice() != 0 || storesData.getTotalPayOrderNumber() != 0 ){
                    BigDecimal bi1 = new BigDecimal(storesData.getTotalPayPrice());
                    BigDecimal bi2 = new BigDecimal(storesData.getTotalPayOrderNumber());
                    BigDecimal divide = bi1.divide(bi2, 2, RoundingMode.HALF_UP);
                    storesData.setUnitPrice(divide.doubleValue());
                }

                storesDataList.add(storesData);
            }
            table.close();
            return storesDataList;
        } else {
            close();
            return storesDataList;
        }
    }

    /**
     * 格式化输出
     * @param result
     */
    public static void showCell(Result result){
        Cell[] cells = result.rawCells();
        for(Cell cell:cells){
            System.out.println("RowName:"+new String(CellUtil.cloneRow(cell))+" ");
            System.out.println("Timetamp:"+cell.getTimestamp()+" ");
            System.out.println("column Family:"+new String(CellUtil.cloneFamily(cell))+" ");
            System.out.println("row Name:"+new String(CellUtil.cloneQualifier(cell))+" ");
            System.out.println("value:"+new String(CellUtil.cloneValue(cell))+" ");
        }
    }
}

参考文章：

Hbase批量查询-scan介绍 https://blog.csdn.net/kangkangwanwan/article/details/89332536
Ubuntu下HBase安装与使用(shell+Java API) https://blog.csdn.net/flyfish111222/article/details/51893096

本文作者： th3ee9ine
本文链接： https://www.blog.ajie39.top/2021/05/05/HBase学习笔记/
版权声明： 本博客所有文章除特别声明外，均采用 LICENSE 下的许可协议。转载请注明出处！