（超详细）快速上手分布式数据库——HBase

向右看齐 2023-10-02 15:34 24阅读 0赞

# HBase的安装、命令操作和基础编程 #

*JunLeon——go big or go home*

--------------------

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_19_color_FFFFFF_t_70_g_se_x_16][]

**目录**

HBase的安装、命令操作和基础编程

一、HBase的概述

1.什么是HBase？

2.HBase的特点

3.HBase组成部分及数据模型

（1）HBase架构的组件及其作用

（2）HBase的数据模型

（3）表和Region

4.HBase的读写流程

5.HBase的Compaction过程

二、基于Hadoop HA集群的HBase环境安装配置

1.下载HBase

2.解压安装配置

（1）上传到虚拟机中指定的opt目录下

（2）解压HBase

（3）配置环境及其相关属性

3.启动HBase集群

4.查看进程及HBase集群信息

三、HBase的Shell命令

1.基本Shell命令

2.DDL操作命令

3.DML操作命令

4.运行HBase Shell脚本

四、HBase基础编程

1.HBase API

2.HBase API编程代码演示

--------------------

**前言：**

学习HBase这个组件，可能很多人都有这个这个疑惑：HDFS和MySQL等都可做数据的持久化存储，那为什么还要学习这个HBase呢？而HBase的最终数据还是存储在HDFS中，那为什么还要使用HBase呢？HBase和HDFS又有什么关系呢？

HBase作为Hadoop的分布式数据库，基于Google发行的三篇论文之一——《BigData》研发的Hadoop生态组件之一。那我们为啥要用HBase呢？HBase在HDFS之上提供了**高并发的随机写**和**支持实时查询**，这是HDFS不具备的。

HDFS是分布式文件存储系统，HBase是分布式数据库，两者其实没有什么可比性。可能很多人对MySQL比较熟悉，MySQL的数据持久化就是将数据落地磁盘存储。简单理解就是可以把HBase当做是MySQL，把HDFS当做是硬盘。HBase只是一个NoSQL数据库，把数据存在HDFS上。

# 一、HBase的概述 #

## 1.什么是HBase？ ##

HBase是高可靠性、高性能、面向列、可伸缩的分布式存储系统，是基于HDFS的分布式数据库，也是一种非关系型数据库。分布式数据库HBase是Hadoop生态系统的组件之一。HBase的运行依赖于Hadoop HDFS文件系统提供数据的持久化，依赖于Zookeeper提供集群的的同步与协调。HBase使用Zookeeper服务来进行节点管理以及表数据的定位。

## 2.HBase的特点 ##

(1)大：一个表可以有上亿行，上百万列。  
(2)面向列：面向列表（簇）的存储和权限控制，列（簇）独立检索。  
(3)稀疏：对于为空（NULL）的列，并不占用存储空间，因此，表可以设计的非常稀疏。  
(4)无模式：每一行都有一个可以排序的主键和任意多的列，列可以根据需要动态增加，同一张表中不同的行可以有截然不同的列。  
(5)数据多版本：每个单元中的数据可以有多个版本，默认情况下，版本号自动分配，版本号就是单元格插入时的时间戳。  
(6)数据类型单一：HBase中的数据都是字符串，没有类型。

## 3.HBase组成部分及数据模型 ##

### （1）HBase架构的组件及其作用 ###

HBase采用Master/slaves的主从服务器架构，由一个HMaster服务器和多个HRegionServer服务器组成。HBase采用Master/Slave架构，主要角色包括Master服务器（HMaster，管理节点）、Region服务器（HRegionServer，数据节点）、ZooKeeper服务器以及客户端。

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_20_color_FFFFFF_t_70_g_se_x_16][]

1．HMaster HMaster

HMaster HMaster是主节点，它主要负责HRegionServer的管理以及元数据的更改，包括以下内容：新HRegionServer的注册、表的增删改查、HRegionServer的负载均衡，Region（表的分区，存储在Region服务器上）的分布调整、Region分裂以及分裂后的Region分配,HRegionServer失效后的Region迁移等。

HMaster采用主备模式部署，集群启动时，通过竞争获得主HMaster角色。主HMaster只能有一个，备HMaster进程在集群运行期间处于休眠状态，不干涉任何集群事务。当主用Master故障时，备用Master将取代主用Master对外提供服务。

2．HRegionServer

HRegionServer是HBase的从节点，它负责提供表数据读写等服务，是数据存储和计算单元。HRegionServer一般与HDFS集群的DataNode部署在一起，实现数据的存储功能。一台HRegionServer管理多个Region对象和一个HLog文件。

