HBase内置过滤器的一些总结

骑猪看日落 2022-08-19 14:16 148阅读 0赞

HBase为筛选数据提供了一组过滤器，通过这个过滤器可以在HBase中的数据的多个维度（行，列，数据版本）上进行对数据的筛选操作，也就是说过滤器最终能够筛选的数据能够细化到具体的一个存储单元格上（由行键，列明，时间戳定位）。通常来说，通过行键，值来筛选数据的应用场景较多。

1. RowFilter：筛选出匹配的所有的行，对于这个过滤器的应用场景，是非常直观的：使用BinaryComparator可以筛选出具有某个行键的行，或者通过改变比较运算符（下面的例子中是CompareFilter.CompareOp.EQUAL）来筛选出符合某一条件的多条数据，以下就是筛选出行键为row1的一行数据：

**\[java\]**  [view plain][] [copy][view plain]

1.  Filter rf = **new** RowFilter(CompareFilter.CompareOp.EQUAL, **new** BinaryComparator(Bytes.toBytes("row1"))); // OK 筛选出匹配的所有的行

2. PrefixFilter：筛选出具有特定前缀的行键的数据。这个过滤器所实现的功能其实也可以由RowFilter结合RegexComparator来实现，不过这里提供了一种简便的使用方法，以下过滤器就是筛选出行键以row为前缀的所有的行：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  Filter pf = **new** PrefixFilter(Bytes.toBytes("row")); // OK  筛选匹配行键的前缀成功的行

3. KeyOnlyFilter：这个过滤器唯一的功能就是只返回每行的行键，值全部为空，这对于只关注于行键的应用场景来说非常合适，这样忽略掉其值就可以减少传递到客户端的数据量，能起到一定的优化作用：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  Filter kof = **new** KeyOnlyFilter(); // OK 返回所有的行，但值全是空

4. RandomRowFilter：从名字上就可以看出其大概的用法，本过滤器的作用就是按照一定的几率（<=0会过滤掉所有的行，>=1会包含所有的行）来返回随机的结果集，对于同样的数据集，多次使用同一个RandomRowFilter会返回不通的结果集，对于需要随机抽取一部分数据的应用场景，可以使用此过滤器：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  Filter rrf = **new** RandomRowFilter((**float**) 0.8); // OK 随机选出一部分的行

5. InclusiveStopFilter：扫描的时候，我们可以设置一个开始行键和一个终止行键，默认情况下，这个行键的返回是前闭后开区间，即包含起始行，单不包含中指行，如果我们想要同时包含起始行和终止行，那么我们可以使用此过滤器：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  Filter isf = **new** InclusiveStopFilter(Bytes.toBytes("row1")); // OK 包含了扫描的上限在结果之内

6. FirstKeyOnlyFilter：如果你只想返回的结果集中只包含第一列的数据，那么这个过滤器能够满足你的要求。它在找到每行的第一列之后会停止扫描，从而使扫描的性能也得到了一定的提升：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  Filter fkof = **new** FirstKeyOnlyFilter(); // OK 筛选出第一个每个第一个单元格

7. ColumnPrefixFilter：顾名思义，它是按照列名的前缀来筛选单元格的，如果我们想要对返回的列的前缀加以限制的话，可以使用这个过滤器：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  Filter cpf = **new** ColumnPrefixFilter(Bytes.toBytes("qual1")); // OK 筛选出前缀匹配的列

8. ValueFilter：按照具体的值来筛选单元格的过滤器，这会把一行中值不能满足的单元格过滤掉，如下面的构造器，对于每一行的一个列，如果其对应的值不包含ROW2\_QUAL1，那么这个列就不会返回给客户端：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  Filter vf = **new** ValueFilter(CompareFilter.CompareOp.EQUAL, **new** SubstringComparator("ROW2\_QUAL1")); // OK 筛选某个（值的条件满足的）特定的单元格

9. ColumnCountGetFilter：这个过滤器来返回每行最多返回多少列，并在遇到一行的列数超过我们所设置的限制值的时候，结束扫描操作：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  Filter ccf = **new** ColumnCountGetFilter(2); // OK 如果突然发现一行中的列数超过设定的最大值时，整个扫描操作会停止

