因为工作需要使用 HBase，因此调研了 HBase 相关的内容。本文的写作目的不仅仅是对前期工作的总结，也希望能帮助到工作繁忙但又想了解 HBase 的同学。在本文写作过程中，将穿插 MySQL 相关内容，希望能帮助理解 HBase 。

本文主要讨论以下几个问题，所述内容仅为个人思考，见解有限，有误之处还望批评指正。

HBase 是什么？其架构是怎样的？
HBase 如何管理数据？
HBase 是分布式数据库，那数据怎么路由？
HBase 的适用场景？
HBase 和 MySQL 的主要区别？
HBase 怎么用？如何实现 CREATE、INSERT、SELECT、UPDATE、DELETE、LIKE 操作？

1 HBase

1.1 HBase 架构

HBase 是什么？其架构是怎样的？

HBase（Hadoop DataBase），是一种非关系型分布式数据库（NoSQL），支持海量数据存储（官方：单表支持百亿行百万列）。HBase 采用经典的主从架构，底层依赖于 HDFS，并借助 ZooKeeper 作为协同服务，其架构大致如下：

其中，

Master：HBase 管理节点。管理 Region Server，分配 Region 到 Region Server，提供负载均衡能力；执行创建表等 DDL 操作。
Region Server：HBase 数据节点。管理 Region，一个 Region Server 可包含多个 Region，Region 相当于表的分区。客户端可直接与 Region Server 通信，实现数据增删改查等 DML 操作。
ZooKeeper：协调中心。负责 Master 选举，节点协调，存储 hbase:meta 等元数据。
HDFS：底层存储系统。负责存储数据，Region 中的数据通过 HDFS 存储。

对 HBase 全局有了基本理解后，我认为有几个比较重要的点值得关注：HBase 数据模型、Region 的概念、数据路由。

1.2 HBase 数据模型

HBase 如何管理数据？（逻辑层）

HBase 的数据模型和 MySQL 等关系型数据库有比较大的区别，其是一种 ”Schema-Flexiable“ 的理念。

在表的维度，其包含若干行，每一行以 RowKey 来区分。
在行的维度，其包含若干列族，列族类似列的归类，但不只是逻辑概念，底层物理存储也是以列族来区分的（一个列族对应不同 Region 中的一个 Store）。
在列族的维度，其包含若干列，列是动态的。与其说是列，不如说是一个个键值对，Key 是列名，Value 是列值。

HBase 的表结构如下：

RowKey（行键）：RowKey 是字典有序的，HBase 基于 RowKey 实现索引；
Column Family（列族）：纵向切割，一行可有多个列族，一个列族可有任意个列；
Key-Value（键值对）：每一列存储的是一个键值对，Key 是列名，Value 是列值；
Byte（数据类型）：数据在 HBase 中以 Byte 存储，实际的数据类型交由用户转换；
Version（多版本）：每一列都可配置相应的版本，获取指定版本的数据（默认返回最新版本）；
稀疏矩阵：行与行之间的列数可以不同，但只有实际的列才会占用存储空间。

1.3 Region

HBase 如何管理数据？（物理层）

Region 是 HBase 中的概念，类似 RDBMS 中的分区。

Region 是表的横向切割，一个表由一个或多个 Region 组成，Region 被分配到各个 Region Server；
一个 Region 根据列族分为多个 Store，每个 Store 由 MemStore 和 StoreFile 组成；数据写入 MemStore，MemStore 类似输入缓冲区，持久化后为 StoreFile；数据写入的同时会更新日志 WAL，WAL 用于发生故障后的恢复，保障数据读写安全；
一个 StoreFile 对应一个 HFile，HFile 存储在 HDFS 。

下面是我梳理的大致模型：

1）Region 是一个 RowKey Range

每个 Region 实际上是一个 RowKey Range，比如 Region A 存放的 RowKey 区间为 [aaa,bbb)，Region B 存放的 RowKey 区间为 [bbb,ccc) ，以此类推。Region 在 Region Server 中存储也是有序的，Region A 必定在 Region B 前面。

