HBase过滤器（转载）

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

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

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

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

也可配合正则进行匹配查询，查询rowkey中以3结尾的数据：
Filter rf = new RowFilter(CompareFilter.CompareOp.EQUAL, new RegexStringComparator("^.*3$"));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		SingleColumnValueFilter scvf = new SingleColumnValueFilter(
				Bytes.toBytes("colfam1"),
				Bytes.toBytes("qual2"),
				CompareFilter.CompareOp.NOT_EQUAL,
				new SubstringComparator("BOGUS"));
		scvf.setFilterIfMissing(false);
		scvf.setLatestVersionOnly(true); // OK

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

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

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

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

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

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

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，使我们能够表达更多的需求：

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 两种关系

		List<Filter> filters = new ArrayList<Filter>();
		filters.add(rf);
		filters.add(vf);
		FilterList fl = new FilterList(FilterList.Operator.MUST_PASS_ALL, filters); // OK 综合使用多个过滤器， AND 和 OR 两种关系
	

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

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

package com.reyun.hbase;

import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.util.Bytes;

public class HBaseDataFeeding {
	private final static byte[] ROW1 = Bytes.toBytes("row1");
	private final static byte[] ROW2 = Bytes.toBytes("row2");
	private final static byte[] COLFAM1 = Bytes.toBytes("colfam1");
	private final static byte[] COLFAM2 = Bytes.toBytes("colfam2");
	private final static byte[] QUAL1 = Bytes.toBytes("qual1");
	private final static byte[] QUAL2 = Bytes.toBytes("qual2");

	public static void main(String[] args) throws IOException {
		Configuration conf = HBaseConfiguration.create();
		HTable table = new HTable(conf, "testtable");
		table.setAutoFlushTo(false);
		Put put_row1 = new Put(ROW1);
		put_row1.add(COLFAM1, QUAL1, Bytes.toBytes("ROW1_QUAL1_VAL"));
		put_row1.add(COLFAM1, QUAL2, Bytes.toBytes("ROW1_QUAL2_VAL"));

		Put put_row2 = new Put(ROW2);
		put_row2.add(COLFAM1, QUAL1, Bytes.toBytes("ROW2_QUAL1_VAL"));
		put_row2.add(COLFAM1, QUAL2, Bytes.toBytes("ROW2_QUAL2_VAL"));

		try{
			table.put(put_row1);
			table.put(put_row2);
		}finally{
			table.close();
		}
	}

}

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

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