HBase原理及优化

最新推荐文章于 2021-11-23 22:18:13 发布

✔✔✔✔

最新推荐文章于 2021-11-23 22:18:13 发布

阅读量176

点赞数

分类专栏： Hadoop生态圈文章标签： hbase

本文链接：https://blog.csdn.net/qq_44110741/article/details/108929887

版权

Hadoop生态圈专栏收录该内容

21 篇文章 1 订阅

订阅专栏

5.2.1 获取Configuration对象

6.1 高可用（High Available）

一、HBase 原理之写流程

get ‘student’,’1001’

1）Client先访问zookeeper，从meta表读取region的位置，然后读取meta表中的数据。meta中又存储了用户表的region信息；

2）根据namespace、表名和rowkey在meta表中找到对应的region信息；

3）找到这个region对应的regionserver；

4）查找对应的region；

5）先从MemStore找数据，如果没有，再到BlockCache里面读；

6）BlockCache还没有，再到StoreFile上读(为了读取的效率)；

7）如果是从StoreFile里面读取的数据，不是直接返回给客户端，而是先写入BlockCache，再返回给客户端。

二、HBase 原理之读流程

put ‘student’,’1003’,’info:name’,’zhangsan’

region1 [1000,2000] regionserver1(hadoop003)

region2 [2000,3000] regionserver2(hadoop004)

1）Client向HRegionServer发送写请求；

2）HRegionServer将数据写到HLog（write ahead log）。为了数据的持久化和恢复；

3）HRegionServer将数据写到内存（MemStore）；

4）反馈Client写成功。

三、HBase 原理之数据Flush流程

1）当MemStore数据达到阈值（默认是128M，老版本是64M），将数据刷到硬盘，将内存中的数据删除，同时删除HLog中的历史数据；

hbase.hregion.memstore.flush.size: 针对region级别，当一个region内的所有memstore总大小达到该阈值的时候，所有的memstore都会溢写到磁盘文件

hbase.regionserver.global.memstore.size：针对regionserver级别，当一个regionserver内的所有memstore总大小达到该阈值的时候，当前regionserver内的所有store的memstore全部flush

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

2）并将数据存储到HDFS中；

四、HBase 原理之数据合并流程

由于memstore每次刷写都会生成一个新的HFile，且同一个字段的不同版本（timestamp）和不同类型（Put/Delete）有可能会分布在不同的 HFile 中，因此查询时需要遍历所有的 HFile。

为了减少 HFile 的个数，以及清理掉过期和删除的数据，会进行 StoreFile Compaction。Compaction 分为两种，分别是 Minor Compaction （小合并）和 Major Compaction（大合并）。Minor Compaction会将临近的若干个较小的 HFile 合并成一个较大的 HFile，但不会清理过期和删除的数据。Major Compaction 会将一个 Store 下的所有的 HFile 合并成一个大 HFile，并且会清理掉过期和删除的数据。

Minor Compaction相关参数：hbase.hstore.compactionThreshold，默认值3

Major Compaction相关参数：hbase.hregion.majorcompaction，默认值604800000即7天

1）当数据块达到3块(一个store中的Hfile，可配置)，Hregionserver将数据块加载到本地，进行合并；

2）当合并的数据（store数据）超过某个值，HregionServer将region进行拆分，HMaster将拆分后的region分配给不同的HRegionServer管理（此处可以预分区）。

切片时机：

当1个region中的某个Store下所有StoreFile的总大小超过hbase.hregion.max.filesize，该 Region 就会进行拆分（0.94 版本之前）。

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

3）当HRegionServer宕机后，HMaster将该HRegionServer对应的HLog拆分，然后分配给不同的HRegionServer加载，修改.META.；

4）注意：HLog会同步到HDFS。（memstore在一个server上也会有很多，所以HLog丢失会不安全）

五、Java API 操作 HBase

5.1 环境准备

新建项目后在pom.xml中添加依赖：

<dependencies>
<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>RELEASE</version>
</dependency>
<dependency>
    <groupId>org.apache.hbase</groupId>
    <artifactId>hbase-client</artifactId>
    <version>1.3.1</version>
