#CSDN软件工程师能力认证学习精选# Hbase从入门到入坑

CSDN软件工程师能力认证是由CSDN制定并推出的一个能力认证标准，宗旨是让一流的技术人才凭真才实学进大厂拿高薪，同时为企业节约大量招聘与培养成本，使命是提升高校大学生的技术能力，为行业提供人才储备，为国家数字化战略贡献力量。我们每天将都会精选CSDN站内技术文章供大家学习，帮助大家系统化学习IT技术。

 

一 什么是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与mysql、oralce、db2、sqlserver等关系型数据库不同，它是一个NoSQL数据库（非关系型数据库）

1. Hbase的表模型与关系型数据库的表模型不同：
2. Hbase的表没有固定的字段定义；
3. Hbase的表中每行存储的都是一些key-value对
4. Hbase的表中有列族的划分，用户可以指定将哪些kv插入哪个列族
5. Hbase的表在物理存储上，是按照列族来分割的，不同列族的数据一定存储在不同的文件中
6. Hbase的表中的每一行都固定有一个行键，而且每一行的行键在表中不能重复
7. Hbase中的数据，包含行键，包含key，包含value，都是byte[ ]类型，hbase不负责为用户维护数据类型
8. HBASE对事务的支持很差

HBASE相比于其他nosql数据库(mongodb、redis、cassendra、hazelcast)的特点：

Hbase的表数据存储在HDFS文件系统中

从而，hbase具备如下特性：存储容量可以线性扩展； 数据存储的安全性可靠性极高！

二 安装HBASE

HBASE是一个分布式系统

其中有一个管理角色：  HMaster(一般2台，一台active，一台backup)

其他的数据节点角色：  HRegionServer(很多台，看数据容量)

2.1 安装准备

需要先有一个java环境

首先，要有一个HDFS集群，并正常运行； regionserver应该跟hdfs中的datanode在一起

其次，还需要一个zookeeper集群，并正常运行

然后，安装HBASE

角色分配如下：

Hdp01:  namenode  datanode  regionserver  hmaster  zookeeper

Hdp02:  datanode   regionserver  zookeeper

Hdp03:  datanode   regionserver  zookeeper

2.2 安装步骤

解压hbase安装包

修改hbase-env.sh

export JAVA_HOME=/root/apps/jdk1.7.0_67

export HBASE_MANAGES_ZK=false

修改hbase-site.xml

        

                hbase.rootdir

                hdfs://hdp01:9000/hbase

        

        

                hbase.cluster.distributed

                true

        

        

                hbase.zookeeper.quorum

                hdp01:2181,hdp02:2181,hdp03:2181

        

修改 regionservers

hdp01

hdp02

hdp03

2.3 启动hbase集群

bin/start-hbase.sh

启动完后，还可以在集群中找任意一台机器启动一个备用的master

bin/hbase-daemon.sh start master

新启的这个master会处于backup状态

三 hbase初体验

3.1 启动hbase命令行客户端

bin/hbase shell

Hbase> list     // 查看表

Hbase> status   // 查看集群状态

Hbase> version  // 查看集群版本

3.2 hbase表模型的特点

1. 一个表，有表名
2. 一个表可以分为多个列族（不同列族的数据会存储在不同文件中）
3. 表中的每一行有一个“行键rowkey”，而且行键在表中不能重复
4. 表中的每一对kv数据称作一个cell
5. hbase可以对数据存储多个历史版本（历史版本数量可配置）
6. 整张表由于数据量过大，会被横向切分成若干个region（用rowkey范围标识），不同region的数据也存储在不同文件中
7. hbase会对插入的数据按顺序存储：

     要点一：首先会按行键排序

     要点二：同一行里面的kv会按列族排序，再按k排序

3.3 hbase的表中能存储什么数据类型

hbase中只支持byte[]

此处的byte[] 包括了： rowkey,key,value,列族名,表名

3.4 hbase命令行客户端操作