注：这里将 RowKey 设计为 aaa，而不是 1001 这样的数字，是为了强调 RowKey 并非只能是数字，只要能进行字典排序的字符都是可以的，如：abc-123456 。

2）数据被路由到各个 Region

表由一个或多个 Region 组成（逻辑），Region Server 包含一个或多个 Region（物理）。数据的路由首先要定位数据存储在哪张表的哪个 Region，表的定位直接根据表名，Region 的定位则根据 RowKey（因为每个 Region 都是一个 RowKey Range，因此根据 RowKey 很容易知道其对应的 Region）。

注：Master 默认采用 DefaultLoadBalancer 策略分配 Region 给 Region Server，类似轮询方式，可保证每个 Region Server 拥有相同数量的 Region（这里只是 Region 的数量相同，但还是有可能出现热点聚集在某个 Region，从而导致热点聚集在某个 Region Server 的情况）。

3）当一个表太大时，Region 将自动分裂

自动分裂

0.94 版本之前，Region 分裂策略为 ConstantSizeRegionSplitPolicy ，根据一个固定值触发分裂。

0.94 版本之后，分裂策略默认为 IncreasingToUpperBoundRegionSplitPolicy，该策略会根据 Region 数量和 StoreFile 的最大值决策。当 Region 的数量小于 9 且 StoreFile 的最大值小于某个值时，分裂 Region；当Region数量大于9 时，采用 ConstantSizeRegionSplitPolicy 。

手动分裂

在 ConstantSizeRegionSplitPolicy 下，通过设置 hbase.hregion.max.filesize 控制 Region 分裂。

1.4 数据路由 hbase:meta

HBase 是分布式数据库，那数据怎么路由？

数据路由借助 hbase:meta 表完成，hbase:meta 记录的是所有 Region 的元数据信息，hbase:meta 的位置记录在 ZooKeeper 。

注：一些比较老的文章可能会提到 .root 和 .meta 两个表。事实上， .root 和 .meta 两个表是 HBase 0.96 版本之前的设计。在 0.96 版本后，.root 表已经被移除，.meta 表更名为 hbase：meta。

hbase:meta 表的格式如下：

其中，

table：表名；
region start key：Region 中的第一个 RowKey，如果 region start key 为空，表示该 Region 是第一个 Region；
region id：Region 的 ID，通常是 Region 创建时的 timestamp；
regioninfo：该 Region 的 HRegionInfo 的序列化值；
server：该 Region 所在的 Region Server 的地址；
serverstartcode：该 Region 所在的 Region Server 的启动时间。

一条数据的写入流程：

数据写入时需要指定表名、Rowkey、数据内容。

HBase 客户端访问 ZooKeeper，获取 hbase:meta 的地址，并缓存该地址；
访问相应 Region Server 的 hbase:meta；
从 hbase:meta 表获取 RowKey 对应的 Region Server 地址，并缓存该地址；
HBase 客户端根据地址直接请求 Region Server 完成数据读写。

注 1：数据路由并不涉及Master，也就是说 DML 操作不需要 Master 参与。借助 hbase:meta，客户端直接与 Region Server 通信，完成数据路由、读写。

注 2：客户端获取 hbase:meta 地址后，会缓存该地址信息，以此减少对 ZooKeeper 的访问。同时，客户端根据 RowKey 查找 hbase:meta，获取对应的 Region Server 地址后，也会缓存该地址，以此减少对 hbase:meta 的访问。因为 hbase:meta 是存放在 Region Server 的一张表，其大小可能很大，因此不会缓存 hbase:meta 的完整内容。

1.5 HBase 适用场景

不需要复杂查询的应用。HBase 原生只支持基于 RowKey 的索引，对于某些复杂查询（如模糊查询，多字段查询），HBase 可能需要全表扫描来获取结果。
写密集应用。HBase 是一个写快读慢（慢是相对的）的系统。HBase 是根据 Google 的 BigTable 设计的，典型应用就是不断插入新数据（如 Google 的网页信息）。
对事务要求不高的应用。HBase 只支持基于 RowKey 的事务。
对性能、可靠性要求高的应用。HBase 不存在单点故障，可用性高。
数据量特别大的应用。HBase 支持百亿行百万列的数据量，单个 Region 过大将自动触发分裂，具备较好的伸缩能力。