一个Region由一个或多个Store组成。每个Store存储该Region一个列族的数据。一个Store包含一个MemStore缓存以及若干StoreFile文件，MemStore缓存客户端向Region插入的数据，当HRegionServer中的MemStore大小达到配置的容量上限时，RegionServer会将MemStore中的数据刷新（Flush）到HDFS中。MemStore的数据刷新到HDFS后成为HFile，HFile定义了StoreFile在文件系统中的存储格式，它是当前HBase系统中StoreFile的具体实现。随着数据的插入，一个Store会产生多个StoreFile，当StoreFile的个数达到配置的最大值时，RegionServer会将多个StoreFile合并为一个大的StoreFile。

HLog日志是一种预写式日志（Write Ahead Log），用户更新数据时需要先写入HLog再写入MemStore，MemStore中的数据被刷新到StoreFile之后才会在HLog中清除对应的记录，这样的设计保证了当HRegionServer故障时，用户写入的数据不丢失，一台HRegionServer的所有Region共享同一个HLog。

3．ZooKeeper

ZooKeeper为HBase集群各进程提供分布式协作服务。各HRegionServer将自己的信息注册到ZooKeeper中，HMaster据此感知各个HRegionServer的健康状态。

HBase还通过ZooKeeper实现HMaster的高可用。ZooKeeper存储HBase的如下信息：HBase元数据、HMaster地址。当HMaster主节点出现故障时，HMaster备用节点会通过ZooKeeper获取主HMaster存储的整个HBase集群状态信息，接管HMaster主节点的工作。

4．Client

客户端通过HBase的元数据找到所需数据所在的HRegionServer进行访问（HBase的元数据存储在ZooKeeper中，因此客户端在做读取操作时不需要与HMaster进行通信，这样的设计减少了HMaster的负担），客户端会在缓存中维护访问过的Region位置信息，下次访问时就可以跳过向ZooKeeper寻址的过程。如果缓存中位置信息所指向的HRegionServer失效或Region已被迁移到其他服务器，客户端在查找不到该Region的情况下，会重新查询元数据以获取该Region的新地址。除了读取HRegionServer的信息外，客户端还可以与HMaster通信做表的修改。

### （2）HBase的数据模型 ###

HBase中，数据存储在由行和列组成的表中，HBase的表是稀疏的，多维映射的。HBase用键值对的方式存储数据。每个值都是未经解释的字符串，通过行键、列族、列限定符、时间戳等信息进行定位。

1．表（Table）

HBase采取表的形式存储数据，表由行和列组成。

2．行（Row）

HBase中的行由行键（RowKey）和若干列组成。行是通过行键按字典顺序进行排序的，因此行键的设计非常重要，好的行键设计可以将内容相关的行排列到相邻位置，方便查找和读取。以存储网页内容为例，将URL作为行键，如org.apache.www、org.apache.mail，可以将相邻子网页存储在相邻的位置。

3．列族（Column Family）

一个表在水平方向上由一个或多个列族组成。一个列族可以由任意多个列组成，列族在表创建时就需要预先设定好。

列族是Region的物理存储单元。同一个Region下面的多个列族，位于不同的Store下面。

列族信息是表级别的配置。同一个表的多个Region，都拥有相同的列族信息（例如，都有两个列族，且不同Region的同一个列族配置信息相同）。不是每一行下的列族或列中都存储了信息，因此说HBase的表是稀疏的。

4．列限定符（Column Qualifier）

列族中添加不同的列限定符可以对数据进行划分定位，列限定符以列族名作为前缀，用“：”连接后缀。例如以“content”为列族，那么列限定符则可以是“content：xxxx”。列限定符是列族下的一个标签，可以在写入数据时任意添加，支持动态扩展，无需预先定义列的数量和类型。

5．单元格（Cell）

一个单元格保存了一个值的多个版本，单元格通过行键、列族和列限定符进行定位，每个版本对应一个时间戳。

6．时间戳（TimeStamp）

HBase每个值都会带一个时间戳，时间戳标识了这个值的版本。默认情况下，在一个值发生变化（写入、更新、删除）时，所在的HRegionServer会自动为其创建一个时间戳。用户也可以在值发生变化时自定义时间戳。如果一个值有多个版本，在用户查询时默认返回最新的版本。HBase保存的版本数可以自定义，当超过设置的版本数时，新的版本会替换掉最早的版本。

### （3）表和Region ###

一个HBase集群中维护着多张表，每张表可能包含非常多的行，在单台机器上无法全部存储，HBase会将一张数据表按行键的值范围横向划分为多个子表，实现分布式存储，如图5-1所示。这些子表，在HBase中被称作“Region”，Region是HBase分布式存储的基本单元。每一个Region都关联一个行键值的范围，即一个使用StartKey和EndKey描述的区间。事实上，每一个Region仅仅记录StartKey就可以了，因为它的EndKey就是下一个Region的StartKey。