</dependency>
</dependencies>

5.2 HBase API

5.2.1 获取Configuration对象

Configuration conf = null;

@Before
public void getConfiguration()throws Exception {
    // 获取配置对象
    conf = HBaseConfiguration.create();
    conf.set("hbase.zookeeper.quorum","hadoop003,hadoop004,hadoop005");
    conf.set("hbase.zookeeper.property.clientPort","2181");
}

5.2.2 判断表是否存在

@Test // 判断表是否存在
public void tableExist()throws Exception {
    // 通过配置对象获取连接对象
    Connection conn = ConnectionFactory.createConnection(conf);
    // 通过连接对象，获取操作hbase的对象
    Admin admin = conn.getAdmin();
    // 通过hbase的客户端对象操作hbase 判断表是否存在
    boolean student = admin.tableExists(TableName.valueOf("student"));
    System.out.println("表是否存在："+student);
    admin.close();
    conn.close();
}

5.2.3 创建表

@Test // 创建表
public void tableCreate()throws Exception {
    // 通过配置对象获取连接对象
    Connection conn = ConnectionFactory.createConnection(conf);
    // 通过连接对象，获取操作hbase的对象
    Admin admin = conn.getAdmin();
    // 通过hbase的客户端对象操作hbase
    HTableDescriptor hTableDescriptor = new HTableDescriptor(TableName.valueOf("stu"));
    HColumnDescriptor hColumnDescriptor = new HColumnDescriptor("info");
    hTableDescriptor.addFamily(hColumnDescriptor);
    admin.createTable(hTableDescriptor);
    System.out.println("创建表成功");
    admin.close();
    conn.close();
}

5.2.4 删除表

@Test // 删除表
public void tableDelete()throws Exception {
    // 通过配置对象获取连接对象
    Connection conn = ConnectionFactory.createConnection(conf);
    // 通过连接对象，获取操作hbase的对象
    Admin admin = conn.getAdmin();
    // 通过hbase的客户端对象操作hbase
    admin.disableTable(TableName.valueOf("stu"));
    admin.deleteTable(TableName.valueOf("stu"));
    System.out.println("删除表成功");
    admin.close();
    conn.close();
}

5.2.5 向表中插入数据

@Test // 插入数据
    public void dataInsert()throws Exception {
        // 通过配置对象获取连接对象
        Connection conn = ConnectionFactory.createConnection(conf);
        // 通过连接对象，获取操作hbase的对象
        // Admin admin = conn.getAdmin(); // 无法通过admin对象操作表的数据
        // 通过hbase的客户端对象操作hbase
        Table connTable = conn.getTable(TableName.valueOf("student"));
        //参数：要插入数据的行键，而是是字节数组，必须用hbase自带的这个Bytes.toBytes()转化
        // 可以利用一个put对象插入一个行键的多个列，但是无法通过一个put对象插入多个行键的数据
//        Put put = new Put(Bytes.toBytes("1004"));
//        put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("name"),Bytes.toBytes("wanglaoqi"));
//        put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("age"), Bytes.toBytes("18"));
//        put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("addr"),Bytes.toBytes("beijing"));
//        put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("tel"),Bytes.toBytes("10086"));

        //要想插入多个行键的数据，可以new多个put对象，放入一个集合
        Put put1 = new Put(Bytes.toBytes("1008"));
        put1.addColumn(Bytes.toBytes("info"), Bytes.toBytes("age"),Bytes.toBytes("19"));
        Put put2 = new Put(Bytes.toBytes("1008"));
        put2.addColumn(Bytes.toBytes("info"), Bytes.toBytes("name"),Bytes.toBytes("laosi"));
        Put put3 = new Put(Bytes.toBytes("1008"));
        put3.addColumn(Bytes.toBytes("info"), Bytes.toBytes("addr"),Bytes.toBytes("shanghai"));

        ArrayList<Put> puts = new ArrayList();
        puts.add(put1);
        puts.add(put2);
        puts.add(put3);
        connTable.put(puts);
        System.out.println("插入数据成功");
        connTable.close();
        conn.close();
    }