2 HBase 与 MySQL 的区别？

HBase 和 MySQL 的主要区别？

2.1 MySQL

MySQL 表结构规整，每一行有固定的列。

创建表时，需要指定表名，预设字段（列）个数以及数据类型，Schema 是固定的。
插入数据时，只需根据表的 Schema 填充每个列的值即可。如果 Schema 没有该列，则无法插入。

2.2 HBase

HBase 支持动态列，不同行可拥有不同数量的列，可动态增加新的列。HBase 的表结构看起来杂乱无章，但却有利于存储稀疏数据。

创建表时，需指定表名、列族，无需指定列的个数、数据类型，Schema 是灵活的。
插入数据时，需要指定表名、列族、RowKey、若干个列（列名和列值），这里列的个数可以是一个或多个。

2.3 对比

进一步，假设 ct_account_info_demo 表中只有一条记录（account_id = 1，account_owner = Owner1，account_amount = 23.0，is_deleted = n），分别通过 MySQL 和 HBase 查找该记录。

MySQL 返回的结果：

mysql> select * from ct_account_info_demo;
+------------+---------------+----------------+------------+
| account_id | account_owner | account_amount | is_deleted |
+------------+---------------+----------------+------------+
|     1      |     Owner1    |      23.0      |     n      |
+------------+---------------+----------------+------------+
1 rows in set (0.01 sec)

HBase 返回的结果：

hbase(main):001:0> scan 'ct_account_info_demo';
ROW           COLUMN+CELL
 1            column=CT:account_amount, timestamp=1532502487735, value=23.0
 1            column=CT:account_id, timestamp=1532909576152, value=1
 1            column=CT:account_owner, timestamp=1532502487528, value=Owner1
 1            column=CT:is_deleted, timestamp=1532909576152, value=n

上述结果都表示一行数据，MySQL 的返回结果比较直观，容易理解。

HBase 返回的结果其实是多个键值对，ROW 表示数据的 RowKey，COLUMN+CELL 表示该 RowKey 对应的内容。

COLUMN+CELL 中又是多个键值对，如：

column=CT:account_amount, timestamp=1532502487735, value=23.0

表示列族 CT 的列 account_amount 的值为 23.0，时间戳为 1532502487735 。

注：ROW 为 1 是因为这里 RowKey = {account_id}，CT 是提前定义的列族（HBase 在插入数据时需要指定 RowKey、Column Family）。

总的来说，

HBase 比 MySQL 多了 RowKey 和 Column Family 的概念，这里的 RowKey 类似 MySQL 中的主键，Column Family 相当于多个列的“归类”。
列族只有一个的情况下，HBase 的 Schema 和 MySQL 可以保持一致，但 HBase 允许某些字段为空或动态增加某个列，而 MySQL 只可根据 Schema 填充相应的列，不能动态增减列。
因为 HBase 的 Schema 是不固定的，所以每次插入、查找数据不像 MySQL 那么简洁，HBase 需要指定行键、列族、列等信息。

更为详细的对比如下表（引自：HBase 深入浅出）：

	RDBMS	HBase
硬件架构	传统的多核系统，硬件成本昂贵	类似于 Hadoop 的分布式集群，硬件成本低廉
容错性	一般需要额外硬件设备实现 HA 机制	由软件架构实现，因为多节点，所以不担心单点故障
数据库大小	GB、TB	PB
数据排布	以行和列组织	稀疏的、分布的、多维的 Map
数据类型	丰富的数据类型	Bytes
事务支持	全面的 ACID 支持，支持 Row 和表	ACID 只支持单个 Row 级别
查询语言	SQL	只支持 Java API （除非与其他框架一起使用，如 Phoenix、Hive）
索引	支持	只支持 Row-key（除非与其他技术一起应用，如 Phoenix、Hive）
吞吐量	数千查询/每秒	百万查询/每秒

3 HBase 相关操作（CRUD）

HBase 怎么用？如何实现 CREATE、INSERT、SELECT、UPDATE、DELETE、LIKE 操作？