每张表最开始值包含一个Region，随着表中数据的不断增大，Region中的行数超过一定阈值时就会分裂为两个新的Region。

Region分为元数据Region以及用户Region（User Region）两类。用户Region用于存储普通数据，元数据Region包括.META.表和-ROOT-表，用于存储Region的位置信息。.META.表记录了每一个用户Region的路由信息，用户可以通过.META.表查询到要访问的Region所在的HRegionServer，从而与其建立通信进行数据操作。.META.表的路由信息存储在-ROOT-表中，-ROOT-表不可被分割，只有一个Region。用户可以通过访问ZooKeeper服务器来获得-ROOT-表的位置。Region的划分如下图：

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_11_color_FFFFFF_t_70_g_se_x_16][]

从HBase0.96.0开始，-ROOT-表的设置已被移除，.META.表改名为hbase：meta，hbase：meta的位置信息直接保存在ZooKeeper中。

## 4.HBase的读写流程 ##

1．HBase的读流程

HBase的读流程如下： ·

客户端发起请求，与ZooKeeper服务器通信获取hbase：meta所在的HRegion Server，记为HRegionServer A；

访问HRegionServer A中的hbase：meta，hbase：meta中记载着各个User Region信息（行键范围，所在RegionServer等），通过行键查找hbase：meta获取所要读取的Region所在HRegionServer，记为HRegionServer B；

请求发送到HRegionServer B，HRegionServer B先查询MemStore，如果未查询到目标数据，则在HFile中查找； ·

查询到数据后返回到客户端。

2．HBase的写流程

HBase的写流程如下： ·

客户端发起请求，与ZooKeeper服务器通信获取hbase：meta所在HRegionServer，记为HRegionServer A；

客户端访问HRegionServer A中的hbase：meta，hbase：meta中记载着每个User Region信息（行键范围，所在RegionServer），通过行键查找hbase：meta获取本次写入操作所涉及的HRegionServer（HBase写入操作可能会涉及多个HRegionServer，在写入前HBase会对数据进行分组，分组共两步：首先将所有的记录按RegionServer划分，然后将同一RegionServer所有的记录按Region划分。每个RegionServer上的数据会一起发送，这样发送的数据中，都是已经按照Region分好组了）；

客户端按RegionServer和Region将数据打包发送到对应的HRegionServer，RegionServer将数据写入对应的Region； ·客户端发送完待写数据后，会自动等待请求处理结果，如果客户端没有捕获到任何的异常，则认为所有数据写入成功。如果全部写入失败，或者部分写入失败，客户端能够获知详细的失败Key值列表。

如下图所示，HRegionServer在写入数据时，会先将数据写入HLog中，再将需要写入的数据暂时保存在对应Region的缓存MemStore中。这样一来可以减少数据直接写入磁盘带来的写入延迟，提高写入效率；另外数据先写入HLog可以避免HRegionServer故障时造成缓存数据的丢失。

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_15_color_FFFFFF_t_70_g_se_x_16][]

达到一定预设条件时，HBase会将MemStore中的数据写入磁盘生成HFlie文件，并清空MemStore及HLog中的对应记录，这个过程称为刷盘（Flush）。

## 5.HBase的Compaction过程 ##

当随着时间的增长，业务数据不断写入到HBase集群中，HFile的数目会越来越多，那么针对同样的查询，需要同时打开的文件也就可能越来越多，从而增加了查询延时，降低查询效率。

当HFile文件过多时，HBase就会启动一个Compation的操作。Compaction的主要目的，是为了减少同一个Region同一个列族下面的小文件数目，从而提升读取的性能。

如下图所示，Compaction分为Minor、Major两类。

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_20_color_FFFFFF_t_70_g_se_x_16 1][]

Minor：小范围的Compaction。Minor Compation有最少和最大文件数目限制，默认最少选择3个HFile，最多10个，通常会选择一些连续时间范围的小文件进行合并。Minor Compaction选取文件时，遵循一定的算法。

Major：Major Compaction会将一个Region中的某个ColumnFamily下面所有的HFile合并成一个HFile。HBase默认一天进行一次Major Compaction。Major Compaction过程中，会清理被删除的数据。

# 二、基于Hadoop HA集群的HBase环境安装配置 #

## 1.下载HBase ##

> 官网下载：[Index of /dist/hbase][Index of _dist_hbase]
> 
> 版本：hbase-1.4.13-bin.tar.gz