10. SingleColumnValueFilter：用一列的值决定这一行的数据是否被过滤。在它的具体对象上，可以调用setFilterIfMissing(true)或者setFilterIfMissing(false)，默认的值是false，其作用是，对于咱们要使用作为条件的列，如果这一列本身就不存在，那么如果为true，这样的行将会被过滤掉，如果为false，这样的行会包含在结果集中。

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  SingleColumnValueFilter scvf = **new** SingleColumnValueFilter(  
2.          Bytes.toBytes("colfam1"),   
3.          Bytes.toBytes("qual2"),   
4.          CompareFilter.CompareOp.NOT\_EQUAL,   
5.          **new** SubstringComparator("BOGUS"));  
6.  scvf.setFilterIfMissing(**false**);  
7.  scvf.setLatestVersionOnly(**true**); // OK

11.  SingleColumnValueExcludeFilter：这个与10种的过滤器唯一的区别就是，作为筛选条件的列的不会包含在返回的结果中。

12. SkipFilter：这是一种附加过滤器，其与ValueFilter结合使用，如果发现一行中的某一列不符合条件，那么整行就会被过滤掉：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  Filter skf = **new** SkipFilter(vf); // OK 发现某一行中的一列需要过滤时，整个行就会被过滤掉

13. WhileMatchFilter：这个过滤器的应用场景也很简单，如果你想要在遇到某种条件数据之前的数据时，就可以使用这个过滤器；当遇到不符合设定条件的数据的时候，整个扫描也就结束了：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  Filter wmf = **new** WhileMatchFilter(rf); // OK 类似于Python itertools中的takewhile

14. FilterList：用于综合使用多个过滤器。其有两种关系：FilterList.Operator.MUST\_PASS\_ONE和FilterList.Operator.MUST\_PASS\_ALL，默认的是FilterList.Operator.MUST\_PASS\_ALL，顾名思义，它们分别是AND和OR的关系，并且 FilterList可以嵌套使用FilterList，使我们能够表达更多的需求：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  List<Filter> filters = **new** ArrayList<Filter>();  
2.  filters.add(rf);  
3.  filters.add(vf);  
4.  FilterList fl = **new** FilterList(FilterList.Operator.MUST\_PASS\_ALL, filters); // OK 综合使用多个过滤器， AND 和 OR 两种关系

以上，是对于HBase内置的过滤器的部分总结，以下代码是数据写入代码：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **package** com.reyun.hbase;  
2.    
3.  **import** java.io.IOException;  
4.  **import** org.apache.hadoop.conf.Configuration;  
5.  **import** org.apache.hadoop.hbase.HBaseConfiguration;  
6.  **import** org.apache.hadoop.hbase.client.HTable;  
7.  **import** org.apache.hadoop.hbase.client.Put;  
8.  **import** org.apache.hadoop.hbase.util.Bytes;  
9.    
10. **public** **class** HBaseDataFeeding \{  
11.     **private** **final** **static** **byte**\[\] ROW1 = Bytes.toBytes("row1");  
12.     **private** **final** **static** **byte**\[\] ROW2 = Bytes.toBytes("row2");  
13.     **private** **final** **static** **byte**\[\] COLFAM1 = Bytes.toBytes("colfam1");  
14.     **private** **final** **static** **byte**\[\] COLFAM2 = Bytes.toBytes("colfam2");  
15.     **private** **final** **static** **byte**\[\] QUAL1 = Bytes.toBytes("qual1");  
16.     **private** **final** **static** **byte**\[\] QUAL2 = Bytes.toBytes("qual2");  
17.       
18.       
19.     **public** **static** **void** main(String\[\] args) **throws** IOException \{  
20.         Configuration conf = HBaseConfiguration.create();  
21.         HTable table = **new** HTable(conf, "testtable");  
22.         table.setAutoFlushTo(**false**);  
23.         Put put\_row1 = **new** Put(ROW1);  
24.         put\_row1.add(COLFAM1, QUAL1, Bytes.toBytes("ROW1\_QUAL1\_VAL"));  
25.         put\_row1.add(COLFAM1, QUAL2, Bytes.toBytes("ROW1\_QUAL2\_VAL"));  
26.           
27.         Put put\_row2 = **new** Put(ROW2);  
28.         put\_row2.add(COLFAM1, QUAL1, Bytes.toBytes("ROW2\_QUAL1\_VAL"));  
29.         put\_row2.add(COLFAM1, QUAL2, Bytes.toBytes("ROW2\_QUAL2\_VAL"));  
30.           
31.         **try**\{  
32.             table.put(put\_row1);  
33.             table.put(put\_row2);  
34.         \}**finally**\{  
35.             table.close();  
36.         \}  
37.     \}  
38.   
39. \}

