Hbase的过滤器

Hbase的过滤器

1. 导入依赖

<dependencies>
    <dependency>
        <groupId>org.apache.hbase</groupId>
        <artifactId>hbase-client</artifactId>
        <version>1.2.1</version>
    </dependency>
</dependencies>

1.1 数据

hbase(main):002:0> scan 'emp'
ROW                         COLUMN+CELL
 001                        column=f1:dept, timestamp=1594783456247, value=c
 001                        column=f1:job, timestamp=1594783456247, value=big
 001                        column=f1:name, timestamp=1594783456247, value=syh
 001                        column=f1:salary, timestamp=1594783456247, value=33000
 002                        column=f1:dept, timestamp=1594783521464, value=a
 002                        column=f1:job, timestamp=1594783521464, value=big
 002                        column=f1:name, timestamp=1594783521464, value=lj
 002                        column=f1:salary, timestamp=1594783521464, value=40000
 003                        column=f1:dept, timestamp=1594783545987, value=a
 003                        column=f1:job, timestamp=1594783545987, value=big
 003                        column=f1:name, timestamp=1594783545987, value=aj
 003                        column=f1:salary, timestamp=1594783545987, value=80000
 004                        column=f1:dept, timestamp=1594783583706, value=b
 004                        column=f1:job, timestamp=1594783583706, value=java
 004                        column=f1:name, timestamp=1594783583706, value=lsd
 004                        column=f1:salary, timestamp=1594783583706, value=23000

2. ColumnValue列值

2.1 SingleColumnValueFilter ：单列过滤器

/**
     * 查询工资大于10000的人
     * SingleColumnValueFilter
     */
    @Test
    public void filter() throws IOException {
        // 1. 获取表
        Table table = HbaseOver.getTable("emp");
        // 2. 查询并给出条件
        // 2.1 创建过滤器 f1：为列簇，第二个参数是比较规则，dept：列名，20000：列值
        SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(
                Bytes.toBytes("f1"),
                Bytes.toBytes("dept"),
                CompareFilter.CompareOp.GREATER,
                Bytes.toBytes("20000"));
        Scan scan = new Scan();
        // 设置过滤器
        scan.setFilter(singleColumnValueFilter);

        // 3. 执行查询
        ResultScanner scanner = table.getScanner(scan);
        // 4. 打印
        HbaseOver.println(scanner);
    }

-- 结果
f1	dept	001	c	
f1	job	001	big	
f1	name	001	syh	
f1	salary	001	33000	
f1	dept	002	a	
f1	job	002	big	
f1	name	002	lj	
f1	salary	002	40000	
f1	dept	003	a	
f1	job	003	big	
f1	name	003	aj	
f1	salary	003	80000	
f1	dept	004	b	
f1	job	004	java	
f1	name	004	lsd	
f1	salary	004	23000

2.2 filterList ：多个过滤器集合

/**
     * 查询工资大于10000的而且工作是big的
     */
    @Test
    public void filterList() throws IOException {
        // 1. 获取表
        Table emp = HbaseOver.getTable("emp");
        // 2. 查询并给出条件
        // 2.1 创建过滤器
        SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(
                Bytes.toBytes("f1"),
                Bytes.toBytes("dept"),
                CompareFilter.CompareOp.GREATER,
                Bytes.toBytes("10000")
        );
        SingleColumnValueFilter singleColumnValueFilter1 = new SingleColumnValueFilter(
                Bytes.toBytes("f1"),
                Bytes.toBytes("job"),
                CompareFilter.CompareOp.EQUAL,
                Bytes.toBytes("big")
        );
        singleColumnValueFilter.setFilterIfMissing(true);
        singleColumnValueFilter1.setFilterIfMissing(true);
        // 2.2 两个单列值过滤器合并成一个过滤器链
        FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL, singleColumnValueFilter, singleColumnValueFilter1);

        Scan scan = new Scan();
        // 设置过滤器
        scan.setFilter(filterList);
        // 3.执行查询
        ResultScanner scanner = emp.getScanner(scan);
        // 4.打印
        HbaseOver.println(scanner);
    }

-- 结果
f1	dept	001	c	
f1	job	001	big	
f1	name	001	syh	
f1	salary	001	33000	
f1	dept	002	a	
f1	job	002	big	
f1	name	002	lj	
f1	salary	002	40000	
f1	dept	003	a	
f1	job	003	big	
f1	name	003	aj	
f1	salary	003	80000

2.3 ColumnValueFilter列值过滤器

/**
 *ColumnValueFilter过滤的如果是name，就只能查询出name的kv。SingleColumnValueFilter除了把自己本身 
 *过滤的列查询出来，还可以将整个这个name对应的rowkey的其他的列都查询出来
 */

3. Column Value Comparators列值比较器