为便于理解，结合 MySQL 说明 HBase 的 DML 操作，演示如何使用 HBase 来实现 MySQL 的 CREATE、 INSERT、SELECT、UPDATE、DELETE、LIKE 操作。

为方便代码复用，这里提前封装获取 HBase 连接的代码：

// 获取HBase连接
public Connection getHBaseConnect() throws IOException {
	// 配置
    Configuration conf = HBaseConfiguration.create();
    conf.set("hbase.zookeeper.quorum", "127.0.0.1");
    conf.set("hbase.zookeeper.property.clientPort", "2181");
    conf.set("log4j.logger.org.apache.hadoop.hbase", "WARN");
    // 创建连接
    Connection connection = ConnectionFactory.createConnection(conf);
    return connection;
}

3.0 CREATE

// 创建表
public void createTable (String tableName,String columnFamily)  {
	try {
	// 获取连接，DDL操作需要获取Admin
        Connection hbaseConnect = hbase.getHBaseConnect();
        Admin admin = hbaseConnect.getAdmin();
        // 设置表名
        HTableDescriptor tableDescriptor = new HTableDescriptor(TableName.valueOf(tableName));
        // 设置列族
        tableDescriptor.addFamily(new HColumnDescriptor(columnFamily));
        // 创建表
        admin.createTable(tableDescriptor);
    } catch (IOException e) {
    	e.printStackTrace();
    }
}

3.1 INSERT

MySQL：

INSERT INTO ct_account_info_demo(account_id, account_owner , account_amount, is_deleted ) VALUES (?,?,?,?)

HBase 实现上述 SQL 语句的功能：

// 插入数据
public int insertAccount(Long accountId, String accountOwner, BigDecimal accountAmount) {
    String tableName = "ct_account_info_demo";		// 表名
    // 行键（为便于理解，这里将accountID作为RowKey，实际应用中RowKey的设计应该重点考虑）
    String rowKey = String.valueOf(accountId);
    String familyName = "account_info";				// 列族（在创建表时已定义）
    Map<String,String> columns = new HashMap<>();	 // 多个列
    columns.put("account_id",String.valueOf(accountId));
    columns.put("account_owner",accountOwner);
    columns.put("account_amount",String.valueOf(accountAmount));
    columns.put("is_deleted","n");
    updateColumnHBase(tableName,rowKey,familyName,columns);	// 更新HBase数据
    return 0;
}

private void updateColumnHBase(String tableName, String rowKey, String familyColumn, Map<String,String> columns) {
    try {
        Connection hbaseConnect = hbase.getHBaseConnect();	        // 获取HBase连接
        Table table = hbaseConnect.getTable(TableName.valueOf(tableName));   // 获取相应的表
        Put put = new Put(Bytes.toBytes(rowKey));	        		// 封装Put对象
        for (Map.Entry<String, String> entry : columns.entrySet()) {
            put.addColumn(Bytes.toBytes(familyColumn), Bytes.toBytes(entry.getKey()),
            Bytes.toBytes(entry.getValue()));
        }
        table.put(put);	        // 提交数据
        table.close();
    } catch (IOException e) {
    	e.printStackTrace();
    }
}

3.2 SELECT

MySQL：

SELECT * from ct_account_info_demo WHERE account_id = #{account_id}

HBase 实现上述 SQL 语句的功能：

// 读取数据
public Account getAccountInfoByID(Long accountId) {
     Account account = new Account();
     String tableName = "ct_account_info_demo";		// 表名
     String familyName = "account_info";			// 列族
     String rowKey = String.valueOf(accountId);		// 行键
     List<String> columns = new ArrayList<>();		// 设置需要返回哪些列
     columns.add("account_id");
     columns.add("account_owner");
     columns.add("account_amount");
     columns.add("is_deleted");
     // 获取某一行指定列的数据
     HashMap<String,String> accountRecord = getColumnHBase(tableName, rowKey,familyName,columns);
     if (accountRecord.size()==0) {
     	return null;
     }
     // 根据查询结果，封装账户信息
     account.setId( Long.valueOf(accountRecord.get("account_id")));
     account.setOwner(accountRecord.get("account_owner"));
     account.setBalance(new BigDecimal(accountRecord.get("account_amount")));
     account.setDeleted(accountRecord.get("isDeleted"));
     return account;
}
 