名称

命令表达式

创建表

create '表名', '列族名1','列族名2','列族名N'

查看所有表

list

描述表

describe  ‘表名’

判断表存在

exists  '表名'

判断是否禁用启用表

is_enabled '表名'

is_disabled ‘表名’

添加记录      

put  ‘表名’, ‘rowKey’, ‘列族 : 列‘  ,  '值'

查看记录rowkey下的所有数据

get  '表名' , 'rowKey'

查看表中的记录总数

count  '表名'

获取某个列族

get '表名','rowkey','列族'

获取某个列族的某个列

get '表名','rowkey','列族：列’

删除记录

delete  ‘表名’ ,‘行名’ , ‘列族：列'

删除整行

deleteall '表名','rowkey'

删除一张表

先要屏蔽该表，才能对该表进行删除

第一步 disable ‘表名’ ，第二步  drop '表名'

清空表

truncate '表名'

查看所有记录

scan "表名"  

查看某个表某个列中所有数据

scan "表名" , {COLUMNS=>'列族名:列名'}

更新记录

就是重写一遍，进行覆盖，hbase没有修改，都是追加

3.4.1 建表

create 't_user_info','base_info','extra_info'

                      表名      列族名   列族名

3.4.2 插入数据

hbase(main):011:0> put 't_user_info','001','base_info:username','zhangsan'

0 row(s) in 0.2420 seconds

 

hbase(main):012:0> put 't_user_info','001','base_info:age','18'

0 row(s) in 0.0140 seconds

 

hbase(main):013:0> put 't_user_info','001','base_info:sex','female'

0 row(s) in 0.0070 seconds

 

hbase(main):014:0> put 't_user_info','001','extra_info:career','it'

0 row(s) in 0.0090 seconds

 

hbase(main):015:0> put 't_user_info','002','extra_info:career','actoress'

0 row(s) in 0.0090 seconds

 

hbase(main):016:0> put 't_user_info','002','base_info:username','liuyifei'

0 row(s) in 0.0060 seconds

3.4.3 查询方式一 scan扫描

hbase(main):017:0> scan 't_user_info'

ROW                               COLUMN+CELL                                                                                     

 001                              column=base_info:age, timestamp=1496567924507, value=18                                         

 001                              column=base_info:sex, timestamp=1496567934669, value=female                                     

 001                              column=base_info:username, timestamp=1496567889554, value=zhangsan                              

 001                              column=extra_info:career, timestamp=1496567963992, value=it                                     

 002                              column=base_info:username, timestamp=1496568034187, value=liuyifei                              

 002                              column=extra_info:career, timestamp=1496568008631, value=actoress    

3.4.4 查询方式二 get单行数据

hbase(main):020:0> get 't_user_info','001'

COLUMN                            CELL                                                                                            

 base_info:age                    timestamp=1496568160192, value=19                                                               

 base_info:sex                    timestamp=1496567934669, value=female                                                           

 base_info:username               timestamp=1496567889554, value=zhangsan                                                         

 extra_info:career                timestamp=1496567963992, value=it                                                               

4 row(s) in 0.0770 seconds

3.4.5 删除一个kv数据

hbase(main):021:0> delete 't_user_info','001','base_info:sex'

0 row(s) in 0.0390 seconds

删除整行数据

hbase(main):024:0> deleteall 't_user_info','001'

0 row(s) in 0.0090 seconds

hbase(main):025:0> get 't_user_info','001'

COLUMN                            CELL                                                                                            

0 row(s) in 0.0110 seconds

3.4.6 删除整个表

hbase(main):028:0> disable 't_user_info'

0 row(s) in 2.3640 seconds

hbase(main):029:0> drop 't_user_info'

0 row(s) in 1.2950 seconds

hbase(main):030:0> list

TABLE                                                                                                                             

0 row(s) in 0.0130 seconds

=> []

3.5 Hbase重要特性-排序特性(行键)