3.1 RegexStringComparator正则表达式比较器

    /**
     * 模糊查询
     * 使用的是正则比较器（name中有l的数据）
     */
    @Test
    public void regexStringComparator() throws IOException {
        // 1. 获取表
        Table table = HbaseOver.getTable("emp");
        // 2. 设置正则比较器
        RegexStringComparator regexStringComparator = new RegexStringComparator(".*l.*");
        // 3. 设置过滤器
        SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(
                Bytes.toBytes("f1"),
                Bytes.toBytes("name"),
                CompareFilter.CompareOp.EQUAL,
                regexStringComparator
        );
        // 获取scan对象
        Scan scan = new Scan();
        // 将scan对象通过过滤器，获取到的就是符号要求的
        scan.setFilter(singleColumnValueFilter);
        // 查询对象
        ResultScanner scanner = table.getScanner(scan);
        // 将对象打印出来
        HbaseOver.println(scanner);
        // 关闭
        HbaseOver.closeTable(table);
    }

-- 结果
f1	dept	002	a	
f1	job	002	big	
f1	name	002	lj	
f1	salary	002	40000	
f1	dept	004	b	
f1	job	004	java	
f1	name	004	lsd	
f1	salary	004	23000

3.2 Substring Comparator字符串比较器

/**
     * 字符串比较器（这里使用的是模糊查询）
     * name中含有'l'的
     */
    @Test
    public void substringComparator() throws IOException {
        // 获取表
        Table table = HbaseOver.getTable("emp");
        // 设置比较器
        SubstringComparator substringComparator = new SubstringComparator("l");
        // 将比较器做为过滤器的条件
        SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(
                Bytes.toBytes("f1"),
                Bytes.toBytes("name"),
                CompareFilter.CompareOp.EQUAL,
                substringComparator
        );
        Scan scan = new Scan();
        scan.setFilter(singleColumnValueFilter);
        ResultScanner scanner = table.getScanner(scan);
        HbaseOver.println(scanner);
        HbaseOver.closeTable(table);
    }

-- 结果
f1	dept	002	a	
f1	job	002	big	
f1	name	002	lj	
f1	salary	002	40000	
f1	dept	004	b	
f1	job	004	java	
f1	name	004	lsd	
f1	salary	004	23000

3.3 Binary Comparator二进制比较器

    /**
     * 二进制比较器
     * 比较dept大于10000的
     */
    @Test
    public void binaryComparator() throws IOException {
        // 获取表
        Table emp = HbaseOver.getTable("emp");
        // 创建比较器
        BinaryComparator binaryComparator = new BinaryComparator(Bytes.toBytes("10000"));
        // 设置过滤器
        SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(
                Bytes.toBytes("f1"),
                Bytes.toBytes("dept"),
                CompareFilter.CompareOp.GREATER,
                binaryComparator
        );
        // 获取Scan对象
        Scan scan = new Scan();
        // 设置过滤器
        scan.setFilter(singleColumnValueFilter);
        ResultScanner scanner = emp.getScanner(scan);
        HbaseOver.println(scanner);
        HbaseOver.closeTable(emp);
    }

-- 结果
f1	dept	001	c	
f1	job	001	big	
f1	name	001	syh	
f1	salary	001	33000	
f1	dept	002	a	
f1	job	002	big	
f1	name	002	lj	
f1	salary	002	40000	
f1	dept	003	a	
f1	job	003	big	
f1	name	003	aj	
f1	salary	003	80000	
f1	dept	004	b	
f1	job	004	java	
f1	name	004	lsd	
f1	salary	004	23000	

4 KeyValue Metadata

4.1 FamilyFilter 列组过滤器

    /**
     * 列组过滤器
     * 查询列簇中名字带有"1"的数据
     */
    @Test
    public void familyFilter() throws IOException {
        Table table = HbaseOver.getTable("emp");
        BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator(Bytes.toBytes("1"));
        FamilyFilter familyFilter = new FamilyFilter(CompareFilter.CompareOp.EQUAL,binaryPrefixComparator);
        Scan scan = new Scan();
        ResultScanner scanner = table.getScanner(scan);
        HbaseOver.println(scanner);
        HbaseOver.closeTable(table);
    }


-- 结果
f1	dept	001	c	
f1	job	001	big	
f1	name	001	syh	
f1	salary	001	33000	
f1	dept	002	a	
f1	job	002	big	
f1	name	002	lj	
f1	salary	002	40000	
f1	dept	003	a	
f1	job	003	big	
f1	name	003	aj	
f1	salary	003	80000	
f1	dept	004	b	
f1	job	004	java	
f1	name	004	lsd	
f1	salary	004	23000