hadoop版本对应的HBase版本可以参考下表，自行选择下载：

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_20_color_FFFFFF_t_70_g_se_x_16 2][] **补充：**我使用的是hadoop-2.7.3版本，故下载hbase-1.4.13的版本。

## 2.解压安装配置 ##

说明：该HBase环境是在基于Zookeeper的Hadoop HA的基础上搭建的。

基于Zookeeper的Hadoop HA搭建请查看：[（超详细）基于Zookeeper的Hadoop HA集群的搭建\_JunLeon的博客-CSDN博客][Zookeeper_Hadoop HA_JunLeon_-CSDN]

### （1）上传到虚拟机中指定的opt目录下 ###

可通过XShell或者其他远程连接工具上传，上传过程略

### （2）解压HBase ###

tar -zxvf /opt/hbase-1.4.13-bin.tar.gz -C /opt/

### （3）配置环境及其相关属性 ###

1.配置HBase的环境变量

vi  /etc/profile

在该文件的最后添加HBase的安装路径

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_20_color_FFFFFF_t_70_g_se_x_16 3][]

使配置文件生效：

source /etc/profile

2.配置$\{HBASE\_HOME\}/conf/hbase-env.sh文件

vi ${HBASE_HOME}/conf/hbase-env.sh

在27行，配置jdk路径：

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_20_color_FFFFFF_t_70_g_se_x_16 4][]

注释46、47行，如果使用jdk1.8，则需要注释掉

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_20_color_FFFFFF_t_70_g_se_x_16 5][]

128行，设置是否启动HBase自带的zookeeper

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_20_color_FFFFFF_t_70_g_se_x_16 6][]

3.配置$\{HBASE\_HOME\}/conf/hbase-site.xml文件

<configuration>
    	<property>
    		
    		<name>hbase.rootdir</name>
    		<value>hdfs://mycluster/data/hbase_db</value>
    	</property>
    	<property>
    		
    		<name>hbase.cluster.distributed</name>
    		<value>true</value>
    	</property>
    	<property>
    		<name>dfs.support.append</name>
    		<value>true</value>
    	</property>
    	<property>
    		<name>hbase.zookeeper.quorum</name>
    		<value>BigData01,BigData02,BigData03</value>
    	</property>
    	<property>
    		
    		<name>hbase.zookeeper.property.datadir</name>
    		<value>/opt/zookeeper-3.4.12</value>
    	</property>
    	<property>
    		<name>hbase.zookeeper.property.clientPort</name>
    		<value>2181</value>
    	</property>
    </configuration>

4.配置$\{HBASE\_HOME\}/conf/regionservers文件

BigData01
    BigData02
    BigData03

## 3.启动HBase集群 ##

在开启HBase集群之前应先将HDFS和YARN节点开启

start-all.sh    # 在主节点上执行

再启动HBase集群节点

start-hbase.sh    # 在主节点上执行

## 4.查看进程及HBase集群信息 ##

jps    # 查看开启的守护进程

Web端访问：(在主机Master上执行)

> IP:16010 例如：192.168.182.10:16010

# 三、HBase的Shell命令 #

## 1.基本Shell命令 ##

（1）启动shell命令（进入HBase命令环境）

[root@BigData01 ~]# hbase shell

如下图所示即进入HBase命令环境中：

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_20_color_FFFFFF_t_70_g_se_x_16 7][]

（2）查看HBase状态

hbase(main):001:0> status

（3）查看版本

hbase(main):002:0> version

（4）获得帮助

hbase(main):003:0> help

（5）退出shell命令

hbase(main):004:0> exit

## 2.DDL操作命令 ##

DDL即数据定义语言：

（1）创建表

create  '表名','列族1','列族2'
    # 例如：	create  ‘student’,’address’,’info’

（2）以列表的形式显示所有表

list

（3）查看表的结构

desc  '表名'
    # 例如： desc  'student'

（4）修改表的结构

disable  '表名'     # 设置表为不可用的状态
    alter  '表名',NAME＝>'列族名'    # 添加列族
    alter  '表名',NAME＝>'cf3',METHOD＝>'delete'   # 删除列族
    
    # 例如：    
    # disable  'student'   —— 设置student为不可用状态      
    # alter  'student',NAME＝>'cf3'  ——  添加列族cf3
    # alter  'student',NAME＝>'cf3',METHOD＝>'delete'  ——  删除列族cf3

（5）查询表是否存在

exists  '表名'
    # 例如：    exists   'student'

（6）判断表是否可用或者不可用

is_eabled  '表名'    # 判断表是否可用
    is_disabled  '表名'    # 判断表是否不可用

（7）删除表

disable  '表名'     # 设置表为不可用的状态
    drop  '表名'    # 删除指定表

