//写入hbase(hfile方式）
org.apache.hadoop.hbase.client.Connection conn = null;
try {
SparkLog.debug("开始读取hbase信息...");
if (StringUtils.isNotBlank(type) && type.equalsIgnoreCase("hbase")) {
SparkLog.debug("==========================================");
String hbasetable = dict.getStringItem("table", "");
String hbase_site_path = dict.getStringItem("path_site", "");
String hfile_path = dict.getStringItem("hfile_path", "");
Configuration conf = ss.sparkContext().hadoopConfiguration();
if (StringUtils.isBlank(hbase_site_path)) {
SparkLog.warn("参数配置错误，未配置hbase-site信息!");
}
if (StringUtils.isNotBlank(hbase_site_path)) {
hbase_site_path = hbase_site_path + (hbase_site_path.contains("hbase-site.xml") ? "" : "/hbase-site.xml");
conf.addResource(new Path(hbase_site_path));
} SparkLog.debug("读取hbase信息完成");
conf.set(HConstants.HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD, "");
if (!P_Spark.delHDFSDir(hfile_path)) {
return TCResult.newFailureResult("SPARK_ERROR", "删除旧文件失败");
}
conf.setInt("hbase.mapreduce.bulkload.max.hfiles.perRegion.perFamily", );
SparkLog.debug(conf); SparkLog.debug("创建hbase的链接...");
// 创建hbase的链接,利用默认的配置文件,实际上读取的hbase的master地址
conn = ConnectionFactory.createConnection(conf); SparkLog.debug("开始生成hfile文件...");
//必须按照key排序
data.flatMapToPair(new PairFlatMapFunction<Row, ImmutableBytesWritable, KeyValue>() { private static final long serialVersionUID = -8033772725296906227L; @Override
public Iterator<Tuple2<ImmutableBytesWritable, KeyValue>> call(Row s) throws Exception {
byte[] rowkey = Bytes.toBytes((new SimpleDateFormat("yyyyMMddHHmmss.sss")).format(System.currentTimeMillis())+Math.random()*);
List<Tuple2<ImmutableBytesWritable,KeyValue>> cols = new ArrayList<>();
byte[] family = Bytes.toBytes("fm"); String hostname =s.get()==null ? "":s.getString();
String request_date =s.get()==null ? "":s.getString();
String post_id=s.get()==null ? "":Integer.toString(s.getInt());
String title=s.get()==null ? "":s.getString();
String author=s.get()==null ? "":s.getString();
String country=s.get()==null ? "":s.getString();
String category=s.get()==null ? "":s.getString(); //String filds[] =s.schema().fieldNames();//获取列名 //列名需要排序，按顺序加入
cols.add(new Tuple2<ImmutableBytesWritable, KeyValue>(new ImmutableBytesWritable(rowkey),new KeyValue(rowkey, family, "author".getBytes(), Bytes.toBytes(author))));
cols.add(new Tuple2<ImmutableBytesWritable, KeyValue>(new ImmutableBytesWritable(rowkey),new KeyValue(rowkey, family, "category".getBytes(), Bytes.toBytes(category))));
cols.add(new Tuple2<ImmutableBytesWritable, KeyValue>(new ImmutableBytesWritable(rowkey),new KeyValue(rowkey, family, "country".getBytes(), Bytes.toBytes(country))));
cols.add(new Tuple2<ImmutableBytesWritable, KeyValue>(new ImmutableBytesWritable(rowkey),new KeyValue(rowkey, family, "hostname".getBytes(), Bytes.toBytes(hostname))));
cols.add(new Tuple2<ImmutableBytesWritable, KeyValue>(new ImmutableBytesWritable(rowkey),new KeyValue(rowkey, family, "post_id".getBytes(), Bytes.toBytes(post_id))));
cols.add(new Tuple2<ImmutableBytesWritable, KeyValue>(new ImmutableBytesWritable(rowkey),new KeyValue(rowkey, family, "request_date".getBytes(), Bytes.toBytes(request_date))));
cols.add(new Tuple2<ImmutableBytesWritable, KeyValue>(new ImmutableBytesWritable(rowkey),new KeyValue(rowkey, family, "title".getBytes(), Bytes.toBytes(title))));
return cols.iterator();
}
}).sortByKey().saveAsNewAPIHadoopFile(hfile_path, ImmutableBytesWritable.class, KeyValue.class, HFileOutputFormat2.class, conf);
SparkLog.debug("生成hfile文件成功");
LoadIncrementalHFiles load = new LoadIncrementalHFiles(conf);
// 根据表名获取表
SparkLog.debug("根据表名获取表...");
Table table = conn.getTable(TableName.valueOf(hbasetable));
SparkLog.debug(table.toString()); // 获取hbase表的region分布
SparkLog.debug("获取hbase表的region分布...");
RegionLocator regionLocator = conn.getRegionLocator(TableName
.valueOf(hbasetable));
// 创建一个hadoop的mapreduce的job
Job job = Job.getInstance(conf);
// 设置job名称
job.setJobName("DumpFile");
// 此处最重要,需要设置文件输出的key,因为我们要生成HFil,所以outkey要用ImmutableBytesWritable
job.setMapOutputKeyClass(ImmutableBytesWritable.class);
// 输出文件的内容KeyValue
job.setMapOutputValueClass(KeyValue.class);
// 配置HFileOutputFormat2的信息
HFileOutputFormat2.configureIncrementalLoad(job, table,
regionLocator); // 开始导入
SparkLog.debug("开始导入...");
load.doBulkLoad(new Path(hfile_path), conn.getAdmin(), table,
regionLocator);
// load.doBulkLoad(new Path(path),new , table,regionLocator);
// load.doBulkLoad(new Path(path), (HTable)table);这个目前也可用
table.close(); } } catch (Throwable e) {
return TCResult.newFailureResult("SPARK_ERROR", e);
} finally {
try {
conn.close();
} catch (Throwable e) {
return TCResult.newFailureResult("SPARK_ERROR", e);
}
}
//读取hbase
Configuration conf = sc.hadoopConfiguration();
3 if (null != hbase_site_path) {
hbase_site_path = hbase_site_path.contains("hbase-site.xml") ? hbase_site_path : hbase_site_path
+ "/hbase-site.xml";
conf.addResource(new Path(hbase_site_path));
} else {
if(zn_parent == null || zn_parent.equals("")){
zn_parent="/hbase";
}
conf.set("hbase.zookeeper.quorum", quorum);
conf.set("hbase.zookeeper.property.clientPort", zkport);
conf.set("zookeeper.znode.parent", zn_parent); }
conf.set(HConstants.HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD, "");
JavaRDD<String> javardd = null;
try {
conf.set(TableInputFormat.INPUT_TABLE, tablename);
JavaPairRDD<ImmutableBytesWritable, Result> hbRDD = sc
.newAPIHadoopRDD(conf, TableInputFormat.class,
ImmutableBytesWritable.class, Result.class); javardd = hbRDD.values().map(new Function<Result, String>(){ /**
*
*/
private static final long serialVersionUID = 1L; @Override
public String call(Result r) throws Exception {
// TODO 自动生成的方法存根
String s = "";
for (Cell cell : r.rawCells()) {
s += "Rowkey:"
+ Bytes.toString(CellUtil.cloneRow(cell))
+ ",column="
+ Bytes.toString(CellUtil.cloneFamily(cell))
+ ":"
+ Bytes.toString(
CellUtil.cloneQualifier(cell))
.replaceAll("Quilifier:", "")
+ ",timestamp=" + cell.getTimestamp()
+ ",value:"
+ Bytes.toString(CellUtil.cloneValue(cell));
}
return s;
} });
SparkLog.debug("hbase table records num = " + javardd.count()); } catch (Throwable e) {
return TCResult.newFailureResult("SPARK_ERROR",e);
}
//hbase读取方式2（saveAsNewAPIHadoopDataset && put方式）
String hbasetable = dict.getStringItem("table", "");
String hbase_site_path = dict.getStringItem("path_site", "");
//String hfile_path = dict.getStringItem("hfile_path", "");
Configuration conf = ss.sparkContext().hadoopConfiguration(); if (StringUtils.isBlank(hbase_site_path)) {
SparkLog.warn("参数配置错误，未配置hbase-site信息!");
}
if (StringUtils.isNotBlank(hbase_site_path)) {
hbase_site_path = hbase_site_path + (hbase_site_path.contains("hbase-site.xml") ? "" : "/hbase-site.xml");
conf.addResource(new Path(hbase_site_path));
} SparkLog.debug("读取hbase信息完成");
conf.set(HConstants.HBASE_CLIENT_SCANNER_TIMEOUT_PERIOD, "");
conf.set(TableOutputFormat.OUTPUT_TABLE, hbasetable); Job job = Job.getInstance(conf);
// 设置job名称
job.setJobName("DumpFile");
// 此处最重要,需要设置文件输出的key,因为我们要生成HFil,所以outkey要用ImmutableBytesWritable
job.setMapOutputKeyClass(ImmutableBytesWritable.class);
// 输出文件的内容Result
job.setMapOutputValueClass(Put.class); job.setOutputFormatClass((TableOutputFormat.class)); data.mapToPair(new PairFunction<Row, ImmutableBytesWritable, Put>() { private static final long serialVersionUID = -8033772725296906227L; @Override
public Tuple2<ImmutableBytesWritable, Put> call(Row s) throws Exception {
byte[] rowkey = Bytes.toBytes((new SimpleDateFormat("yyyyMMddHHmmss.sss")).format(System.currentTimeMillis())+Math.random()*); byte[] family = Bytes.toBytes("fm"); String hostname =s.get()==null ? "":s.getString();
String request_date =s.get()==null ? "":s.getString();
String post_id=s.get()==null ? "":Integer.toString(s.getInt());
String title=s.get()==null ? "":s.getString();
String author=s.get()==null ? "":s.getString();
String country=s.get()==null ? "":s.getString();
String category=s.get()==null ? "":s.getString(); Put put = new Put(rowkey); put.addImmutable(family,Bytes.toBytes("hostname"),Bytes.toBytes(hostname));
put.addImmutable(family,Bytes.toBytes("request_date"),Bytes.toBytes(request_date));
put.addImmutable(family,Bytes.toBytes("post_id"),Bytes.toBytes(post_id));
put.addImmutable(family,Bytes.toBytes("title"),Bytes.toBytes(title));
put.addImmutable(family,Bytes.toBytes("author"),Bytes.toBytes(author));
put.addImmutable(family,Bytes.toBytes("country"),Bytes.toBytes(country));
put.addImmutable(family,Bytes.toBytes("category"),Bytes.toBytes(category)); return new Tuple2<ImmutableBytesWritable, Put>(new ImmutableBytesWritable(rowkey),put); }
}).saveAsNewAPIHadoopDataset(job.getConfiguration());
//创建hbase表结构
org.apache.hadoop.hbase.client.Connection conn = null;
try { //创建hbase的链接,利用默认的配置文件,实际上读取的hbase的master地址
conn = ConnectionFactory.createConnection(conf);
// 根据表名获取表
HBaseAdmin admin =(HBaseAdmin) conn.getAdmin(); if (!admin.tableExists(tablename)) {
SparkLog.info("Table Not Exists! Create Table");
HTableDescriptor tableDesc = new HTableDescriptor(TableName.valueOf(tablename));
String fms[] =Col_family.split(",");
for(int i=;i<fms.length;i++){
tableDesc.addFamily(new HColumnDescriptor(fms[i].getBytes()));
}
admin.createTable(tableDesc);
}else{
SparkLog.info("Table Exists! Do not Create Table");
}
}catch (Throwable e) {
return TCResult.newFailureResult("SPARK_ERROR", e);
} finally {
try {
conn.close();
} catch (Throwable e) {
return TCResult.newFailureResult("SPARK_ERROR", e);
}
}
// 添加一条数据
public static void addRow(String tableName, String rowKey, String columnFamily, String column, String value)
throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 通过rowkey创建一个put对象
Put put = new Put(Bytes.toBytes(rowKey));
// 在put对象中设置列族、列、值
put.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(column), Bytes.toBytes(value));
// 插入数据,可通过put(List<Put>)批量插入
table.put(put);
// 关闭资源
table.close();
conn.close();
}
// 通过rowkey获取一条数据
public static void getRow(String tableName, String rowKey) throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 通过rowkey创建一个get对象
Get get = new Get(Bytes.toBytes(rowKey));
// 输出结果
Result result = table.get(get);
for (Cell cell : result.rawCells()) {
System.out.println(
"行键:" + new String(CellUtil.cloneRow(cell)) + "\t" +
"列族:" + new String(CellUtil.cloneFamily(cell)) + "\t" +
"列名:" + new String(CellUtil.cloneQualifier(cell)) + "\t" +
"值:" + new String(CellUtil.cloneValue(cell)) + "\t" +
"时间戳:" + cell.getTimestamp());
}
// 关闭资源
table.close();
conn.close();
}
// 全表扫描
public static void scanTable(String tableName) throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 创建一个扫描对象
Scan scan = new Scan();
// 扫描全表输出结果
ResultScanner results = table.getScanner(scan);
for (Result result : results) {
for (Cell cell : result.rawCells()) {
System.out.println(
"行键:" + new String(CellUtil.cloneRow(cell)) + "\t" +
"列族:" + new String(CellUtil.cloneFamily(cell)) + "\t" +
"列名:" + new String(CellUtil.cloneQualifier(cell)) + "\t" +
"值:" + new String(CellUtil.cloneValue(cell)) + "\t" +
"时间戳:" + cell.getTimestamp());
}
}
// 关闭资源
results.close();
table.close();
conn.close();
}
// 删除一条数据
public static void delRow(String tableName, String rowKey) throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 删除数据
Delete delete = new Delete(Bytes.toBytes(rowKey));
table.delete(delete);
// 关闭资源
table.close();
conn.close();
}
// 删除多条数据
public static void delRows(String tableName, String[] rowkeys) throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 删除多条数据
List<Delete> list = new ArrayList<Delete>();
for (String row : rowkeys) {
Delete delete = new Delete(Bytes.toBytes(row));
list.add(delete);
}
table.delete(list);
// 关闭资源
table.close();
conn.close();
}
// 删除列族
public static void delColumnFamily(String tableName, String columnFamily) throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 创建一个数据库管理员
HBaseAdmin hAdmin = (HBaseAdmin) conn.getAdmin();
// 删除一个表的指定列族
hAdmin.deleteColumn(tableName, columnFamily);
// 关闭资源
conn.close();
}
// 删除数据库表
public static void deleteTable(String tableName) throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 创建一个数据库管理员
HBaseAdmin hAdmin = (HBaseAdmin) conn.getAdmin();
if (hAdmin.tableExists(tableName)) {
// 失效表
hAdmin.disableTable(tableName);
// 删除表
hAdmin.deleteTable(tableName);
System.out.println("删除" + tableName + "表成功");
conn.close();
} else {
System.out.println("需要删除的" + tableName + "表不存在");
conn.close();
System.exit();
}
}
// 追加插入(将原有value的后面追加新的value，如原有value=a追加value=bc则最后的value=abc)
public static void appendData(String tableName, String rowKey, String columnFamily, String column, String value)
throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 通过rowkey创建一个append对象
Append append = new Append(Bytes.toBytes(rowKey));
// 在append对象中设置列族、列、值
append.add(Bytes.toBytes(columnFamily), Bytes.toBytes(column), Bytes.toBytes(value));
// 追加数据
table.append(append);
// 关闭资源
table.close();
conn.close();
}
// 符合条件后添加数据(只能针对某一个rowkey进行原子操作)
public static boolean checkAndPut(String tableName, String rowKey, String columnFamilyCheck, String columnCheck, String valueCheck, String columnFamily, String column, String value) throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 设置需要添加的数据
Put put = new Put(Bytes.toBytes(rowKey));
put.addColumn(Bytes.toBytes(columnFamily), Bytes.toBytes(column), Bytes.toBytes(value));
// 当判断条件为真时添加数据
boolean result = table.checkAndPut(Bytes.toBytes(rowKey), Bytes.toBytes(columnFamilyCheck),
Bytes.toBytes(columnCheck), Bytes.toBytes(valueCheck), put);
// 关闭资源
table.close();
conn.close(); return result;
}
// 符合条件后刪除数据(只能针对某一个rowkey进行原子操作)
public static boolean checkAndDelete(String tableName, String rowKey, String columnFamilyCheck, String columnCheck,
String valueCheck, String columnFamily, String column) throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 设置需要刪除的delete对象
Delete delete = new Delete(Bytes.toBytes(rowKey));
delete.addColumn(Bytes.toBytes(columnFamilyCheck), Bytes.toBytes(columnCheck));
// 当判断条件为真时添加数据
boolean result = table.checkAndDelete(Bytes.toBytes(rowKey), Bytes.toBytes(columnFamilyCheck), Bytes.toBytes(columnCheck),
Bytes.toBytes(valueCheck), delete);
// 关闭资源
table.close();
conn.close(); return result;
}
// 计数器(amount为正数则计数器加，为负数则计数器减，为0则获取当前计数器的值)
public static long incrementColumnValue(String tableName, String rowKey, String columnFamily, String column, long amount)
throws IOException {
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(tableName));
// 计数器
long result = table.incrementColumnValue(Bytes.toBytes(rowKey), Bytes.toBytes(columnFamily), Bytes.toBytes(column), amount);
// 关闭资源
table.close();
conn.close(); return result;
}
内置过滤器的使用
HBase为筛选数据提供了一组过滤器，通过这个过滤器可以在HBase中数据的多个维度（行、列、数据版本）上进行对数据的筛选操作，也就是说过滤器最终能够筛选的数据能够细化到具体的一个存储单元格上（由行键、列名、时间戳定位）。通常来说，通过行键、值来筛选数据的应用场景较多。需要说明的是，过滤器会极大地影响查询效率。所以，在数据量较大的数据表中，应尽量避免使用过滤器。
下面介绍一些常用的HBase内置过滤器的用法：
1、RowFilter：筛选出匹配的所有的行。使用BinaryComparator可以筛选出具有某个行键的行，或者通过改变比较运算符（下面的例子中是CompareFilter.CompareOp.EQUAL）来筛选出符合某一条件的多条数据，如下示例就是筛选出行键为row1的一行数据。
// 筛选出匹配的所有的行
Filter rf = new RowFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("row1")));
2、PrefixFilter：筛选出具有特定前缀的行键的数据。这个过滤器所实现的功能其实也可以由RowFilter结合RegexComparator来实现，不过这里提供了一种简便的使用方法，如下示例就是筛选出行键以row为前缀的所有的行。
// 筛选匹配行键的前缀成功的行
Filter pf = new PrefixFilter(Bytes.toBytes("row"));
3、KeyOnlyFilter：这个过滤器唯一的功能就是只返回每行的行键，值全部为空，这对于只关注于行键的应用场景来说非常合适，这样忽略掉其值就可以减少传递到客户端的数据量，能起到一定的优化作用。
// 返回所有的行键，但值全是空
Filter kof = new KeyOnlyFilter();
4、RandomRowFilter：按照一定的几率（<=0会过滤掉所有的行，>=1会包含所有的行）来返回随机的结果集，对于同样的数据集，多次使用同一个RandomRowFilter会返回不同的结果集，对于需要随机抽取一部分数据的应用场景，可以使用此过滤器。
// 随机选出一部分的行
Filter rrf = new RandomRowFilter((float) 0.8);
5、InclusiveStopFilter：扫描的时候，我们可以设置一个开始行键和一个终止行键，默认情况下，这个行键的返回是前闭后开区间，即包含起始行，但不包含终止行。如果我们想要同时包含起始行和终止行，那么可以使用此过滤器。
// 包含了扫描的上限在结果之内
Filter isf = new InclusiveStopFilter(Bytes.toBytes("row1"));
6、FirstKeyOnlyFilter：如果想要返回的结果集中只包含第一列的数据，那么这个过滤器能够满足要求。它在找到每行的第一列之后会停止扫描，从而使扫描的性能也得到了一定的提升。
// 筛选出每行的第一个单元格
Filter fkof = new FirstKeyOnlyFilter();
7、ColumnPrefixFilter：它按照列名的前缀来筛选单元格，如果我们想要对返回的列的前缀加以限制的话，可以使用这个过滤器。
// 筛选出前缀匹配的列
Filter cpf = new ColumnPrefixFilter(Bytes.toBytes("qual1"));
8、ValueFilter：按照具体的值来筛选单元格的过滤器，这会把一行中值不能满足的单元格过滤掉，如下面的构造器，对于每一行的一个列，如果其对应的值不包含ROW2_QUAL1，那么这个列就不会返回给客户端。
// 筛选某个（值的条件满足的）特定的单元格
Filter vf = new ValueFilter(CompareFilter.CompareOp.EQUAL, new SubstringComparator("ROW2_QUAL1"));
9、ColumnCountGetFilter：这个过滤器在遇到一行的列数超过我们所设置的限制值的时候，结束扫描操作。
// 如果突然发现一行中的列数超过设定的最大值时，整个扫描操作会停止
Filter ccf = new ColumnCountGetFilter(2);
10、SingleColumnValueFilter：用一列的值决定这一行的数据是否被过滤，可对它的对象调用setFilterIfMissing方法，默认的参数是false。其作用是，对于咱们要使用作为条件的列，如果参数为true，这样的行将会被过滤掉，如果参数为false，这样的行会包含在结果集中。
// 将满足条件的列所在的行过滤掉
SingleColumnValueFilter scvf = new SingleColumnValueFilter(
• Bytes.toBytes("colfam1"),
• Bytes.toBytes("qual2"),
• CompareFilter.CompareOp.NOT_EQUAL,
• new SubstringComparator("BOGUS"));
scvf.setFilterIfMissing(true);
11、SingleColumnValueExcludeFilter：这个过滤器与第10种过滤器唯一的区别就是，作为筛选条件的列，其行不会包含在返回的结果中。
12、SkipFilter：这是一种附加过滤器，其与ValueFilter结合使用，如果发现一行中的某一列不符合条件，那么整行就会被过滤掉。
// 发现某一行中的一列需要过滤时，整个行就会被过滤掉
Filter skf = new SkipFilter(vf);
13、WhileMatchFilter：使用这个过滤器，当遇到不符合设定条件的数据的时候，整个扫描结束。
// 当遇到不符合过滤器rf设置的条件时，整个扫描结束
Filter wmf = new WhileMatchFilter(rf);
14. FilterList：可以用于综合使用多个过滤器。其有两种关系： Operator.MUST_PASS_ONE表示关系AND，Operator.MUST_PASS_ALL表示关系OR，并且FilterList可以嵌套使用，使得我们能够表达更多的需求。
// 综合使用多个过滤器，AND和OR两种关系
List<Filter> filters = new ArrayList<Filter>();
filters.add(rf);
filters.add(vf);
FilterList fl = new FilterList(FilterList.Operator.MUST_PASS_ALL,filters);
下面给出一个使用RowFilter过滤器的完整示例：
public class HBaseFilter {
private static final String TABLE_NAME = "table1";
public static void main(String[] args) throws IOException {
// 设置配置
Configuration conf = HBaseConfiguration.create();
conf.set("hbase.zookeeper.quorum", "localhost");
conf.set("hbase.zookeeper.property.clientPort", "2181");
// 建立一个数据库的连接
Connection conn = ConnectionFactory.createConnection(conf);
// 获取表
HTable table = (HTable) conn.getTable(TableName.valueOf(TABLE_NAME));
// 创建一个扫描对象
Scan scan = new Scan();
// 创建一个RowFilter过滤器
Filter filter = new RowFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("abc")));
// 将过滤器加入扫描对象
scan.setFilter(filter);
// 输出结果
ResultScanner results = table.getScanner(scan);
for (Result result : results) {
for (Cell cell : result.rawCells()) {
System.out.println(
"行键:" + new String(CellUtil.cloneRow(cell)) + "\t" +
"列族:" + new String(CellUtil.cloneFamily(cell)) + "\t" +
"列名:" + new String(CellUtil.cloneQualifier(cell)) + "\t" +
"值:" + new String(CellUtil.cloneValue(cell)) + "\t" +
"时间戳:" + cell.getTimestamp());
}
}
// 关闭资源
results.close();
table.close();
conn.close();
}
}