与nosql数据库们一样,row key是用来检索记录的主键。访问HBASE table中的行，只有三种方式：

1.通过单个row key访问

2.通过row key的range（正则）

3.全表扫描

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

插入到hbase中去的数据，hbase会自动排序存储：

排序规则：  首先看行键，然后看列族名，然后看列（key）名； 按字典顺序

Hbase的这个特性跟查询效率有极大的关系

比如：一张用来存储用户信息的表，有名字，户籍，年龄，职业....等信息

然后，在业务系统中经常需要：

查询某个省的所有用户

经常需要查询某个省的指定姓的所有用户

思路：如果能将相同省的用户在hbase的存储文件中连续存储，并且能将相同省中相同姓的用户连续存储，那么，上述两个查询需求的效率就会提高！！！

做法：将查询条件拼到rowkey内

四 HBASE客户端API操作

4.1 简洁版

HbaseClientDDL 

1. package cn.hbase.demo;

2.  

3. import org.apache.hadoop.conf.Configuration;

4. import org.apache.hadoop.hbase.HBaseConfiguration;

5. import org.apache.hadoop.hbase.HColumnDescriptor;

6. import org.apache.hadoop.hbase.HTableDescriptor;

7. import org.apache.hadoop.hbase.TableName;

8. import org.apache.hadoop.hbase.client.Admin;

9. import org.apache.hadoop.hbase.client.Connection;

10. import org.apache.hadoop.hbase.client.ConnectionFactory;

11. import org.apache.hadoop.hbase.regionserver.BloomType;

12. import org.junit.Before;

13. import org.junit.Test;

14.  
15.  

16. /**

17. *

18. * 1、构建连接

19. * 2、从连接中取到一个表DDL操作工具admin

20. * 3、admin.createTable(表描述对象);

21. * 4、admin.disableTable(表名);

22. 5、admin.deleteTable(表名);

23. 6、admin.modifyTable(表名，表描述对象);

24. *

25. *

26. */

27. public class HbaseClientDDL {

28. Connection conn = null;

29.  

30. @Before

31. public void getConn() throws Exception{

32. // 构建一个连接对象

33. Configuration conf = HBaseConfiguration.create(); // 会自动加载hbase-site.xml

34. conf.set("hbase.zookeeper.quorum", "hdp-01:2181,hdp-02:2181,hdp-03:2181");

35.  

36. conn = ConnectionFactory.createConnection(conf);

37. }

38.  
39.  
40.  

41. /**

42. * DDL

43. * @throws Exception

44. */

45. @Test

46. public void testCreateTable() throws Exception{

47.  

48. // 从连接中构造一个DDL操作器

49. Admin admin = conn.getAdmin();

50.  

51. // 创建一个表定义描述对象

52. HTableDescriptor hTableDescriptor = new HTableDescriptor(TableName.valueOf("user_info"));

53.  

54. // 创建列族定义描述对象

55. HColumnDescriptor hColumnDescriptor_1 = new HColumnDescriptor("base_info");

56. hColumnDescriptor_1.setMaxVersions(3); // 设置该列族中存储数据的最大版本数,默认是1

57.  

58. HColumnDescriptor hColumnDescriptor_2 = new HColumnDescriptor("extra_info");

59.  

60. // 将列族定义信息对象放入表定义对象中

61. hTableDescriptor.addFamily(hColumnDescriptor_1);

62. hTableDescriptor.addFamily(hColumnDescriptor_2);

63.  
64.  

65. // 用ddl操作器对象：admin 来建表

66. admin.createTable(hTableDescriptor);

67.  

68. // 关闭连接

69. admin.close();

70. conn.close();

71.  

72. }

73.  
74.  

75. /**

76. * 删除表

77. * @throws Exception

78. */

79. @Test

80. public void testDropTable() throws Exception{

81.  

82. Admin admin = conn.getAdmin();

83.  

84. // 停用表

85. admin.disableTable(TableName.valueOf("user_info"));

86. // 删除表

87. admin.deleteTable(TableName.valueOf("user_info"));

88.  
89.  

90. admin.close();

91. conn.close();

92. }

93.  

94. // 修改表定义--添加一个列族

95. @Test

96. public void testAlterTable() throws Exception{

97.  

98. Admin admin = conn.getAdmin();

99.  

100. // 取出旧的表定义信息

101. HTableDescriptor tableDescriptor = admin.getTableDescriptor(TableName.valueOf("user_info"));

102.  
103.  

104. // 新构造一个列族定义

105. HColumnDescriptor hColumnDescriptor = new HColumnDescriptor("other_info");

106. hColumnDescriptor.setBloomFilterType(BloomType.ROWCOL); // 设置该列族的布隆过滤器类型

107.  

108. // 将列族定义添加到表定义对象中

109. tableDescriptor.addFamily(hColumnDescriptor);

110.  
111.  

112. // 将修改过的表定义交给admin去提交

113. admin.modifyTable(TableName.valueOf("user_info"), tableDescriptor);

114.  
115.  

116. admin.close();

117. conn.close();

118.  

119. }

120.  
121.  

122. /**

123. * DML -- 数据的增删改查

124. */

125.  
126.  
127.  

128. }