## 3.DML操作命令 ##

**DML即数据操作语言：**

> 首先， 假设student 表的列族为address \{ province、city\}、info \{ height、weight、birthday、telephone\}、'row key' 为姓名(也可根据需要设学号为row key)

（1）插入记录数据

> 格式：put '表名','row key','列族:列','列的值'

put  'student','zhangsan','address:province','guizhou'
    put  'student','zhangsan','address:city','guiyang'
    put  'student','zhangsan','info:height','180'
    put  'student','zhangsan','info:birthday','2000-01-01'
    put  'student','zhangsan','info:telephone','18888888888'

（2）获取一条数据

> 格式：get '表名','row key'

get  'student','zhangsan'

（3）获取一个ID（row key）的一个列族所有数据

> 格式：get '表名','row key','列族'

get  'student','zhangsan','info'

（4）更新一条记录

> 格式：get '表名','row key','列族:列'

get  'student','zhangsan','info:height'

（5）更新一条数据

> 格式：put '表名','row key','列族:列','列新的值'

put  'student','zhangsan','info:height','190'

（6）读出表数据

> scan '表名'

scan  'student'

（7）查询表有多少行

> count '表名'

count  'student'

（8）将表清空

> truncate '表名'

truncate  'student'

（9）删除某ID（row key）的某列的值

> 格式：delete '表名','row key','列族:列'

delete  'student','zhangsan','info:height'

## 4.运行HBase Shell脚本 ##

可以将操作命令写入文件中，当成HBase Shell脚本，再在Linux shell命令下执行该脚本。

比如：在Linux文件系统中创建一个脚本testHBaseData.sh，再在Linux Shell命令下执行：

vi testHBaseData.sh，在脚本文件中添加如下内容：

> put 'student','lisi','address:province','guizhou'  
> put 'student','lisi','address:city','guiyang'  
> put 'student','lisi','info:height','185'  
> put 'student','lisi','info:birthday','1995-01-01'  
> put 'student','lisi','info:telephone','18899999999'

执行脚本文件：

hbase shell testHbaseData.sh

# 四、HBase基础编程 #

## 1.HBase API ##

（1）HBaseConfiguration类

> 该类在hbase-common-1.4.13.jar 里，包名为org.apach.hadoop.hbase，该类是客户端必须使用的。 它从hbase-default.xml和hbase-site.xml文件中获取配置信息，编程时使用如下语句进行初始化配置文件：  
> Configuration config = HBaseConfiguration.create();

（2）ConnectionFactory类和Connection接口

> 该类和接口在hbase-common-1.4.13.jar 里，包名为org.apach.hadoop.hbase.client，用来通过配置连接HBase 集群，即建立连接，提高连接接口。 编程时使用如下语句：  
> Connection connection = ConnectionFactory.createConnection(config)

（3）HBaseAdmin类和Admin接口

> 该类和接口在hbase-client-1.4.13.jar 里，包名为org.apach.hadoop.hbase.client，封装了对数据表结构的操作的接口，提供的方法有：创建表、删除表、列出表项、使表有效或者无效、添加或者删除表列族成员。

（4）HTableDescriptor类

> 该类在hbase-client-1.4.13.jar 里，包名为org.apach.hadoop.hbase。HTableDescriptor类封装了表的相关属性及操作接口。

（5）HColumnDescriptor类

> 该类在hbase-client-1.4.13.jar 里，包名为org.apach.hadoop.hbase。HColumnDescriptor类维护列族的相关信息。

（6）HTable类和Table接口

> 该类和接口在hbase-client-1.4.13.jar 里，包名为org.apach.hadoop.hbase.client，HTable类与HBase表直接通信,编程时不推荐使用HTable 类， 建议直接使用Table 接口， 使用如下语句获得Table 接口变量:  
> TableName tableName = TableName.valueOf("表名");  
> Table table = connection.getTable(tableName);

（7）Put类

> 该类在hbase-client-1.4.13.jar 里，包名为org.apach.hadoop.hbase.client，Put类用来对单行数据的添加操作。

（8）Get类

> 该类在hbase-client-1.4.13.jar 里，包名为org.apach.hadoop.hbase.client，Get类用于获取单行数据的相关信息。

（9）Scan类

> 该类在hbase-client-1.4.13.jar 里，包名为org.apach.hadoop.hbase.client，用于对表进行检索

（10）ResultScanner类

> 该类在hbase-client-1.4.13.jar 里，包名为org.apach.hadoop.hbase.client，该类提供了客户端获取值得接口。

（11）Result类

> 该类在hbase-client-1.4.13.jar 里，包名为org.apach.hadoop.hbase.client