private HashMap<String, String> getColumnHBase(String tableName, String rowKey, String familyColumn, List<String> columns) {
     HashMap<String,String> accountRecord = new HashMap<>(16);
     try {
         Connection hbaseConnect = hbase.getHBaseConnect();		// 获取HBase连接
         Table table = hbaseConnect.getTable(TableName.valueOf(tableName));	// 获取相应的表
         Get get = new Get(Bytes.toBytes(rowKey));				// 封装Get对象
         for (String column:columns) {
             get.addColumn(Bytes.toBytes(familyColumn), Bytes.toBytes(column));
         }
         Result result = table.get(get);		// 获取数据
         if (result.listCells() != null) {
             for (Cell cell : result.listCells()) {
                 String k = Bytes.toString(cell.getQualifierArray(), cell.getQualifierOffset(), cell.getQualifierLength());
                 String v = Bytes.toString(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength());
                 accountRecord.put(k,v);	// 将结果存放在map中
             }
         }
         table.close();
     } catch (IOException e) {
     e.printStackTrace();
     }
     return accountRecord;		// 返回本次查询的结果
}

3.3 UPDATE

MySQL：

UPDATE ct_account_info_demo SET account_amount = account_amount + #{transAmount} WHERE account_id = #{fromAccountId}

HBase 实现上述 SQL 语句的功能：

// 更新数据
public void transIn(Long accountId, BigDecimal accountAmount) {
    String tableName = "ct_account_info_demo";		// 表名
    String rowKey = String.valueOf(accountId);		// 行键
    String familyName = "account_info";				// 列族
    List<String> columns = new ArrayList<>();		// 获取账户信息
    columns.add("account_amount");
    HashMap<String,String> accountRecord = getColumnHBase(tableName, rowKey,familyName,columns);
    // 增加账户余额
    BigDecimal newAccountAmount = new BigDecimal(accountRecord.get("account_amount")).add(accountAmount);
    // 更新账户的余额
    Map<String,String> fromColumns = new HashMap<>(1);
    fromColumns.put("account_amount",String.valueOf(newAccountAmount));
    // 更新HBase数据
    updateColumnHBase(tableName,rowKey,familyName,fromColumns);
}

3.4 DELETE

MySQL：

DELETE FROM ct_account_info_demo WHERE account_id = ?

通过 HBase 实现上述 SQL 语句的功能：

// 删除数据
public void deleteAccount (String tableName, Long accountId) {
    try {
        Connection hbaseConnect = hbase.getHBaseConnect();
        // 行键
        String rowKey = String.valueOf(accountId);
        // 列族
        String familyName = "account_info";
        Table table = hbaseConnect.getTable(TableName.valueOf(tableName));
        Delete delete = new Delete(Bytes.toBytes(rowKey));
        // 删除该行指定列的数据
        delete.deleteColumn(Bytes.toBytes(familyName), Bytes.toBytes("account_id"));
        delete.deleteColumn(Bytes.toBytes(familyName), Bytes.toBytes("account_owner"));
        delete.deleteColumn(Bytes.toBytes(familyName), Bytes.toBytes("account_amount"));
        delete.deleteColumn(Bytes.toBytes(familyName), Bytes.toBytes("is_deleted"));
        // 删除整个列族
        //delete.deleteFamily(Bytes.toBytes(familyName));
        table.delete(delete);
        table.close();
    } catch (IOException e) {
    	e.printStackTrace();
    }
}

3.5 LIKE

MySQL：

SELECT * FROM ct_account_info_demo WHERE account_id = #{account_id} AND account_owner LIKE CONCAT('%', #{keyWord}, '%')

HBase 实现上述 SQL 语句的功能：