5.2.6 删除一行&多行数据

@Test // 删除数据
public void dataDelete()throws Exception {
    // 通过配置对象获取连接对象
    Connection conn = ConnectionFactory.createConnection(conf);
    // 通过连接对象，获取操作hbase的对象
    // Admin admin = conn.getAdmin(); // 无法通过admin对象操作表的数据
    // 通过hbase的客户端对象操作hbase
    Table connTable = conn.getTable(TableName.valueOf("student"));
    //Delete delete = new Delete(Bytes.toBytes("1004"));
   // delete.addColumn(Bytes.toBytes("info"), Bytes.toBytes("name"));
    //delete.addFamily(Bytes.toBytes("info"));

    // 要想删除多个行键的数据，必须new多个Delete对象，保证其行键不同
    Delete delete1 = new Delete(Bytes.toBytes("1005"));
    Delete delete2 = new Delete(Bytes.toBytes("1006"));
    ArrayList<Delete> deletes = new ArrayList();
    deletes.add(delete1);
    deletes.add(delete2);
    connTable.delete(deletes);

    System.out.println("删除数据成功");
    connTable.close();
    conn.close();
}

5.2.7 获取所有数据

@Test // 获取所有数据
public void dataGetAll()throws Exception {
    // 通过配置对象获取连接对象
    Connection conn = ConnectionFactory.createConnection(conf);
    // 通过连接对象，获取操作hbase的对象
    // Admin admin = conn.getAdmin(); // 无法通过admin对象操作表的数据
    // 通过hbase的客户端对象操作hbase
    Table connTable = conn.getTable(TableName.valueOf("student"));
    Scan scan = new Scan();
    //scan.addFamily(Bytes.toBytes("info"));
    // 获取scanner
    ResultScanner scanner = connTable.getScanner(scan);
    // 通过scanner遍历所有的数据
    for (Result result : scanner) {
        //  某个rowkey的所有cell
        Cell[] cells = result.rawCells();
        for (Cell cell : cells) {
            String rowkey = Bytes.toString(CellUtil.cloneRow(cell));
            String family = Bytes.toString(CellUtil.cloneFamily(cell));
            String column = Bytes.toString(CellUtil.cloneQualifier(cell));
            String value = Bytes.toString(CellUtil.cloneValue(cell));
            System.out.println(rowkey+":"+family+":"+column+":"+value);
        }
        System.out.println("==============================================");
    }
    System.out.println("获取所有数据成功");
    connTable.close();
    conn.close();
}

5.2.8 获取某一行数据，指定列族，列

@Test // 获取一些数据
public void dataGetSome()throws Exception {
    // 通过配置对象获取连接对象
    Connection conn = ConnectionFactory.createConnection(conf);
    // 通过连接对象，获取操作hbase的对象
    // Admin admin = conn.getAdmin(); // 无法通过admin对象操作表的数据
    // 通过hbase的客户端对象操作hbase
    Table connTable = conn.getTable(TableName.valueOf("student"));
    //Get get = new Get(Bytes.toBytes("1008"));
    //get.addFamily(Bytes.toBytes("info"));
    //get.addColumn(Bytes.toBytes("info"), Bytes.toBytes("name"));
    Get get1 = new Get(Bytes.toBytes("1002"));
    Get get2 = new Get(Bytes.toBytes("1003"));
    ArrayList<Get> gets = new ArrayList();
    gets.add(get1);
    gets.add(get2);
    // get方法传递一个get对象，则返回的是一个Result对象
    // 如果传递一个get对象集合作为参数，则返回的是一个Result对象的数组
    /*Result[] results = connTable.get(gets);
    Cell[] cells = result1.rawCells();
    for (Cell cell : cells) {
        String rowkey = Bytes.toString(CellUtil.cloneRow(cell));
        String family = Bytes.toString(CellUtil.cloneFamily(cell));
        String column = Bytes.toString(CellUtil.cloneQualifier(cell));
        String value = Bytes.toString(CellUtil.cloneValue(cell));
        System.out.println(rowkey+":"+family+":"+column+":"+value);
    }*/

    Result[] results = connTable.get(gets);
    for (Result result : results) {
        Cell[] cells = result.rawCells();
        for (Cell cell : cells) {
            String rowkey = Bytes.toString(CellUtil.cloneRow(cell));
            String family = Bytes.toString(CellUtil.cloneFamily(cell));
            String column = Bytes.toString(CellUtil.cloneQualifier(cell));
            String value = Bytes.toString(CellUtil.cloneValue(cell));
            System.out.println(rowkey+":"+family+":"+column+":"+value);
        }
        System.out.println("=================================");
    }

    System.out.println("获取一些数据成功");
    connTable.close();
    conn.close();
}