4.2 QualifierFilter 列字段过滤器

 	/**
 	 * 列字段过滤器
     * 查询所有的job的字段信息
     * 只查询出含有job的kv对
     */
    @Test
    public void qualifierFilter() throws IOException {
        Table emp = HbaseOver.getTable("emp");
        BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator(Bytes.toBytes("job"));
        QualifierFilter qualifierFilter = new QualifierFilter(CompareFilter.CompareOp.EQUAL,binaryPrefixComparator);
        Scan scan = new Scan();
        scan.setFilter(qualifierFilter);
        ResultScanner scanner = emp.getScanner(scan);
        HbaseOver.println(scanner);
        HbaseOver.closeTable(emp);
    }

-- 结果
f1	job	001	big	
f1	job	002	big	
f1	job	003	big	
f1	job	004	java

4.3 ColumnPrefixFilter 列前缀过滤器

	/**
     * 列前缀过滤器
     * 获取前缀是'j'的列名的kv对
     */
    @Test
    public void columnPrefixFilter() throws IOException {
        Table emp = HbaseOver.getTable("emp");
        ColumnPrefixFilter columnPrefixFilter = new ColumnPrefixFilter(Bytes.toBytes("j"));
        Scan scan = new Scan();
        scan.setFilter(columnPrefixFilter);
        ResultScanner scanner = emp.getScanner(scan);
        HbaseOver.println(scanner);
        HbaseOver.closeTable(emp);
    }

-- 结果
f1	job	001	big	
f1	job	002	big	
f1	job	003	big	
f1	job	004	java

4.4 MultipleColumnPrefixFilter 多列前缀过滤器

/**
     * 多列前缀过滤器，
     * 查询的是前缀是"j","n"开头的列名的kv对
     * @throws IOException
     */
    @Test
    public void multipleColumnPrefixFilter() throws IOException {
        Table emp = HbaseOver.getTable("emp");
        byte[][] bytes ={Bytes.toBytes("j"),Bytes.toBytes("n")};
        MultipleColumnPrefixFilter multipleColumnPrefixFilter = new MultipleColumnPrefixFilter(bytes);
        Scan scan = new Scan();
        scan.setFilter(multipleColumnPrefixFilter);
        ResultScanner scanner = emp.getScanner(scan);
        HbaseOver.println(scanner);
        HbaseOver.closeTable(emp);
    }

-- 结果
f1	job	001	big	
f1	name	001	syh	
f1	job	002	big	
f1	name	002	lj	
f1	job	003	big	
f1	name	003	aj	
f1	job	004	java	
f1	name	004	lsd

```java
在这里插入代码片

### 4.5 ColumnRangeFilter 列范围过滤器

```java
/**
     * 列范围过滤器。true是包含的意思，false是不包含的意思
     * 查询的是每个行键中的
     * @throws IOException
     */
    @Test
    public void columnRangeFilter() throws IOException {
        Table table = HbaseOver.getTable("emp");
        ColumnRangeFilter columnRangeFilter = new ColumnRangeFilter(Bytes.toBytes("dept"),true,
                Bytes.toBytes("salary"),false);
        Scan scan = new Scan();
        scan.setFilter(columnRangeFilter);
        ResultScanner scanner = table.getScanner(scan);
        HbaseOver.println(scanner);
        HbaseOver.closeTable(table);
    }

-- 结果
f1	dept	001	c	
f1	job	001	big	
f1	name	001	syh	
f1	dept	002	a	
f1	job	002	big	
f1	name	002	lj	
f1	dept	003	a	
f1	job	003	big	
f1	name	003	aj	
f1	dept	004	b	
f1	job	004	java	
f1	name	004	lsd	

5 RowFilter

5.1 RowFilter 行过滤器

    /**
     * 查询指定的行键的值
     * 取行键为"004"的数据
     * @throws IOException
     */
    @Test
    public void rowFilter() throws IOException {
        Table table = HbaseOver.getTable("emp");
        BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator(Bytes.toBytes("004"));
        RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.EQUAL,binaryPrefixComparator);
        Scan scan = new Scan();
        scan.setFilter(rowFilter);
        ResultScanner scanner = table.getScanner(scan);
        HbaseOver.println(scanner);
        HbaseOver.closeTable(table);
    }
-- 结果
f1	dept	004	b	
f1	job	004	java	
f1	name	004	lsd	
f1	salary	004	23000

5.2 KistKeyOnlyFilter

    /**
     * 查询第一个列簇中的每一个行键中的第一个kv对
     * @throws IOException
     */
    @Test
    public void fistKeyOnlyFilter() throws IOException {
        Table table = HbaseOver.getTable("emp");
        FirstKeyOnlyFilter firstKeyOnlyFilter = new FirstKeyOnlyFilter();
        Scan scan = new Scan();
        scan.setFilter(firstKeyOnlyFilter);
        ResultScanner scanner = table.getScanner(scan);
        HbaseOver.println(scanner);
        HbaseOver.closeTable(table);
    }

-- 结果
f1	dept	001	c	
f1	dept	002	a	
f1	dept	003	a	
f1	dept	004	b