以下是过滤器测试代码，可以通过修改代码，更换过滤器来看到具体的效果：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **package** com.reyun.hbase;  
2.    
3.  **import** java.io.IOException;  
4.  **import** java.util.ArrayList;  
5.  **import** java.util.List;  
6.    
7.  **import** org.apache.hadoop.conf.Configuration;  
8.  **import** org.apache.hadoop.hbase.Cell;  
9.  **import** org.apache.hadoop.hbase.CellUtil;  
10. **import** org.apache.hadoop.hbase.HBaseConfiguration;  
11. **import** org.apache.hadoop.hbase.client.HTable;  
12. **import** org.apache.hadoop.hbase.client.Result;  
13. **import** org.apache.hadoop.hbase.client.ResultScanner;  
14. **import** org.apache.hadoop.hbase.client.Scan;  
15. **import** org.apache.hadoop.hbase.filter.BinaryComparator;  
16. **import** org.apache.hadoop.hbase.filter.ColumnCountGetFilter;  
17. **import** org.apache.hadoop.hbase.filter.ColumnPrefixFilter;  
18. **import** org.apache.hadoop.hbase.filter.CompareFilter;  
19. **import** org.apache.hadoop.hbase.filter.Filter;  
20. **import** org.apache.hadoop.hbase.filter.FilterList;  
21. **import** org.apache.hadoop.hbase.filter.FirstKeyOnlyFilter;  
22. **import** org.apache.hadoop.hbase.filter.InclusiveStopFilter;  
23. **import** org.apache.hadoop.hbase.filter.KeyOnlyFilter;  
24. **import** org.apache.hadoop.hbase.filter.PageFilter;  
25. **import** org.apache.hadoop.hbase.filter.PrefixFilter;  
26. **import** org.apache.hadoop.hbase.filter.RandomRowFilter;  
27. **import** org.apache.hadoop.hbase.filter.RowFilter;  
28. **import** org.apache.hadoop.hbase.filter.SkipFilter;  
29. **import** org.apache.hadoop.hbase.filter.ValueFilter;  
30. **import** org.apache.hadoop.hbase.filter.SingleColumnValueFilter;  
31. **import** org.apache.hadoop.hbase.filter.SubstringComparator;  
32. **import** org.apache.hadoop.hbase.filter.WhileMatchFilter;  
33. **import** org.apache.hadoop.hbase.util.Bytes;  
34.   
35. **public** **class** HBaseScannerTest \{  
36.   
37.     **public** **static** **void** main(String\[\] args) **throws** IOException, IllegalAccessException \{  
38.         Configuration conf = HBaseConfiguration.create();  
39.         HTable table = **new** HTable(conf, "testtable");  
40.         table.setAutoFlushTo(**false**);  
41.           
42.         Scan scan1 = **new** Scan();  
43.         SingleColumnValueFilter scvf = **new** SingleColumnValueFilter(  
44.                 Bytes.toBytes("colfam1"),   
45.                 Bytes.toBytes("qual2"),   
46.                 CompareFilter.CompareOp.NOT\_EQUAL,   
47.                 **new** SubstringComparator("BOGUS"));  
48.         scvf.setFilterIfMissing(**false**);  
49.         scvf.setLatestVersionOnly(**true**); // OK  
50.         Filter ccf = **new** ColumnCountGetFilter(2); // OK 如果突然发现一行中的列数超过设定的最大值时，整个扫描操作会停止  
51.         Filter vf = **new** ValueFilter(CompareFilter.CompareOp.EQUAL, **new** SubstringComparator("ROW2\_QUAL1")); // OK 筛选某个（值的条件满足的）特定的单元格  
52.         Filter cpf = **new** ColumnPrefixFilter(Bytes.toBytes("qual2")); // OK 筛选出前缀匹配的列  
53.         Filter fkof = **new** FirstKeyOnlyFilter(); // OK 筛选出第一个每个第一个单元格  
54.         Filter isf = **new** InclusiveStopFilter(Bytes.toBytes("row1")); // OK 包含了扫描的上限在结果之内  
55.         Filter rrf = **new** RandomRowFilter((**float**) 0.8); // OK 随机选出一部分的行  
56.         Filter kof = **new** KeyOnlyFilter(); // OK 返回所有的行，但值全是空  
57.         Filter pf = **new** PrefixFilter(Bytes.toBytes("row")); // OK  筛选匹配行键的前缀成功的行  
58.         Filter rf = **new** RowFilter(CompareFilter.CompareOp.NOT\_EQUAL, **new** BinaryComparator(Bytes.toBytes("row1"))); // OK 筛选出匹配的所有的行  
59.         Filter wmf = **new** WhileMatchFilter(rf); // OK 类似于Python itertools中的takewhile  
60.         Filter skf = **new** SkipFilter(vf); // OK 发现某一行中的一列需要过滤时，整个行就会被过滤掉  
61.           
62.         List<Filter> filters = **new** ArrayList<Filter>();  
63.         filters.add(rf);  
64.         filters.add(vf);  
65.         FilterList fl = **new** FilterList(FilterList.Operator.MUST\_PASS\_ALL, filters); // OK 综合使用多个过滤器， AND 和 OR 两种关系  
66.           
67.         scan1.  
68.         setStartRow(Bytes.toBytes("row1")).  
69.         setStopRow(Bytes.toBytes("row3")).  
70.         setFilter(scvf);   
71.         ResultScanner scanner1 = table.getScanner(scan1);  
72.           
73.         **for**(Result res : scanner1)\{  
74.             **for**(Cell cell : res.rawCells())\{  
75.                 System.out.println("KV: " + cell + ", Value: " + Bytes.toString(CellUtil.cloneValue(cell)));  
76.             \}  
77.             System.out.println("------------------------------------------------------------");  
78.         \}  
79.           
80.         scanner1.close();  
81.         table.close();  
82.     \}  
83.    
84. \}