// 模糊查询
public Account getAccountInfoByKeyWord(Long accountId, String keyWord) {
    Account account = new Account();
    // 表名
    String tableName = "ct_account_info_demo";		
    // 起始行键（闭区间）
    String startRow = String.valueOf(accountId);	
    // 终止行键（开区间，结果不包含stopRow）
    String stopRow = String.valueOf(accountId);	
    // 列族
    String familyName = "account_info";
    // 设置需要模糊查询的列
    String targetColumn = "account_owner";
    // 设置需要返回哪些列
    List<String> columns = new ArrayList<>();
    columns.add("account_id");
    columns.add("account_owner");
    columns.add("account_amount");
    columns.add("is_deleted");
    // 模糊查询
    HashMap<String,String> accountRecord = singleColumnFilter(tableName, familyName, startRow, stopRow, targetColumn, keyWord, columns);
    if (accountRecord.size()==0) {
    	return null;
    }
    // 根据查询结果，封装账户信息
    account.setId( Long.valueOf(accountRecord.get("account_id")));
    account.setOwner(accountRecord.get("account_owner"));
    account.setBalance(new BigDecimal(accountRecord.get("account_amount")));
    account.setDeleted(accountRecord.get("isDeleted"));
    return account;
}

private HashMap<String,String> singleColumnFilter(String tableName, String familyColumn, String startRowKey, String stopRowKey, String targetColumn, String keyWord, List<String> columns) {
    if (hbase == null) {
    	throw new NullPointerException("HBaseConfig");
    }
    if (familyColumn == null || columns.size() == 0) {
    	return null;
    }
    HashMap<String,String> accountRecord = new HashMap<>(8);
    try {
        // 获取HBase连接
        Connection hbaseConnect = hbase.getHBaseConnect();
        // 获取相应的表
        Table table = hbaseConnect.getTable(TableName.valueOf(tableName));
        // 封装Scan
        Scan scan = new Scan();
        scan.setStartRow(Bytes.toBytes(startRowKey));
        scan.setStopRow(Bytes.toBytes(stopRowKey));
        // 设置查询的列
        for (String column:columns) {
            scan.addColumn(Bytes.toBytes(familyColumn), Bytes.toBytes(column));
        }
        // 定义过滤器：某一列的值是否包含关键字
        SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(Bytes.toBytes(familyColumn),Bytes.toBytes(targetColumn),CompareFilter.CompareOp.EQUAL,new SubstringComparator(keyWord));
        //ValueFilter filter = new ValueFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator(keyWord));
        FilterList list = new FilterList(FilterList.Operator.MUST_PASS_ONE,singleColumnValueFilter);
        // Scan添加过滤器
        scan.setFilter(list);
        // 获取数据
        ResultScanner resultScanner = table.getScanner(scan);
        for(Result result = resultScanner.next();result!=null;result = resultScanner.next()){
        	if (result.listCells() != null) {
            	for (Cell cell : result.listCells()) {
                    // 将结果存放在map中
                    String k = Bytes.toString(cell.getQualifierArray(), cell.getQualifierOffset(), cell.getQualifierLength());
                    String v = Bytes.toString(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength());
                    accountRecord.put(k,v);
    			}
    		}
    	}
    	table.close();
    } catch (IOException e) {
    	e.printStackTrace();
    }
    // 返回所有行数据
    return accountRecord;
}

后话：

在学校时，我参与过 Elasticsearch 相关的项目。在理解 HBase 时，发现 HBase 的设计其实和 Elasticsearch 十分相似，如 HBase 的 Flush&Compact 机制等设计与 Elasticsearch 如出一辙，因此理解起来比较顺利。

从本质上来说，HBase 的定位是分布式存储系统，Elasticsearch 是分布式搜索引擎，两者并不等同，但两者是互补的。HBase 的搜索能力有限，只支持基于 RowKey 的索引，其它二级索引等高级特性需要自己开发。因此，有一些案例是结合 HBase 和 Elasticsearch 实现存储 + 搜索的能力。通过 HBase 弥补 Elasticsearch 存储能力的不足，通过 Elasticsearch 弥补 HBase 搜索能力的不足。

其实，不只是 HBase 和 Elasticsearch。任何一种分布式框架或系统，它们都有一定的共性，不同之处在于各自的关注点不同。我的感受是，在学习分布式中间件时，应先弄清其核心关注点，再对比其它中间件，提取共性和特性，进一步加深理解。

参考资料：