六、HBase企业级调优

6.1 高可用（High Available）

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

1．关闭HBase集群（如果没有开启则跳过此步）

[root@hadoop003 hbase-1.3.1]$ bin/stop-hbase.sh

2．在conf目录下创建backup-masters文件

[root@hadoop003 hbase-1.3.1]$ touch conf/backup-masters

3．在backup-masters文件中配置高可用HMaster节点

[root@hadoop003 hbase-1.3.1]$ echo hadoop005 > conf/backup-masters

4．将backup-masters分发到其他节点

5．启动集群并打开页面测试查看http://hadooo003:16010

6.2 RowKey设计

一条数据的唯一标识就是rowkey，那么这条数据存储于哪个分区，取决于rowkey处于哪个一个预分区的区间内，设计rowkey的主要目的，就是让数据均匀的分布于所有的region中，在一定程度上防止不同region的数据倾斜，再一个就是要记住rowkey，防止取不出来。接下来我们就谈一谈rowkey常用的设计方案。

注意：RowKey如何设计必须结合实际业务场景

6.3 预分区

每一个region维护着startRowKey与endRowKey，如果加入的数据符合某个region维护的rowKey范围，则该数据交给这个region维护。那么依照这个原则，我们可以将数据所要投放的分区提前大致的规划好，以提高HBase性能。
注意：手动分区（预分区）需要对业务数据量有把控

手动设定预分区

hbase> create 'staff1','info',SPLITS => ['1000','2000','3000','4000']

6.4 内存优化

HBase操作过程中需要大量的内存开销，毕竟Table是可以缓存在内存中的，一般会分配整个可用内存的70%给HBase的Java堆。但是不建议分配非常大的堆内存，因为GC过程持续太久会导致RegionServer处于长期不可用状态，一般16~48G内存就可以了，如果因为框架占用内存过高导致系统内存不足，框架一样会被系统服务拖死。

七、HBase认知扩展

7.1 HBase在商业项目中的能力

每天：

1) 消息量：发送和接收的消息数超过60亿

2) 将近1000亿条数据的读写

3) 高峰期每秒150万左右操作

4) 整体读取数据占有约55%，写入占有45%

5) 超过2PB的数据，涉及冗余共6PB数据

6) 数据每月大概增长300千兆字节。

7.2 布隆过滤器

在日常生活中，包括在设计计算机软件时，我们经常要判断一个元素是否在一个集合中。比如在字处理软件中，需要检查一个英语单词是否拼写正确（也就是要判断它是否在已知的字典中）；在 FBI，一个嫌疑人的名字是否已经在嫌疑名单上；在网络爬虫里，一个网址是否被访问过等等。最直接的方法就是将集合中全部的元素存在计算机中，遇到一个新元素时，将它和集合中的元素直接比较即可。一般来讲，计算机中的集合是用哈希表（hash table）来存储的。它的好处是快速准确，缺点是费存储空间。当集合比较小时，这个问题不显著，但是当集合巨大时，哈希表存储效率低的问题就显现出来了。比如说，一个像 Yahoo,Hotmail 和 Gmai 那样的公众电子邮件（email）提供商，总是需要过滤来自发送垃圾邮件的人（spamer）的垃圾邮件。一个办法就是记录下那些发垃圾邮件的 email 地址。由于那些发送者不停地在注册新的地址，全世界少说也有几十亿个发垃圾邮件的地址，将他们都存起来则需要大量的网络服务器。如果用哈希表，每存储一亿个 email 地址，就需要 1.6GB 的内存（用哈希表实现的具体办法是将每一个 email 地址对应成一个八字节的信息指纹googlechinablog.com/2006/08/blog-post.html，然后将这些信息指纹存入哈希表，由于哈希表的存储效率一般只有 50%，因此一个 email 地址需要占用十六个字节。一亿个地址大约要 1.6GB，即十六亿字节的内存）。因此存贮几十亿个邮件地址可能需要上百 GB 的内存。除非是超级计算机，一般服务器是无法存储的。