[view plain]: http://blog.csdn.net/cnweike/article/details/42920547#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/584516
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/584516/fork

发表评论取消回复

表情：

评论列表（有 0 条评论，148人围观）

还没有评论，来说两句吧...

相关阅读

相关 Spring Security内置过滤器详解

> 相关文章： > > 1. [OAuth2的定义和运行流程][OAuth2] > 2. [Spring Security OAuth实现Gitee快捷登录][Sprin

柔情只为你懂/ 2024年04月08日 08:22/ 0 赞/ 76 阅读

相关 Scala中的一些内置函数

Scala中的一些内置函数 1.将字符变为大写【toUpperCase】 val books = List("Hadoop", "Hive", "HDFS"

蔚落/ 2023年07月09日 11:25/ 0 赞/ 7 阅读

相关 hive 常用的一些内置函数

hive 常用的一些内置函数 nvl （UDF） substring （UDF） if （UDF） array\_contains（常和 if 一

谁借莪１个温暖的怀抱￠/ 2023年06月08日 14:56/ 0 赞/ 15 阅读

相关 HBase内置过滤器的一些总结

HBase为筛选数据提供了一组过滤器，通过这个过滤器可以在HBase中的数据的多个维度（行，列，数据版本）上进行对数据的筛选操作，也就是说过滤器最终能够筛选的数据能够细化到具体

骑猪看日落/ 2022年08月19日 14:16/ 0 赞/ 149 阅读

相关 angular ng的内置过滤器

ng的内置过滤器　　ng内置了九种过滤器，使用方法都非常简单，看文档即懂。不过为了以后不去翻它的文档，我在这里还是做一个详细的记录。　　1. currency (货币处

电玩女神/ 2022年05月27日 10:48/ 0 赞/ 193 阅读

相关 [Hbase]Hbase的过滤器分类

Hbase的过滤器分类 1、比较过滤器 1.1、行键过滤器RowFilter Filter filter1 = new RowFilter(Compare

桃扇骨/ 2022年05月08日 00:10/ 0 赞/ 211 阅读

相关 HBASE（三）—— HBase 的过滤器

HBase 的过滤器主要用来实现复杂查询的，类似 where 条件，常用的有以下几种：列值过滤器：SingleColumnValueFilter 列名前缀过滤器

叁歲伎倆/ 2022年04月11日 13:41/ 0 赞/ 289 阅读

相关 hbase安装（内置zk）

https://www.apache.org/dyn/closer.lua/hbase/2.2.0/hbase-2.2.0-bin.tar.gz 下载 wget -P /o

港控/mmm°/ 2021年12月12日 18:51/ 0 赞/ 289 阅读

相关 Spring Cloud Gateway内置过滤器实战——Hystrix过滤器

一代码位置 [https://github.com/cakin24/spring-cloud-code/tree/master/ch17-3/ch17-3-7-gatewa

亦凉/ 2021年07月25日 01:59/ 0 赞/ 537 阅读

相关 Spring Cloud Gateway内置过滤器实战——StripPrefix过滤器

一代码位置 [https://github.com/cakin24/spring-cloud-code/tree/master/ch17-3/ch17-3-5-gatewa

淡淡的烟草味﹌/ 2021年07月24日 14:41/ 0 赞/ 848 阅读