Hbase有多种不同的客户端,如REST客户端,Thift客户端,ORM框架Kundera等等。 Hbase也提供了Java的API来操作表与列簇等信息,它的shell就是对Java的API做了一层封装。
Hbase的Java API提供了很多高级的特性:
- 元数据管理,列簇的数据压缩,region分隔
- 创建,删除,更新,读取 rowkey
我们还是直接看代码这样理解的更容易
环境
- Hbase 0.98
- Java 1.8
- Zookeeper 3.4.6
案例
Hbase的客户端版本不一致实验结果很容易出现问题,尽量采用同样的版本。因为服务端实验的是Hbase0.98,客户端也用0.98,另外由于Hadoop 2.x的版本现对于1.x做了很大的提升,建议采用Hbase-hadoop 2.x的客户端。
<dependency>
<groupId>org.apache.hbase</groupId>
<artifactId>hbase-client</artifactId>
<version>0.98.24-hadoop2</version>
</dependency>
建立连接
-
直接新建HTable("tableName"),但是这种每次创建表的时候因为都要查询.meta表,来判断表是不是存在,导致创建表的过程会有点慢,所以不建议每个请求都创建一个Htable
-
使用HTablePool,它和HTable的创建方式很像,但是如果采用连接池的话,它就不会给每个请求都单独创建一个Htable了。
在创建Htable或者HtablePool的时候都可以指定更详细的配置信息。
HTablePool hTablePool = new HTablePool();
hTablePool.getTable("user");
增删改查
rowkey是代表Hbase中表的唯一一个行,同时像列簇 ,时间戳等用来定位表中的部分数据,Java的API对Hbas的CURD提供了如下的类:
- Put
- Get
- Delete
- Scan
- Increment
我们详细的讨论几个类,剩余的可以举一反三。
写数据
当写请求收到的时候,默认数据同步的写到Hlog中和MemStore,同时在两个地方写是为了保证数据的持久性,Memstore最终会持久化到磁盘中的Hfile中。每次MemStore进行Flush的时候,就会创建一个新的Hfile。
Put类用于向Hbase的表中存储数据,存储数据时,Put的实例必须要指定Rowkey
创建完Put实例后,再向其中添加数据
public void put() throws IOException {
// 获取默认的配置
Configuration conf = HBaseConfiguration.create();
// 获取Table实例
HTable table = new HTable(conf, "tab1");
// 创建Put实例,并且指定rowKey
Put put = new Put(Bytes.toBytes("row-1"));
// 添加一个 column,值为 "Hello",在 "cf1:greet" 列中
put.add(Bytes.toBytes("cf1"), Bytes.toBytes("greet"), Bytes.toBytes("Hello"));
// 添加一个 column,值为 "John",在 "cf1:person" 列中
put.add(Bytes.toBytes("cf1"), Bytes.toBytes("person"), Bytes.toBytes("John"));
table.put(put);
table.close();
}
数据也可以批量的进行插入:
// table对象可以传入List参数
table.put(final List<Put> puts)
执行结果:
读数据
Hbase使用LRU缓存读取数据。Htable对象使用下面的方法读取数据
而Get实例的构造方法和Put很像,构造方法要指定一个rowkey。
如果要查找特定的cell,就是特定列的数据,可以采用额外的方法进行更加精细的调控。
看一下如下的案例代码:
public void get() throws IOException {
// 获取默认的配置
Configuration conf = HBaseConfiguration.create();
// 获取Table实例
HTable table = new HTable(conf, "tab1");
// 创建Put实例,并且指定rowKey
Get get = new Get(Bytes.toBytes("row-1"));
//
get.addColumn(Bytes.toBytes("cf1"), Bytes.toBytes("greet"));
// 添加一个 column,值为 "John",在 "cf1:person" 列中
Result result = table.get(get);
byte[] value = result.getValue(Bytes.toBytes("cf1"), Bytes.toBytes("greet"));
System.out.println("获取到的值" + new String(value));
table.close();
}
执行结果
更新数据
更新数据与写数据基本一致,只是在Put实例赋值的时候,在相同的列上设置不同的值,操作的时候就会更新为新的值。
代码如下:
public void update() throws IOException {
Configuration conf = HBaseConfiguration.create();
// 获取Table实例
HTable table = new HTable(conf, "tab1");
// 创建Put实例,并且指定rowKey
Put put = new Put(Bytes.toBytes("row-1"));
// 添加一个 column,值为 "Hello",在 "cf1:greet" 列中
put.add(Bytes.toBytes("cf1"), Bytes.toBytes("greet"), Bytes.toBytes("Good Morning"));
// 添加一个 column,值为 "John",在 "cf1:person" 列中
// put.add(Bytes.toBytes("cf1"), Bytes.toBytes("person"), Bytes.toBytes("John"));
table.put(put);
table.close();
}
执行结果:
删除数据
Delete命令只是标记当前的数据为删除状态,而不是立刻的删除,也就是先进行逻辑删除。实际上的删除是在Hfile进行压缩的时候,这些被标记的记录就会被删除掉。
Delete对象与Put和Get也很像
构造Delete实例
如果想要进行更加详细的指定,可以再指定具体的列等信息
看下面的案例代码:
public void delete() throws IOException {
Configuration conf = HBaseConfiguration.create();
// 获取Table实例
HTable table = new HTable(conf, "tab1");
// 创建Delete实例,并且指定rowKey
Delete delete = new Delete(Bytes.toBytes("row-1"));
// 删除 column "cf1:greet"
delete.deleteColumn(Bytes.toBytes("cf1"), Bytes.toBytes("greet"));
table.delete(delete);
table.close();
}
执行结果:连续执行两次删除
操作优化
一个系统上线之后,开发和调优将一直贯穿系统的生命周期中,HBase也不列外。
这里主要说一些Hbase的调优
Hbase查询优化
作为NoSQL数据库,增删改查是其最基本的功能,其中查询是最常用的一项。
设置Scan缓存
HBase中Scan查询可以设置缓存,方法是setCaching(),这样可以有效的减少服务端与客户端的交互,更有效的提升扫描查询的性能。
/**
* Set the number of rows for caching that will be passed to scanners.
* If not set, the default setting from {@link HTable#getScannerCaching()} will apply.
* Higher caching values will enable faster scanners but will use more memory.
* @param caching the number of rows for caching
* 设置scanners缓存的行数
*/
public void setCaching(int caching) {
this.caching = caching;
}
显示的指定列
当使用Scan或者GET获取大量的行时,最好指定所需要的列,因为服务端通过网络传输到客户端,数据量太大可能是瓶颈。如果能有效过滤部分数据,能很大程度的减少网络I/O的花费。
/**
* Get all columns from the specified family.
* <p>
* Overrides previous calls to addColumn for this family.
* @param family family name
* @return this
* 获取指定列簇的所有列
*/
public Scan addFamily(byte [] family) {
familyMap.remove(family);
familyMap.put(family, null);
return this;
}
/**
* Get the column from the specified family with the specified qualifier.
* <p>
* Overrides previous calls to addFamily for this family.
* @param family family name
* @param qualifier column qualifier
* @return this
* 获取指定列簇的特定列
*/
public Scan addColumn(byte [] family, byte [] qualifier) {
NavigableSet<byte []> set = familyMap.get(family);
if(set == null) {
set = new TreeSet<byte []>(Bytes.BYTES_COMPARATOR);
}
if (qualifier == null) {
qualifier = HConstants.EMPTY_BYTE_ARRAY;
}
set.add(qualifier);
familyMap.put(family, set);
return this;
}
一般用:
scan.addColumn(...)
关闭ResultScanner
如果在使用table.getScanner之后,忘记关闭该类,它会一直和服务端保持连接,资源无法释放,从而导致服务端的某些资源不可用。
所以在用完之后,需要执行关闭操作,这点与JDBS操作MySQL类似
scanner.close()
禁用块缓存
如果批量进行全表扫描,默认是有缓存的,如果此时有缓存,会降低扫描的效率。
scan.setCacheBlocks(true|false);
对于经常读到的数据,建议使用默认值,开启块缓存
缓存查询结果
对于频繁查询HBase的应用场景,可以考虑在应用程序和Hbase之间做一层缓存系统,新的查询先去缓存查,缓存没有再去查Hbase。
写入优化
写也是Hbase常有的操作之一,并且Hbase在写入操作上有着其他NoSQL无法比拟的优势,下面讲如何优化写入操作
关闭写WAL日志
一般为了保证系统的高可用性,WAL日志默认是开启状态,WAL主要用于灾难恢复的,如果应用可以容忍一定的数据丢失风险,可以在写数据的时候,关闭写WAL。
风险: 当RegionServer宕机时,写入的数据出现丢失,且无法恢复
设置AutoFlush
Htable有一个属性是AutoFlush,该属性用于支持客户端的批量更新,默认是true,当客户端每收到一条数据,立刻发送到服务端,如果设置为false,当客户端提交put请求时候,先将该请求在客户端缓存,到达阈值的时候或者执行hbase.flushcommits(),才向RegionServer提交请求。
风险: 在请求未发送到RegionServer之前客户端崩溃,数据也会丢失
table.setAutoFlush(false);
table.setWriteBufferSize( 12 * 1024 * 1024 );
预创建Region
一般表刚开始只有一个Region,插入该表的数据都会保存在此Region中,插入该表的所有塑化剂都会保存在该Region中,当到达一定的阈值时,才发生分裂。 这样开始时刻针对该表的写操作都集中在某台服务器上,造成这台服务器的压力很紧张,同时对整个集群资源的浪费
建议刚开始的时候预创建Region,可以使用Hbase自带的RegionSplitter
延迟日志flush
默认写入操作,首先写入WAL,并且在1S内写入HDFS,这个时间默认是1S,可以通过参数配置
hbase.regionserver.optionallogflushinterval
可以配置大一点的值,比如5s,这段时间数据会保留在内存中,直到RegionServer周期性的执行flush操作。
Scan的重要参数
Scan是操作Hbase中非常常用的一个操作,虽然前面的Hbase API操作简单的介绍了Scan的操作,但不够详细,由于Scan非常常用,关于其详细的整理也是很有必要的。
Scan
HBase中的数据表通过划分成一个个的Region来实现数据的分片,每一个Region关联一个RowKey的范围区间,而每一个Region中的数据,按RowKey的字典顺序进行组织。
正是基于这种设计,使得HBase能够轻松应对这类查询:"指定一个RowKey的范围区间,获取该区间的所有记录", 这类查询在HBase被称之为Scan。
1 . 构建Scan,指定startRow与stopRow,如果未指定的话会进行全表扫描
2 . 获取ResultScanner
3 . 遍历查询结果
4 . 关闭ResultScanner
public void stringFilter() throws IOException {
Configuration conf = HBaseConfiguration.create();
// 获取Table实例
HTable table = new HTable(conf, "user");
// 构建Scan
Scan scan = new Scan();
scan = scan.setStartRow(Bytes.toBytes("startRowxxx")).setStopRow(Bytes.toBytes("StopRowxxx"));
RowFilter filter = new RowFilter(
CompareFilter.CompareOp.EQUAL,
new BinaryComparator(Bytes.toBytes("224382618261914241"))
);
scan.setFilter(filter);
// 获取resultScanner
ResultScanner scanner = table.getScanner(scan);
Result result = null;
// 处理结果
while ((result = scanner.next()) != null) {
byte[] value = result.getValue(Bytes.toBytes("ship"), Bytes.toBytes("addr"));
if (value == null || value.length == 0) {
continue;
}
System.out.println(
new String(value)
);
System.out.println("hello World");
}
// 关闭ResultScanner
scanner.close();
table.close();
}
其它的设置参数
Caching: 设置一次RPC请求批量读取的Results数量
下面的示例代码设定了一次读取回来的Results数量为100:
scan.setCaching(100);
Client每一次往RegionServer发送scan请求,都会批量拿回一批数据(由Caching决定过了每一次拿回的Results数量),然后放到本次的Result Cache中:
应用每一次读取数据时,都是从本地的Result Cache中获取的。如果Result Cache中的数据读完了,则Client会再次往RegionServer发送scan请求获取更多的数据。
Batch: 设置每一个Result中的列的数量
下面的示例代码设定了每一个Result中的列的数量的限制值为3:
scan.setBatch(3);
该参数适用于一行数据过大的场景,这样,一行数据被请求的列会被拆成多个Results返回给Client。
举例说明如下:
假设一行数据中共有十个列:
{Col01,Col02,Col03,Col04,Col05,Col06,Col07,Col08,Col09, Col10}
假设Scan中设置的Batch为3,那么,这一行数据将会被拆成4个Results返回:
Result1 -> {Col01,Col02,Col03}
Result2 -> {Col04,Col05,Col06}
Result3 -> {Col07,Col08,Col09}
Result4 -> {Col10}
关于Caching参数,我们说明了是Client每一次从RegionServer侧获取到的Results的数量,上例中,一行数据被拆成了4个Results,这将会导致Caching中的计数器被减了4次。结合Caching与Batch,我们再列举一个稍复杂的例子:
假设,Scan的参数设置如下:
final byte[] start = Bytes.toBytes("Row1");
final byte[] stop = Bytes.toBytes("Row5");
Scan scan = new Scan();
scan.withStartRow(start).withStopRow(stop);
scan.setCaching(10);
scan.setBatch(3);
待读取的数据RowKey与所关联的列集如下所示:
Row1: {Col01,Col02,Col03,Col04,Col05,Col06,Col07,Col08,Col09,Col10}
Row2: {Col01,Col02,Col03,Col04,Col05,Col06,Col07,Col08,Col09,Col10,Col11}
Row3: {Col01,Col02,Col03,Col04,Col05,Col06,Col07,Col08,Col09,Col10}
再回顾一下Caching与Batch的定义:
Caching: 影响一次读取返回的Results数量。
Batch: 限定了一个Result中所包含的列的数量,如果一行数据被请求的列的数量超出Batch限制,那么这行数据会被拆成多个Results。
那么, Client往RegionServer第一次请求所返回的结果集如下所示:
Result1 -> Row1: {Col01,Col02,Col03}
Result2 -> Row1: {Col04,Col05,Col06}
Result3 -> Row1: {Col07,Col08,Col09}
Result4 -> Row1: {Col10}
Result5 -> Row2: {Col01,Col02,Col03}
Result6 -> Row2: {Col04,Col05,Col06}
Result7 -> Row2: {Col07,Col08,Col09}
Result8 -> Row2: {Col10,Col11}
Result9 -> Row3: {Col01,Col02,Col03}
Result10 -> Row3: {Col04,Col05,Col06}
Limit: 限制一次Scan操作所获取的行的数量
同SQL语法中的limit子句,限制一次Scan操作所获取的行的总量:
scan.setLimit(10000);
注意:Limit参数是在2.0版本中新引入的。但在2.0.0版本中,当Batch与Limit同时设置时,似乎还存在一个BUG,初步分析问题原因应该与BatchScanResultCache中的numberOfCompletedRows计数器逻辑处理有关。因此,暂时不建议同时设置这两个参数。
CacheBlock: RegionServer侧是否要缓存本次Scan所涉及的HFileBlocks
scan.setCacheBlocks(true);
e) Raw Scan: 是否可以读取到删除标识以及被删除但尚未被清理的数据
scan.setRaw(true);
MaxResultSize: 从内存占用量的维度限制一次Scan的返回结果集
下面的示例代码将返回结果集的最大值设置为5MB:
scan.setMaxResultSize(5 * 1024 * 1024);
Reversed Scan: 反向扫描
普通的Scan操作是按照字典顺序从小到大的顺序读取的,而Reversed Scan则恰好相反:
scan.setReversed(true);
带Filter的Scan
Filter可以在Scan的结果集基础之上,对返回的记录设置更多条件值,这些条件可以与RowKey有关,可以与列名有关,也可以与列值有关,还可以将多个Filter条件组合在一起,等等。
最常用的Filter是SingleColumnValueFilter,基于它,可以实现如下类似的查询:
"返回满足条件{列I:D的值大于等于10}的所有行"
示例代码如下:
Filter丰富了HBase的查询能力,但使用Filter之前,需要注意一点:Filter可能会导致查询响应时延变的不可控制。因为我们无法预测,为了找到一条符合条件的记录,背后需要扫描多少数据量,如果在有效限制了Scan范围区间(通过设置StartRow与StopRow限制)的前提下,该问题能够得到有效的控制。这些信息都要求使用Filter之前应该详细调研自己的业务数据模型。