布隆过滤器只需要哈希表 1/8 到 1/4 的大小就能解决同样的问题。

Bloom Filter是一种空间效率很高的随机数据结构，它利用位数组很简洁地表示一个集合，并能判断一个元素是否属于这个集合。Bloom Filter的这种高效是有一定代价的：在判断一个元素是否属于某个集合时，有可能会把不属于这个集合的元素误认为属于这个集合（false positive）。因此，Bloom Filter不适合那些“零错误”的应用场合。而在能容忍低错误率的应用场合下，Bloom Filter通过极少的错误换取了存储空间的极大节省。

下面我们具体来看Bloom Filter是如何用位数组表示集合的。初始状态时，Bloom Filter是一个包含m位的位数组，每一位都置为0，如图所示：

为了表达S={x1, x2,…,xn}这样一个n个元素的集合，Bloom Filter使用k个相互独立的哈希函数（Hash Function），它们分别将集合中的每个元素映射到{1,…,m}的范围中。对任意一个元素x，第i个哈希函数映射的位置hi(x)就会被置为1（1≤i≤k）。注意，如果一个位置多次被置为1，那么只有第一次会起作用，后面几次将没有任何效果。如图所示，k=3，且有两个哈希函数选中同一个位置（从左边数第五位）。

在判断y是否属于这个集合时，我们对y应用k次哈希函数，如果所有hi(y)的位置都是1（1≤i≤k），那么我们就认为y是集合中的元素，否则就认为y不是集合中的元素。如图所示y1就不是集合中的元素。y2或者属于这个集合，或者刚好是一个false positive。

为了add一个元素，用k个hash function将它hash得到bloom filter中k个bit位，将这k个bit位置1。
为了query一个元素，即判断它是否在集合中，用k个hash function将它hash得到k个bit位。若这k bits全为1，则此元素在集合中；若其中任一位不为1，则此元素比不在集合中（因为如果在，则在add时已经把对应的k个bits位置为1）。
不允许remove元素，因为那样的话会把相应的k个bits位置为0，而其中很有可能有其它元素对应的位。因此remove会引入false negative，这是绝对不被允许的。

布隆过滤器决不会漏掉任何一个在黑名单中的可疑地址。但是，它有一条不足之处，也就是它有极小的可能将一个不在黑名单中的电子邮件地址判定为在黑名单中，因为有可能某个好的邮件地址正巧对应一个八个都被设置成一的二进制位。好在这种可能性很小，我们把它称为误识概率。

布隆过滤器的好处在于快速，省空间，但是有一定的误识别率，常见的补救办法是在建立一个小的白名单，存储那些可能个别误判的邮件地址

✔✔✔✔

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
HBase原理及优化

目录一、HBase 原理之写流程二、HBase 原理之读流程三、HBase 原理之数据Flush流程四、HBase 原理之数据合并流程五、Java API 操作 HBase5.1 环境准备5.2 HBase API5.2.1 获取Configuration对象5.2.2 判断表是否存在5.2.3 创建表5.2.4 删除表5.2.5 向表中插入数据5.2.6 删除一行&多行数据5.2.7 获取所有数据5.2.8 获取某一行数据，指定列族，..
复制链接

扫一扫