本文已参与「新人创作礼」活动，一起开启掘金创作之路。
文章目录
一 HBase架构
1 RegionServer架构
（1）StoreFile
保存实际数据的物理文件，StoreFile以Hfile的形式存储在HDFS上。每个Store会有一个或多个StoreFile（HFile），数据在每个StoreFile中都是有序的。
（2）MemStore
写缓存，由于HFile中的数据要求是有序的，所以数据是先存储在MemStore中，排好序后，等到达刷写时机才会刷写到HFile，每次刷写都会形成一个新的HFile。
（3）WAL
由于数据要经MemStore排序后才能刷写到HFile，但把数据保存在内存中会有很高的概率导致数据丢失，为了解决这个问题，数据会先写在一个叫做Write-Ahead logfile的文件中，然后再写入MemStore中。所以在系统出现故障的时候，数据可以通过这个日志文件重建。
（4）BlockCache
读缓存，每次查询出的数据会缓存在BlockCache中，方便下次查询。
2 写流程
1）Client先访问zookeeper，获取hbase:meta表位于哪个Region Server。
2）访问对应的Region Server，获取hbase:meta表，根据读请求的namespace:table/rowkey，查询出目标数据位于哪个Region Server中的哪个Region中。并将该table的region信息以及meta表的位置信息缓存在客户端的meta cache，方便下次访问。
3）与目标Region Server进行通讯；
4）将数据顺序写入（追加）到WAL；
5）将数据写入对应的MemStore，数据会在MemStore进行排序；
6）向客户端发送ack；
7）等达到MemStore的刷写时机后，将数据刷写到HFile。
3 MemStore Flush
MemStore刷写时机：
1）当某个memstore的大小达到了hbase.hregion.memstore.flush.size（默认值128M） ，其所在region的所有memstore都会刷写。
当memstore的大小达到了**hbase.hregion.memstore.flush.size（默认值128M）* hbase.hregion.memstore.block.multiplier（默认值4）**时，会阻止继续往该memstore写数据。
2.当region server中memstore的总大小达到java_heapsize * hbase.regionserver.global.memstore.size（默认值0.4）* hbase.regionserver.global.memstore.size.lower.limit（默认值0.95） ，region会按照其所有memstore的大小顺序（由大到小）依次进行刷写。直到region server中所有memstore的总大小减小到上述值以下。
当region server中memstore的总大小达到**java_heapsize * hbase.regionserver.global.memstore.size（默认值0.4）**时，会阻止继续往所有的memstore写数据。
3）到达自动刷写的时间，也会触发memstore flush。自动刷新的时间间隔由该属性进行配置hbase.regionserver.optionalcacheflushinterval（默认1小时） 。
4）当WAL文件的数量超过hbase.regionserver.max.logs，region会按照时间顺序依次进行刷写，直到WAL文件数量减小到hbase.regionserver.max.logs以下（该属性名已经废弃，现无需手动设置，最大值为32）。
4 读流程
merge细节：当1001的数据经过几次修改，可能存储在不同的HFile中，那么put时需要将所有的1001数据全部读取出来
读流程
1）Client先访问zookeeper，获取hbase:meta表位于哪个Region Server。
2）访问对应的Region Server，获取hbase:meta表，根据读请求的namespace:table/rowkey，查询出目标数据位于哪个Region Server中的哪个Region中。并将该table的region信息以及meta表的位置信息缓存在客户端的meta cache，方便下次访问。
3）与目标Region Server进行通讯；
4）分别在MemStore和Store File（HFile）中查询目标数据，并将查到的所有数据进行合并。此处所有数据是指同一条数据的不同版本（time stamp）或者不同的类型（Put/Delete）。
5）将查询到的新的数据块（Block，HFile数据存储单元，默认大小为64KB）缓存到Block Cache。
6）将合并后的最终结果返回给客户端。
5 StoreFile Compaction
由于memstore每次刷写都会生成一个新的HFile，且同一个字段的不同版本（timestamp）和不同类型（Put/Delete）有可能会分布在不同的HFile中，因此查询时需要遍历所有的HFile。为了减少HFile的个数，以及清理掉过期和删除的数据，会进行StoreFile Compaction。
Compaction分为两种，分别是Minor Compaction（每一次flush后就会尝试进行小合并）和Major Compaction（默认7天一次，误差0.5，6.5–7.5天，生产环境不会进行大合并，改为0，在合适的时机手动进行大合并）。Minor Compaction会将临近的若个较小的HFile合并成一个较大的HFile，并清理掉部分过期和删除的数据。Major Compaction会将一个Store下的所有的HFile合并成一个大HFile，并且会清理掉所有过期和删除的数据。
6 Region Split
默认情况下，每个Table起初只有一个Region，随着数据的不断写入，Region会自动进行拆分。刚拆分时，两个子Region都位于当前的Region Server，但处于负载均衡的考虑，HMaster有可能会将某个Region转移给其他的Region Server。
Region Split时机：
1）当1个region中的某个Store下所有StoreFile的总大小超过hbase.hregion.max.filesize（默认10G），该Region就会进行拆分（0.94版本之前）。
2）当1个region中的某个Store下所有StoreFile的总大小超过Min(initialSizeR^3 ,hbase.hregion.max.filesize")，该Region就会进行拆分。其中initialSize的默认值为2hbase.hregion.memstore.flush.size，R为当前Region Server中属于该Table的Region个数（0.94版本之后）。
具体的切分策略为：
第一次split：1^3 * 256 = 256MB
第二次split：2^3 * 256 = 2048MB
第三次split：3^3 * 256 = 6912MB
第四次split：4^3 * 256 = 16384MB > 10GB，因此取较小的值10GB
后面每次split的size都是10GB了。
3）Hbase 2.0引入了新的split策略：如果当前RegionServer上该表只有一个Region，按照2 *
hbase.hregion.memstore.flush.size分裂，否则按照hbase.hregion.max.filesize分裂。
二 HBase API
1 环境准备
<dependency>
<groupId>org.apache.hbase</groupId>
<artifactId>hbase-server</artifactId>
<version>2.0.5</version>
</dependency>
<dependency>
<groupId>org.apache.hbase</groupId>
<artifactId>hbase-client</artifactId>
<version>2.0.5</version>
</dependency>
2 DDL
官网API手册 hbase.apache.org/2.3/apidocs…
（1）创建namespace
/**
* Connection: 通过ConnectionFactory获取，是重量级实现
* Table: 主要负责DML操作
* Admin: 只要负责DDl操作
*/
public class HBaseDemo {
private static Connection connection;
//连接hbase
static {
Configuration conf = HBaseConfiguration.create();
conf.set("hbase.zookeeper.quorum","hadoop101,hadoop102,hadoop103");
try {
connection = ConnectionFactory.createConnection(conf);
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws IOException {
createNameSpace("testAPI1");
}
/**
* 创建namespace
*/
public static void createNameSpace(String nameSpace) throws IOException {
//判空操作
if(nameSpace == null || nameSpace.equals("")){
System.err.println("nameSpace名字不能为空");
}
//获取Admin对象
Admin admin = connection.getAdmin();
NamespaceDescriptor.Builder builder = NamespaceDescriptor.create(nameSpace);
NamespaceDescriptor namespaceDescriptor = builder.build();
//调用方法
try {
admin.createNamespace(namespaceDescriptor);
System.out.println(nameSpace + "创建成功");
} catch (NamespaceExistException e){
System.err.println(nameSpace + "已经存在");
} finally {
admin.close();
}
}
}
（2）创建表
/**
* 创建table
**/
public static void createTable(String nameSpaceName, String tableName, String ... cfs) throws IOException {
Admin admin = connection.getAdmin();
TableDescriptorBuilder tableDescriptorBuilder =
TableDescriptorBuilder.newBuilder(TableName.valueOf(nameSpaceName, tableName));
if(cfs == null || cfs.length < 1){
System.err.println("至少指定一个列族");
return ;
}
for (String cf : cfs) {
ColumnFamilyDescriptorBuilder columnFamilyDescriptorBuilder =
ColumnFamilyDescriptorBuilder.newBuilder(Bytes.toBytes(cf));
ColumnFamilyDescriptor columnFamilyDescriptor =
columnFamilyDescriptorBuilder.build();
tableDescriptorBuilder.setColumnFamilies(Collections.singleton(columnFamilyDescriptor));
}
TableDescriptor tableDescriptor = tableDescriptorBuilder.build();
admin.createTable(tableDescriptor);
admin.close();
}
（3）判断表是否存在
/**
* 判断表是否存在
*/
public static boolean exitsTable(String nameSpaceName,String tableName) throws IOException {
Admin admin = connection.getAdmin();
return admin.tableExists(TableName.valueOf(nameSpaceName, tableName))
}
（4）删除表
/**
* 删除表
*/
public static void dropTable(String nameSpace, String tableName) throws IOException {
if(!exitsTable(nameSpace, tableName)){
System.err.println("表不存在");
return ;
}
Admin admin = connection.getAdmin();
admin.disableTable(TableName.valueOf(nameSpace, tableName));
admin.deleteTable(TableName.valueOf(nameSpace, tableName));
}
3 DML
（1）添加/修改数据
/**
* put
cf：列族
cl：列名
*/
public static void putData(String nameSpaceName,
String tableName,
String rowkey,
String cf,
String cl,
String value) throws IOException {
Table table = connection.getTable(TableName.valueOf(nameSpaceName,tableName));
Put put = new Put(Bytes.toBytes(rowkey));
put.addColumn(Bytes.toBytes(cf),Bytes.toBytes(cl),Bytes.toBytes(value));
table.put(put);
table.close();
}
（2）删除数据
/**
* delete
*/
public static void deleteData(String nameSpace,
String tableName,
String rowKey,
String cf,
String cl) throws IOException {
Table table = connection.getTable(TableName.valueOf(nameSpace,tableName));
//只指定rowkey，就是删除整条数据
Delete delete = new Delete(Bytes.toBytes(rowKey));
//table.delete(delete); //DeleteFamily
//指定删除某个列族的数据
//delete.addFamily(Bytes.toBytes(cf)); //DeleteFamily
//删除某一列最新版本的数据
//delete.addColumn(Bytes.toBytes(cf),Bytes.toBytes(cl)); //Delete
//删除某一列所有版本数据
delete.addColumns(Bytes.toBytes(cf),Bytes.toBytes(cl)); //DeleteColumn
table.delete(delete);
table.close();
}
（3）查询数据
public static void getData(String nameSpace,
String tableName,
String rowKey,
String cf,
String cl) throws IOException {
Table table = connection.getTable(TableName.valueOf(nameSpace,tableName));
Get get = new Get(Bytes.toBytes(rowKey));
//获取某一列族的数据
//get.addFamily(Bytes.toBytes(cf));
//获取某一列的数据
get.addColumn(Bytes.toBytes(cf),Bytes.toBytes(cl));
Result result = table.get(get);
Cell[] cells = result.rawCells();
for (Cell cell : cells) {
String cellString = Bytes.toString(CellUtil.cloneRow(cell)) + " : " +
Bytes.toString(CellUtil.cloneFamily(cell)) + " : " +
Bytes.toString(CellUtil.cloneQualifier(cell)) + " : " +
Bytes.toString(CellUtil.cloneValue(cell));
System.out.println(cellString);
}
table.close();
}
（4）扫描数据
public static void scanData(String nameSpaceName,String tableName,String stratRow,String stopRow) throws IOException {
Table table = connection.getTable(TableName.valueOf(nameSpaceName, tableName));
//Scan scan = new Scan();
//扫描全表数据
//ResultScanner scanner = table.getScanner(scan);
Scan scan = new Scan().withStartRow(Bytes.toBytes(stopRow)).withStopRow(Bytes.toBytes(stopRow));
ResultScanner scanner = table.getScanner(scan);
for (Result result : scanner) {
Cell[] cells = result.rawCells();
for (Cell cell : cells) {
String cellString = Bytes.toString(CellUtil.cloneRow(cell)) + " : " +
Bytes.toString(CellUtil.cloneFamily(cell)) + " : " +
Bytes.toString(CellUtil.cloneQualifier(cell)) + " : " +
Bytes.toString(CellUtil.cloneValue(cell));
System.out.println(cellString);
}
System.out.println("---------------------");
}
table.close();
}