HbaseClientDML

1. package cn.hbase.demo;

2.  
3.  

4. import java.util.ArrayList;

5. import java.util.Iterator;

6.  

7. import org.apache.hadoop.conf.Configuration;

8. import org.apache.hadoop.hbase.Cell;

9. import org.apache.hadoop.hbase.CellScanner;

10. import org.apache.hadoop.hbase.HBaseConfiguration;

11. import org.apache.hadoop.hbase.TableName;

12. import org.apache.hadoop.hbase.client.Connection;

13. import org.apache.hadoop.hbase.client.ConnectionFactory;

14. import org.apache.hadoop.hbase.client.Delete;

15. import org.apache.hadoop.hbase.client.Get;

16. import org.apache.hadoop.hbase.client.Put;

17. import org.apache.hadoop.hbase.client.Result;

18. import org.apache.hadoop.hbase.client.ResultScanner;

19. import org.apache.hadoop.hbase.client.Scan;

20. import org.apache.hadoop.hbase.client.Table;

21. import org.apache.hadoop.hbase.util.Bytes;

22. import org.junit.Before;

23. import org.junit.Test;

24.  

25. public class HbaseClientDML {

26. Connection conn = null;

27.  

28. @Before

29. public void getConn() throws Exception{

30. // 构建一个连接对象

31. Configuration conf = HBaseConfiguration.create(); // 会自动加载hbase-site.xml

32. conf.set("hbase.zookeeper.quorum", "hdp-01:2181,hdp-02:2181,hdp-03:2181");

33.  

34. conn = ConnectionFactory.createConnection(conf);

35. }

36.  
37.  

38. /**

39. * 增

40. * 改:put来覆盖

41. * @throws Exception

42. */

43. @Test

44. public void testPut() throws Exception{

45.  

46. // 获取一个操作指定表的table对象,进行DML操作

47. Table table = conn.getTable(TableName.valueOf("user_info"));

48.  

49. // 构造要插入的数据为一个Put类型(一个put对象只能对应一个rowkey)的对象

50. Put put = new Put(Bytes.toBytes("001"));

51. put.addColumn(Bytes.toBytes("base_info"), Bytes.toBytes("username"), Bytes.toBytes("张三"));

52. put.addColumn(Bytes.toBytes("base_info"), Bytes.toBytes("age"), Bytes.toBytes("18"));

53. put.addColumn(Bytes.toBytes("extra_info"), Bytes.toBytes("addr"), Bytes.toBytes("北京"));

54.  
55.  

56. Put put2 = new Put(Bytes.toBytes("002"));

57. put2.addColumn(Bytes.toBytes("base_info"), Bytes.toBytes("username"), Bytes.toBytes("李四"));

58. put2.addColumn(Bytes.toBytes("base_info"), Bytes.toBytes("age"), Bytes.toBytes("28"));

59. put2.addColumn(Bytes.toBytes("extra_info"), Bytes.toBytes("addr"), Bytes.toBytes("上海"));

60.  
61.  

62. ArrayList puts = new ArrayList();

63. puts.add(put);

64. puts.add(put2);

65.  
66.  

67. // 插进去

68. table.put(puts);

69.  

70. table.close();

71. conn.close();

72.  

73. }

74.  
75.  

76. /**

77. * 循环插入大量数据

78. * @throws Exception

79. */

80. @Test

81. public void testManyPuts() throws Exception{

82.  

83. Table table = conn.getTable(TableName.valueOf("user_info"));

84. ArrayList puts = new ArrayList();

85.  

86. for(int i=0;i conf/backup-masters

    4．将整个conf目录scp到其他节点

    [atguigu@hadoop102 hbase]$ scp -r conf/ hadoop103:/opt/module/hbase/

    [atguigu@hadoop102 hbase]$ scp -r conf/ hadoop104:/opt/module/hbase/

    6.2 预分区

    每一个region维护着startRow与endRowKey，如果加入的数据符合某个region维护的rowKey范围，则该数据交给这个region维护。那么依照这个原则，我们可以将数据所要投放的分区提前大致的规划好，以提高HBase性能。

    1．手动设定预分区

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

    2．生成16进制序列预分区

    create 'staff2','info','partition2',{NUMREGIONS => 15, SPLITALGO => 'HexStringSplit'}

    3．按照文件中设置的规则预分区

    创建splits.txt文件内容如下：

    aaaa

    bbbb

    cccc

    dddd

    然后执行：

    create 'staff3','partition3',SPLITS_FILE => 'splits.txt'

    4．使用JavaAPI创建预分区

    //自定义算法，产生一系列Hash散列值存储在二维数组中

    byte[][] splitKeys = 某个散列值函数

    //创建HBaseAdmin实例

    HBaseAdmin hAdmin = new HBaseAdmin(HBaseConfiguration.create());

    //创建HTableDescriptor实例

    HTableDescriptor tableDesc = new HTableDescriptor(tableName);

    //通过HTableDescriptor实例和散列值二维数组创建带有预分区的HBase表

    hAdmin.createTable(tableDesc, splitKeys);

    6.3 RowKey设计

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

    1．生成随机数、hash、散列值

    比如：

    原本rowKey为1001的，SHA1后变成：dd01903921ea24941c26a48f2cec24e0bb0e8cc7

    原本rowKey为3001的，SHA1后变成：49042c54de64a1e9bf0b33e00245660ef92dc7bd

    原本rowKey为5001的，SHA1后变成：7b61dec07e02c188790670af43e717f0f46e8913

    在做此操作之前，一般我们会选择从数据集中抽取样本，来决定什么样的rowKey来Hash后作为每个分区的临界值。

    2.字符串反转

    20170524000001转成10000042507102

    20170524000002转成20000042507102

    3.字符串拼接

    20170524000001_a12e

    20170524000001_93i7

    6.4 内存优化

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

    6.5 基础优化

    1．允许在HDFS的文件中追加内容

    hdfs-site.xml、hbase-site.xml

    属性：dfs.support.append

    解释：开启HDFS追加同步，可以优秀的配合HBase的数据同步和持久化。默认值为true。

    2．优化DataNode允许的最大文件打开数

     

     

    hdfs-site.xml

    属性：dfs.datanode.max.transfer.threads

    解释：HBase一般都会同一时间操作大量的文件，根据集群的数量和规模以及数据动作，设置为4096或者更高。默认值：4096

    3．优化延迟高的数据操作的等待时间

    hdfs-site.xml

    属性：dfs.image.transfer.timeout

    解释：如果对于某一次数据操作来讲，延迟非常高，socket需要等待更长的时间，建议把该值设置为更大的值（默认60000毫秒），以确保socket不会被timeout掉。

    4．优化数据的写入效率

    mapred-site.xml

    属性：

    mapreduce.map.output.compress

    mapreduce.map.output.compress.codec

    解释：开启这两个数据可以大大提高文件的写入效率，减少写入时间。第一个属性值修改为true，第二个属性值修改为：org.apache.hadoop.io.compress.GzipCodec或者其他压缩方式。

    5．设置RPC监听数量

    hbase-site.xml

    属性：hbase.regionserver.handler.count

    解释：默认值为30，用于指定RPC监听的数量，可以根据客户端的请求数进行调整，读写请求较多时，增加此值。

    6．优化HStore文件大小

    hbase-site.xml

    属性：hbase.hregion.max.filesize

    解释：默认值10737418240（10GB），如果需要运行HBase的MR任务，可以减小此值，因为一个region对应一个map任务，如果单个region过大，会导致map任务执行时间过长。该值的意思就是，如果HFile的大小达到这个数值，则这个region会被切分为两个Hfile。

    7．优化hbase客户端缓存

    hbase-site.xml

    属性：hbase.client.write.buffer

    解释：用于指定HBase客户端缓存，增大该值可以减少RPC调用次数，但是会消耗更多内存，反之则反之。一般我们需要设定一定的缓存大小，以达到减少RPC次数的目的。

    8．指定scan.next扫描HBase所获取的行数

    hbase-site.xml

    属性：hbase.client.scanner.caching

    解释：用于指定scan.next方法获取的默认行数，值越大，消耗内存越大。

    9．flush、compact、split机制

    当MemStore达到阈值，将Memstore中的数据Flush进Storefile；compact机制则是把flush出来的小文件合并成大的Storefile文件。split则是当Region达到阈值，会把过大的Region一分为二。

    涉及属性：

    即：128M就是Memstore的默认阈值

    hbase.hregion.memstore.flush.size：134217728

    即：这个参数的作用是当单个HRegion内所有的Memstore大小总和超过指定值时，flush该HRegion的所有memstore。RegionServer的flush是通过将请求添加一个队列，模拟生产消费模型来异步处理的。那这里就有一个问题，当队列来不及消费，产生大量积压请求时，可能会导致内存陡增，最坏的情况是触发OOM。

    hbase.regionserver.global.memstore.upperLimit：0.4

    hbase.regionserver.global.memstore.lowerLimit：0.38

    即：当MemStore使用内存总量达到hbase.regionserver.global.memstore.upperLimit指定值时，将会有多个MemStores flush到文件中，MemStore flush 顺序是按照大小降序执行的，直到刷新到MemStore使用内存略小于lowerLimit

     

     

    关于CSDN软件工程师能力认证

          CSDN软件工程师能力认证（以下简称C系列认证）是由中国软件开发者网CSDN制定并推出的一个能力认证标准。C系列认证历经近一年的实际线下调研、考察、迭代、测试，并梳理出软件工程师开发过程中所需的各项技术技能，结合企业招聘需求和人才应聘痛点，基于公开、透明、公正的原则，甑别人才时确保真实业务场景、全部上机实操、所有过程留痕、存档不可篡改。C系列认证的宗旨是让一流的技术人才凭真才实学进大厂拿高薪，同时为企业节约大量招聘与培养成本，使命是提升高校大学生的技术能力，为行业提供人才储备，为国家数字化战略贡献力量。

     

    了解详情可点击：CSDN软件工程师能力认证介绍

     

    本文出处：https://blog.csdn.net/zuochang_liu/article/details/81452124?ops_request_misc=&request_id=&biz_id=102&utm_term=Hbase&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-3-81452124.pc_search_result_before_js&spm=1018.2226.3001.4187