（12）Delete类

> 该类在hbase-client-1.4.13.jar 里，包名为org.apach.hadoop.hbase.client

（13）TableName类

> 该类在hbase-common-1.4.13.jar 里，包名为org.apach.hadoop.hbase

（14）Cell类和CellUtil类

> 该类在hbase-common-1.4.13.jar 里，包名为org.apach.hadoop.hbase

## 2.HBase API编程代码演示 ##

> 下面通过示例介绍使用Java 语言编程来操作HBase 中的表及数据，编程时必需的最少  
> jar 包为hadoop-common-2.x.x.jar、hbase-common-1.4.13.jar、hbase-client-1.4.13.jar  
> ①打开Eclipse 编程工具,并建立Java工程MyHBaseUtil；
> 
>   
> ②新建lib 目录, 将Hbase 编程所需的jar 包拷贝到lib 目录下, 并加入buildpath；
> 
>   
> ③新建Class文件， 比如: HBASEUtil 类， 并在该类中编写针对HBase 操作的方法， 为  
> 了测试在本类中添加入口主方法main()， 使用HBASEUtil 操作数据；
> 
>   
> ④将本工程导出生成jar 包文件(指定主类)， 导出生成jar 包文件的方法：  
> 选择Eclipse的菜单File→Export， 接着选Java 下的Jar File，点击“Next”， 勾选当前工程(比如:MyHBaseUtil)， 此时默认选中当前工程下的src和lib 目录,接下来勾选“Export all output folders for checked projects”，导出所有输出文件夹， 在选项Options中勾选“Compress the contents of the of JAR file” “ add directory entries”， 在“ Select the export destination:”中输入JAR file 存储位置及文件名(比如: MyHBaseUtil.jar)，最后点击“Finish”即可！
> 
> ⑤ 将导出的jar 文件上传到服务器BigData01中，再使用命令：
> 
>     hadoop jar MyHBaseUtil.jar hadoop.hbase.HBaseUtil
> 
> 运行程序(需要保证已经启动运行了HBase集群)， 假设出现Zookeeper连接错误， 则将程序代码中注释下面几行：
> 
> //conf.set("hbase.zookeeper.quorum", "BigData01:2181, BigData02:2181, BigData03:2181");  
> //conf.set("hbase.zookeeper.quorum", "BigData01, BigData02, BigData03");  
> //conf.set("hbase.zookeeper.property.clientPort", "2181");

参考代码如下：

