HBase的API
wal的机制 WAL(Write-Ahead-Log)
SKIP_WAL：不写wal日志,这种可以较大提高写入的性能，但是会存在数据丢失的危险，只有在大批量写入的时候才使用(出错了可以重新运行)，其他情况不建议使用。
ASYNC_WAL：异步写入
SYNC_WAL：同步写入wal日志文件，保证数据写入了DataNode节点。
FSYNC_WAL: 目前不支持了，表现是与SYNC_WAL是一致的
USE_DEFAULT: 如果没有指定持久化级别，则默认为USE_DEFAULT, 这个为使用HBase全局默认级别(SYNC_WAL)
Hbaseutil
package Util;
import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.*;
import org.apache.log4j.Logger;
import java.io.IOException;
/**
* hbase的工具类,admin操作ddl,而table操作dml
*/
public class HbaseUtil {
private static final Logger LOGGER = Logger.getLogger(HbaseUtil.class);
private static final String CONNEXT_KEY ="hbase.zookeeper.quorum";
private static final String CONNECT_VALUE = "hadoop-01:2181,hadoop-03:2181,hadoop-04:2181";
private static Connection connection =null;
static{
//1.获取连接的对象
Configuration configuration= HBaseConfiguration.create();
//2.设置连接hbase的参数
configuration.set(CONNEXT_KEY,CONNECT_VALUE);
//3.获取connection的对象
try {
connection= ConnectionFactory.createConnection(configuration);
} catch (IOException e) {
LOGGER.warn("连接hbase的时候异常!",e);
}
}
//获取admin的对象
public static Admin getAdmin() {
Admin admin=null;
try {
admin=connection.getAdmin();
} catch (IOException e) {
LOGGER.warn("获取admin时异常!",e);
}
return admin;
}
//关闭admin的对象
public static void closeAdmin(Admin admin){
try {
admin.close();
admin.getConnection().close();
} catch (IOException e) {
LOGGER.warn("关闭admin时异常!",e);
}
}
/**
* 获取表连接
*/
public static Table getHTable(String tableName){
Table table = null;
HTable table1=null;
try {
if(StringUtils.isEmpty(tableName)){
tableName = "hbase:meta";
}
table=connection.getTable(TableName.valueOf(tableName));
} catch (IOException e) {
LOGGER.warn("获得表连接时异常!",e);
}
return table;
}
/**
* 关闭表连接
*/
public static void closeTable(Table table){
try {
table.close();
} catch (IOException e) {
LOGGER.warn("关闭表连接时异常!",e);
}
}
public static void main(String[] args) {
HbaseUtil.getHTable("zhao:test");
System.out.println("连接成功");
}
}
ddl_admin :
表操作:
package Hbase.ddl_admin;
import Util.HbaseUtil;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Durability;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.log4j.Logger;
import java.io.IOException;
public class CreateDemo {
public static void main(String[] args) throws IOException {
//获取admin的连接
Admin admin = HbaseUtil.getAdmin();
//创建表描述器
HTableDescriptor tableDescriptor = new HTableDescriptor(TableName.valueOf("zhao:user_info1"));
//创建列簇描述器
HColumnDescriptor columnDescriptor =new HColumnDescriptor("1024_test_javaApi");
//设置列簇版本从1到5
columnDescriptor.setVersions(1,5);
columnDescriptor.setTimeToLive(24*60*60);
//启动读缓存
columnDescriptor.setBlockCacheEnabled(true);
//将列簇添加到表中
tableDescriptor.addFamily(columnDescriptor);
//设置wal的机制 WAL(Write-Ahead-Log)
tableDescriptor.setDurability(Durability.ASYNC_WAL);
//提交
admin.addColumn(TableName.valueOf("zhao:user_info1"),columnDescriptor);
//admin.createTable(tableDescriptor);
admin.deleteColumn(TableName.valueOf("zhao:user_info1"), Bytes.toBytes("1022_test_javaApi"));
HbaseUtil.closeAdmin(admin);
}
}
添加工作空间
package Hbase.ddl_admin;
import Util.HbaseUtil;
import org.apache.hadoop.hbase.NamespaceDescriptor;
import org.apache.hadoop.hbase.client.Admin;
import java.io.IOException;
public class CreateNameSpace {
public static void main(String[] args) throws IOException {
//获得admin的连接
Admin admin=HbaseUtil.getAdmin();
// //创建namespace对象
NamespaceDescriptor namespaceDescriptor=NamespaceDescriptor.create("ali").build();
// try {
admin.createNamespace(namespaceDescriptor);
} catch (IOException e) {
// e.printStackTrace();
// }
NamespaceDescriptor[] namespaceDescriptors=admin.listNamespaceDescriptors();
for (NamespaceDescriptor nd:namespaceDescriptors){
System.out.println(nd.getName());
}
//admin.deleteNamespace("ali");
//关闭连接admin
HbaseUtil.closeAdmin(admin);
}
}
表操作删除
package Hbase.ddl_admin;
import Util.HbaseUtil;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.NamespaceDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.log4j.Logger;
import java.io.IOException;
public class Droptable {
public static void main(String[] args) throws IOException {
//获取admin的连接
Admin admin = HbaseUtil.getAdmin();
try {
HColumnDescriptor columnDescriptor = new HColumnDescriptor("10-23");
HTableDescriptor tableDescriptor = new HTableDescriptor(TableName.valueOf("ali:test"));
tableDescriptor.addFamily(columnDescriptor);
admin.createTable(tableDescriptor);
System.out.println("ali:test已经创建");
Thread.sleep(10000);
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
if (admin.tableExists(TableName.valueOf("ali:test"))) {
if (!admin.isTableDisabled(TableName.valueOf("ali:test"))) {
admin.disableTable(TableName.valueOf("ali:test"));
}
admin.deleteTable(TableName.valueOf("ali:test"));
System.out.println("删除操作已完成");
}
//关闭admin
HbaseUtil.closeAdmin(admin);
}
}
dml_table
get
package Hbase.dml_table;
import Util.HbaseUtil;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.NavigableMap;
public class getDemo {
public static void main(String[] args) throws IOException {
//获取对象
Table table = HbaseUtil.getHTable("zhao:user_info");
// //获取get的对象
// Get get = new Get(Bytes.toBytes("100"));
// //通过table获取结果对象
// Result result = table.get(get);
List<Get> gets = new ArrayList<Get>();
for (int i = 1; i < 10; i++) {
Get get = new Get(Bytes.toBytes(100 + i + ""));
//指定获取的列
//get.addColumn(Bytes.toBytes("base_info"),Bytes.toBytes("username"));
//指定获取的列簇
get.addFamily(Bytes.toBytes("base_info"));
gets.add(get);
}
Result[] result = table.get(gets);
if (result != null) {
for (Result rs : result) {
//3. 获取指定列簇的map集合
NavigableMap<byte[], byte[]> base_info = rs.getFamilyMap(Bytes.toBytes("base_info"));
//4. 遍历map
for (Map.Entry<byte[], byte[]> entry : base_info.entrySet()) {
String k = new String(entry.getKey());
String v = new String(entry.getValue());
System.out.println(k + "=" + v);
}
}
}
}
}
put
package Hbase.dml_table;
import Util.HbaseUtil;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Table;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class PutDemo {
public static void main(String[] args) throws IOException {
//获取table对象
Table table = HbaseUtil.getHTable("zhao:user_info");
//获取Put对象,通过rowkey指定
// Put put = new Put(Bytes.toBytes("100"));
/**
* 设置插入的数据
* 列簇,列名,value
*/
// put.addColumn(Bytes.toBytes("base_info"),Bytes.toBytes("username"),Bytes.toBytes("zhao1024"));
// put.addColumn(Bytes.toBytes("base_info"),Bytes.toBytes("sex"),Bytes.toBytes("male"));
// put.addColumn(Bytes.toBytes("base_info"),Bytes.toBytes("age"),Bytes.toBytes("12"));
// //提交
// table.put(put);
List<Put> puts = new ArrayList<>();
for (int i = 0; i < 10; i++) {
Put put = new Put(Bytes.toBytes(100 + i + ""));
put.addColumn(Bytes.toBytes("base_info"), Bytes.toBytes("username"), Bytes.toBytes("zbs" + i + ""));
put.addColumn(Bytes.toBytes("base_info"), Bytes.toBytes("age"), Bytes.toBytes(12 + i + ""));
put.addColumn(Bytes.toBytes("base_info"), Bytes.toBytes("Sex"), Bytes.toBytes("male"));
puts.add(put);
}
table.put(puts);
//关闭
HbaseUtil.closeTable(table);
}
}
scan
package Hbase.dml_table;
import Util.HbaseUtil;
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.util.Bytes;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.NavigableMap;
public class ScanDemo {
public static void main(String[] args) throws IOException {
//获取连接
Table table = HbaseUtil.getHTable("zhao:user_info");
//创建扫描器
Scan scan = new Scan();
//2.添加扫描的行数左闭又开
scan.setStartRow(Bytes.toBytes("001"));
scan.setStopRow(Bytes.toBytes("909" + "\001"));
scan.setRaw(true);
//3.添加扫描的列
//scan.addColumn(Bytes.toBytes("base_info"),Bytes.toBytes("username"));
scan.getBatch();
//4.获取扫描器
ResultScanner scanner = table.getScanner(scan);
Iterator<Result> it = scanner.iterator();
while (it.hasNext()) {
Result result = it.next();
NavigableMap<byte[], byte[]> base_info = result.getFamilyMap(Bytes.toBytes("base_info"));
for (Map.Entry<byte[], byte[]> entry : base_info.entrySet()) {
String kv = new String(entry.getKey()) + ":" + new String(entry.getValue());
System.out.println(kv);
}
}
}
}
filter
package Hbase.filter;
import Util.HbaseUtil;
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.*;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.NavigableMap;
public class SingleColumnFilter {
public static void main(String[] args) throws IOException {
/*
* 1. 创建过滤器链
* and条件使用MUST_PASS_ALL作为条件
* or条件使用MUST_PASS_ONE
*/
FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL);
FilterList filterList1 = new FilterList(FilterList.Operator.MUST_PASS_ONE);
/**
* 2.构造查询条件
* 对于单例值比较器使用SingLeColumnValueFilter，
* ColumFamily,qualifier,比较过滤器（大于、小于、等于。。。），value
*
*/
SingleColumnValueFilter ageFilter = new SingleColumnValueFilter(
Bytes.toBytes("base_info"), Bytes.toBytes("age"),
CompareFilter.CompareOp.GREATER_OR_EQUAL, Bytes.toBytes("10")
);
SingleColumnValueFilter nameFilter = new SingleColumnValueFilter(
Bytes.toBytes("base_info"), Bytes.toBytes("username"),
CompareFilter.CompareOp.EQUAL, new SubstringComparator("zbs")
);
SingleColumnValueFilter sexFilter = new SingleColumnValueFilter(
Bytes.toBytes("base_info"), Bytes.toBytes("Sex"),
CompareFilter.CompareOp.NOT_EQUAL, new RegexStringComparator("^m.*")
);
filterList.addFilter(ageFilter);
filterList.addFilter(nameFilter);
filterList1.addFilter(filterList);
filterList1.addFilter(sexFilter);
//4.创建扫描器进行扫描
Scan scan = new Scan();
//5. 将过滤条件关联到扫描器
scan.setFilter(filterList);
scan.setFilter(filterList1);
//6. 获取表对象
Table table = HbaseUtil.getHTable("zhao:user_info");
//7. 扫描表
ResultScanner scanner = table.getScanner(scan);
//8. 打印数据
Iterator<Result> iterator = scanner.iterator();
while (iterator.hasNext()) {
Result result = iterator.next();
NavigableMap<byte[], byte[]> base_info = result.getFamilyMap(Bytes.toBytes("base_info"));
//4. 遍历map
for (Map.Entry<byte[], byte[]> entry : base_info.entrySet()) {
String kv = new String(entry.getKey()) + ":" + new String(entry.getValue()) + "\t";
System.out.println(kv);
}
}
//关闭
HbaseUtil.closeTable(table);
}
}
https://hbase.apache.org/book.html#thrift.filter_language
108.8
以下是谷歌翻译（英语水平见谅）
Filter
KeyOnlyFilter
此过滤器不接受任何参数。它仅返回每个键值的键组成部分。
FirstKeyOnlyFilter
此过滤器不接受任何参数。它仅返回每行的第一个键值。
PrefixFilter
此过滤器采用一个参数–行键的前缀。它仅返回以指定行前缀开头的行中存在的那些键值
ColumnPrefixFilter
该过滤器采用一个参数–列前缀。它仅返回存在于以指定列前缀开头的列中的那些键值。列前缀的格式必须为：“qualifier”。
MultipleColumnPrefixFilter
此过滤器采用列前缀列表。它返回存在于以任何指定列前缀开头的列中的键值。每个列前缀都必须采用以下形式：“qualifier”。
ColumnCountGetFilter
此过滤器采用一个参数-一个限制。它返回表中的第一个限制列数。
页面过滤器
此过滤器采用一个参数–页面大小。它从表中返回页面大小的行数。
ColumnPaginationFilter
该过滤器采用两个参数–限制和偏移量。在偏移列数之后返回限制列数。它为所有行执行此操作。
InclusiveStopFilter
该过滤器采用一个参数–行键，停止扫描。它返回直到指定行为止（包括指定行）的所有键值。
时间戳过滤器
该过滤器采用时间戳列表。它返回那些时间戳与任何指定时间戳匹配的键值。
行过滤器
该过滤器带有一个比较运算符和一个比较器。它使用比较运算符将每个行键与比较器进行比较，如果比较返回true，则返回该行中的所有键值。
家庭过滤器
该过滤器带有一个比较运算符和一个比较器。它使用比较运算符将每个列族名称与比较器进行比较，如果比较结果为true，则返回该列族中的所有单元格。
QualifierFilter
该过滤器带有一个比较运算符和一个比较器。它使用比较运算符将每个限定符名称与比较器进行比较，如果比较返回true，则将返回该列中的所有键值。
值过滤器
该过滤器带有一个比较运算符和一个比较器。它使用比较运算符将每个值与比较器进行比较，如果比较返回true，则返回该键值。
DependentColumnFilter
该过滤器接受两个参数-家庭和限定词。它尝试在每一行中定位此列，并返回该行中所有具有相同时间戳的键值。如果该行不包含指定的列-该行中的任何键值均不会返回。
SingleColumnValueFilter
该过滤器包含一个列族，一个限定符，一个比较运算符和一个比较器。如果找不到指定的列，则将发射该行的所有列。如果找到该列，并且与比较器的比较返回true，则将发出该行的所有列。如果条件失败，则不会发出该行。
SingleColumnValueExcludeFilter
该过滤器采用相同的参数，其行为与SingleColumnValueFilter相同–但是，如果找到该列并且条件通过，则将发出该行的所有列，但测试列的值除外。
ColumnRangeFilter
此过滤器仅用于选择列在minColumn和maxColumn之间的键。它还需要两个布尔变量来指示是否包括minColumn和maxColumn。
package com.ali.hbase.filter;
import com.ali.util.HBaseUtil;
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.*;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.NavigableMap;
public class OtherFilterDemo {
public static void main(String[] args) throws IOException {
//1. 创建正则比较器：以base开头的字符串
SubstringComparator substringComparator = new SubstringComparator("ag");
//2. 创建FamilyFilter
QualifierFilter qualifierFilter = new QualifierFilter(
CompareFilter.CompareOp.EQUAL, new BinaryPrefixComparator(Bytes.toBytes("s")));
ColumnPrefixFilter columnPrefixFilter = new ColumnPrefixFilter(
Bytes.toBytes("s"));
byte[][] prefixes = new byte[][] {Bytes.toBytes("a"), Bytes.toBytes("s")};
MultipleColumnPrefixFilter multipleColumnPrefixFilter = new MultipleColumnPrefixFilter(
prefixes);
ColumnRangeFilter columnRangeFilter = new ColumnRangeFilter(Bytes.toBytes("age"), true,
Bytes.toBytes("sex"), true);
BinaryPrefixComparator binaryComparator = new BinaryPrefixComparator(Bytes.toBytes("1"));
RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.EQUAL, binaryComparator);
FirstKeyOnlyFilter firstKeyOnlyFilter = new FirstKeyOnlyFilter();
PageFilter pageFilter = new PageFilter(3);
//4.创建扫描器进行扫描
Scan scan = new Scan();
//5. 将过滤条件关联到扫描器
scan.setFilter(pageFilter);
//6. 获取表对象
Table table = HBaseUtil.getTable("user_info");
//5. 遍历显示
String maxKey = ""; // 最大key值记录器
while(true) {
int count = 0; // 计算器
//6. 获取结构扫描器
ResultScanner scanner = table.getScanner(scan);
//7. 获取迭代器迭代
Iterator<Result> iterator = scanner.iterator();
//8. 迭代
while (iterator.hasNext()) {
Result result = iterator.next();
System.out.println(new String(result.getRow()));
count++;
maxKey = Bytes.toString(result.getRow());
//9. 打印
NavigableMap<byte[], byte[]> base_info = result.getFamilyMap(Bytes.toBytes("ext_info"));
//4. 遍历map
for(Map.Entry<byte[], byte[]> entry : base_info.entrySet()) {
String kv = new String(entry.getKey())+":"+new String(entry.getValue())+"\t";
System.out.println(kv);
}
}
System.out.println("------------------------------------");
//10. 判断是否可以结束
if (count < 3) break;
//11. 设置下一次开始查询的行键号
scan.setStartRow(Bytes.toBytes(maxKey + "\001"));
}
//-------------------------------------------------------
/*//7. 扫描表
ResultScanner scanner = table.getScanner(scan);
//8. 打印数据
Iterator<Result> iterator = scanner.iterator();
while (iterator.hasNext()) {
Result result = iterator.next();
NavigableMap<byte[], byte[]> base_info = result.getFamilyMap(Bytes.toBytes("ext_info"));
//4. 遍历map
for(Map.Entry<byte[], byte[]> entry : base_info.entrySet()) {
String kv = new String(entry.getKey())+":"+new String(entry.getValue())+"\t";
System.out.println(kv);
}
}*/
//关闭
HBaseUtil.closeTable(table);
}
}
5013
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