package hadoop.hbase;
    
    import java.io.IOException;
    
    import org.apache.hadoop.conf.Configuration;
    import org.apache.hadoop.hbase.HBaseConfiguration;
    import org.apache.hadoop.hbase.HColumnDescriptor;
    import org.apache.hadoop.hbase.HTableDescriptor;
    import org.apache.hadoop.hbase.KeyValue;
    import org.apache.hadoop.hbase.MasterNotRunningException;
    import org.apache.hadoop.hbase.TableName;
    import org.apache.hadoop.hbase.ZooKeeperConnectionException;
    import org.apache.hadoop.hbase.client.Admin;
    import org.apache.hadoop.hbase.client.Append;
    import org.apache.hadoop.hbase.client.Delete;
    import org.apache.hadoop.hbase.client.Get;
    import org.apache.hadoop.hbase.client.HBaseAdmin;
    import org.apache.hadoop.hbase.client.HTable;
    import org.apache.hadoop.hbase.client.Increment;
    import org.apache.hadoop.hbase.client.Put;
    import org.apache.hadoop.hbase.client.Result;
    import org.apache.hadoop.hbase.client.ResultScanner;
    import org.apache.hadoop.hbase.client.Scan;
    import org.apache.hadoop.hbase.client.Table;
    import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
    import org.apache.hadoop.hbase.filter.Filter;
    import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
    import org.apache.hadoop.hbase.util.Bytes;
    
    public class HBaseUtil {
    	private static Configuration conf = null;
    	static {
    		conf = HBaseConfiguration.create();
    		//conf.set("hbase.zookeeper.quorum", "BigData01:2181, BigData02:2181, BigData03:2181");
    		//conf.set("hbase.zookeeper.quorum", "BigData01, BigData02, BigData03");
    		//conf.set("hbase.zookeeper.property.clientPort", "2181");
    		System.out.println("---Static Code Loaded. Configuration: " + conf.toString());
    	}
    	
    	public static void main(String[] args) {
    		String tableName = "goods"; 
    		String[] familys = {"baseinfo", "otherinfo"};
    		try {
    			System.out.println("===Test Beginning: Creat table " + tableName);
    			HBaseUtil.deleteTable(tableName);
    			HBaseUtil.createTable(tableName, familys);
    			HBaseUtil.addData(tableName, "000001", familys[0], "name", "创维电视机");
    			HBaseUtil.getOneRow(tableName, "000001");
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	/**
    	 * 创建表
    	 * @param tableName
    	 * @param familys
    	 * @throws MasterNotRunningException
    	 * @throws ZooKeeperConnectionException
    	 * @throws IOException
    	 */
    	public static void createTable(String tableName, String[] familys) throws MasterNotRunningException, ZooKeeperConnectionException, IOException{
    		HBaseAdmin admin = new HBaseAdmin(conf);
    		if(admin.tableExists(tableName)){
    			System.out.println("---CreateTable: table " + tableName + " already exists!");
    		}else{
    			HTableDescriptor tableDesc = new HTableDescriptor(tableName);
    			for(int i=0; i<familys.length; i++){
    				tableDesc.addFamily(new HColumnDescriptor(familys[i]));
    			}
    			admin.createTable(tableDesc);
    			System.out.println("---CreateTable: create table " + tableName + " success!");
    		}
    	}
    	
    	// 删除表
    	public static void deleteTable(String tableName)
    			throws MasterNotRunningException, ZooKeeperConnectionException, IOException {
    		HBaseAdmin admin = new HBaseAdmin(conf);
    		if (admin.tableExists(tableName)) {
    			admin.disableTable(tableName);
    			admin.deleteTable(tableName);
    			System.out.println("---DeleteTable: delete table " + tableName + " success!");
    		} else {
    			System.out.println("---DeleteTable: " + tableName + " not exists!");
    		}
    	}
    
    	/**
    	 * 插入数据
    	 * @param tableName
    	 * @param rowKey
    	 * @param family
    	 * @param qualifier
    	 * @param value
    	 */
    	public static void addData(String tableName, String rowKey, String family, String qualifier, String value){
    		try {
    			HTable table = new HTable(conf, tableName);
    			Put put = new Put(Bytes.toBytes(rowKey));
    			put.add(Bytes.toBytes(family), Bytes.toBytes(qualifier), Bytes.toBytes(value));
    			table.put(put);
    			System.out.println("insert record success!");
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    	
    	/**
    	 * 删除数据
    	 * @param tableName
    	 * @param rowKey
    	 * @throws IOException 
    	 */
    	public static void deleteRow(String tableName, String rowKey) throws IOException{
    		HTable table = new HTable(conf, tableName);
    		Delete deleteRow = new Delete(rowKey.getBytes());
    		table.delete(deleteRow);
    		System.out.println("delete row " + rowKey + " success!");
    	}
    	
    	/**
    	 * 删除一行中某列
    	 * @param tableName
    	 * @param rowKey
    	 * @param familyName
    	 * @param columnName
    	 * @throws IOException 
    	 */
    	public static void deleteColumn(String tableName, String rowKey, String familyName, String columnName) throws IOException{
    		HTable table = new HTable(conf, tableName);
    		Delete deleteColumn = new Delete(Bytes.toBytes(rowKey));
    		deleteColumn.deleteColumn(Bytes.toBytes(familyName), Bytes.toBytes(columnName));
    		table.delete(deleteColumn);
    		System.out.println("delete " + rowKey + ":" + familyName + ":" + columnName + " success!");
    	}
    	
    	/**
    	 * 添加数据
    	 * @param tableName
    	 * @param rowKey
    	 * @param family
    	 * @param qualifier
    	 * @param value
    	 * @throws IOException 
    	 */
    	public static void appendData(String tableName, String rowKey, String family, String qualifier, String value) throws IOException {
    		HTable table = new HTable(conf, tableName);
    		Append append = new Append(Bytes.toBytes(rowKey));
    		append.add(Bytes.toBytes(family), Bytes.toBytes(qualifier), Bytes.toBytes(value));
    		table.append(append);
    		System.out.println("append data success!");
    	}
    	
    	/**
    	 * 增长数据
    	 * @param tableName
    	 * @param rowKey
    	 * @param family
    	 * @param qualifier
    	 * @param amount
    	 * @throws IOException 
    	 */
    	public static void incrementData(String tableName, String rowKey, String family, String qualifier, long amount) throws IOException {
    		HTable table = new HTable(conf, tableName);
    		Increment increment = new Increment(Bytes.toBytes(rowKey));
    		increment.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier), amount);
    		table.increment(increment);
    		System.out.println("increment data success!");
    	}
    	
    	/**
    	 * 读取数据
    	 * @param tableName
    	 * @param rowKey
    	 * @throws IOException
    	 */
    	public static void getOneRow(String tableName, String rowKey) throws IOException{
    		HTable table = new HTable(conf, tableName);
    		Get get = new Get(rowKey.getBytes());	//设置rowKey
    		Result result = table.get(get);
    		//打印结果
    		for(KeyValue kv : result.raw()){
    			System.out.println("\trow: " + new String(kv.getRow()) + " ");
    			System.out.println("\tfamily: " + new String(kv.getFamily()) + " ");
    			System.out.println("\tqualifier: " + new String(kv.getQualifier()) + " ");
    			System.out.println("\ttimestamp: " + kv.getTimestamp() + " ");
    			System.out.println("\tvalue: " + new String(kv.getValue()) + " ");
    		}
    	}
    	
    	/**
    	 * 扫描数据
    	 * @param tableName
    	 * @param startRow
    	 * @param stopRow
    	 * @throws IOException
    	 */
    	public static void scanRows(String tableName, String startRow, String stopRow) throws IOException{
    		HTable table = new HTable(conf, tableName);
    		//在scan中指定startRow和stopRow
    		Scan scan = new Scan(startRow.getBytes(), stopRow.getBytes());
    		ResultScanner resultS = table.getScanner(scan);
    		//打印扫描结果
    		for(Result result : resultS){
    			for(KeyValue kv : result.raw()){
    				System.out.println("\trow: " + new String(kv.getRow()) + " ");
    				System.out.println("\tfamily: " + new String(kv.getFamily()) + " ");
    				System.out.println("\tqualifier: " + new String(kv.getQualifier()) + " ");
    				System.out.println("\ttimestamp: " + kv.getTimestamp() + " ");
    				System.out.println("\tvalue: " + new String(kv.getValue()) + " ");
    			}
    		}
    	}
    	
    	public static void scanByFilter(String tableName, String family, String qualifier, String value) throws IOException{
    		HTable table = new HTable(conf, tableName);
    		Scan scan = new Scan();
    		scan.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
    		Filter filter = new SingleColumnValueFilter(Bytes.toBytes(family), Bytes.toBytes(qualifier), CompareOp.EQUAL, Bytes.toBytes(value));
    		//在scan中设置filter
    		scan.setFilter(filter);
    		ResultScanner resultS = table.getScanner(scan);
    		//打印扫描结果
    		for(Result result : resultS){
    			System.out.println("row: " + new String(result.getRow()));
    			for(KeyValue kv : result.raw()){
    				System.out.println("\tfamily: " + new String(kv.getFamily()));
    				System.out.println("\tqualifier: " + new String(kv.getQualifier()));
    				System.out.println("\ttimestamp: " + kv.getTimestamp() + " ");
    				System.out.println("\tvalue: " + new String(kv.getValue()));
    			}
    		}
    	}
    
    }

下一篇：数据仓库Hive的实战（超详细）

如果你喜欢、对你有帮助，点赞+收藏，跟着军哥学知识……

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_19_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/b53c3633aa3a4113acdc0c98aa8fee2b.jpg?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U=,size_19,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/a9f5dd188b8d4c139c712808bdc1bcd5.jpg?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U=,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_11_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/400ef86ae5e34289ad709029255b8d9b.jpg?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U=,size_11,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_15_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/807192fc3c5b4224bda64689b684042e.jpg?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U=,size_15,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/d4c6bd97bc5d4c9badfa08e076b969d6.jpg?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U=,size_20,color_FFFFFF,t_70,g_se,x_16
[Index of _dist_hbase]: https://archive.apache.org/dist/hbase/
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/1801a3cd935444bfad4deb6b1ea4d2c1.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U=,size_20,color_FFFFFF,t_70,g_se,x_16
[Zookeeper_Hadoop HA_JunLeon_-CSDN]: https://blog.csdn.net/JunLeon/article/details/120689889
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://img-blog.csdnimg.cn/ac40fa3c3882460f8e175a3b61ef9285.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U=,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_20_color_FFFFFF_t_70_g_se_x_16 4]: https://img-blog.csdnimg.cn/e4c737a7773e4f40a5d55e97d12c7dca.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U=,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_20_color_FFFFFF_t_70_g_se_x_16 5]: https://img-blog.csdnimg.cn/6d536fc7f111471795bcd0ddfe4c45b1.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U=,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_20_color_FFFFFF_t_70_g_se_x_16 6]: https://img-blog.csdnimg.cn/a0f23d5ce1954ba98e836625ea558a5d.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U=,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_20_color_FFFFFF_t_70_g_se_x_16 7]: https://img-blog.csdnimg.cn/03beabc75dc44663841af7ba99bbc02a.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U=,size_20,color_FFFFFF,t_70,g_se,x_16