HBase Java API 02：过滤器

HBase版本：1.2.6

1. HBase过滤器简介

(1) 过滤器简介

过滤器 解释
ColumnPrefixFilter 列前缀过滤器
TimestampsFilter 时间戳过滤器
PageFilter 分页过滤器
MultipleColumnPrefixFilter 复合列前缀过滤器
FamilyFilter 列簇过滤器
ColumnPaginationFilter
SingleColumnValueFilter 单列值过滤器
RowFilter 行健过滤器
QualifierFilter 列过滤器
ColumnRangeFilter
ValueFilter 值过滤器
PrefixFilter 前缀过滤器
SingleColumnValueExcludeFilter 单列值排除器
ColumnCountGetFilter
InclusiveStopFilter
DependentColumnFilter
FirstKeyOnlyFilter
KeyOnlyFilter

(2) 过滤器分类

类别 过滤器
比较过滤器 RowFilter、FamilyFilter、QualifierFilter、ValueFilter 等
专用过滤器 SingleColumnValueFilter、SingleColumnValueExcludeFilter、PrefixFilter、ColumnPrefixFilter、PageFilter 等

(3) 运算符种类

运算符 说明
LESS <
LESS_OR_EQUAL <=
EQUAL =
NOT_EQUAL !=
GREATER_OR_EQUAL >=
GREATER >
NO_OP 没有运算符

(4) 比较器种类

比较器 说明
BinaryComparator 按字节索引顺序比较指定字节数组，采用 Bytes.compareTo(byte[])
BinaryPrefixComparator 跟前面相同，只是比较左端的数据是否相同
BitComparator 按位比较
LongComparator 比较long型value
NullComparator 判断给定value的是否为空
RegexStringComparator 提供一个正则的比较器，仅支持 EQUAL 和 NOT_EQUAL 运算符
SubstringComparator 判断提供的子串是否出现在 value 中

(5) 使用比较过滤器的方法

2. 常见过滤器API

package com.aura.hbase.test;

import java.io.IOException;

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.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
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.Filter;
import org.apache.hadoop.hbase.filter.FilterList;
import org.apache.hadoop.hbase.filter.MultipleColumnPrefixFilter;
import org.apache.hadoop.hbase.filter.PageFilter;
import org.apache.hadoop.hbase.filter.PrefixFilter;
import org.apache.hadoop.hbase.filter.QualifierFilter;
import org.apache.hadoop.hbase.filter.RowFilter;
import org.apache.hadoop.hbase.filter.SingleColumnValueExcludeFilter;
import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
import org.apache.hadoop.hbase.filter.SubstringComparator;
import org.apache.hadoop.hbase.filter.ValueFilter;
import org.apache.hadoop.hbase.filter.BinaryComparator;
import org.apache.hadoop.hbase.filter.ColumnPrefixFilter;
import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
import org.apache.hadoop.hbase.filter.FamilyFilter;
import org.apache.hadoop.hbase.util.Bytes;
import org.junit.Test;

import com.aura.hbase.utils.HBasePrintUtil;

public class HBaseFilterTest {
    
    public static final String ZOOKEEPER_LIST = "node01:2181,node02:2181,node03:2181";
    public static final String TABLE_NAME = "user_info";
    public static Configuration conf = null;
    public static Admin admin = null;
    public static Table table = null;
    
    static {
        conf = HBaseConfiguration.create();
        conf.set("hbase.zookeeper.quorum", ZOOKEEPER_LIST);
        try {
            Connection conn = ConnectionFactory.createConnection(conf);
            admin = conn.getAdmin();
            table = conn.getTable(TableName.valueOf(TABLE_NAME));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    /*
     * 扫描全表，查寻指定列族的记录
     */
    @Test
    public void testScanWithFamily() throws Exception {
        Scan scan = new Scan();
        scan.addFamily("base_info".getBytes());
        ResultScanner scanner = table.getScanner(scan);
        HBasePrintUtil.printResultScanner(scanner);
    }
    
    /*
     * 扫描全表，查寻指定列族、指定列的记录
     */
    @Test
    public void testScanWithColumn() throws Exception {
        Scan scan = new Scan();
        scan.addColumn("base_info".getBytes(), "name".getBytes());
        ResultScanner scanner = table.getScanner(scan);
        HBasePrintUtil.printResultScanner(scanner);
    }
    
    /*
     * 扫描全表，查寻指定时间戳或指定时间戳范围的记录
     */
    @Test
    public void testScanWithTimestamp() throws Exception {
        Scan scan = new Scan();
        
        // 指定时间戳，查出一条
        // scan.setTimeStamp(1514443301587L);
        
        // 指定时间戳范围，查出一条或多条
        scan.setTimeRange(1514443301340L, 1514443301587L);
        ResultScanner scanner = table.getScanner(scan);
        HBasePrintUtil.printResultScanner(scanner);
    }
    
    /*
     * 扫描全表，查寻指定rowkey或rowkey范围的记录
     */
    @Test
    public void testScanWithRowkey() throws Exception {
        Scan scan = new Scan();
        scan.setStartRow("baiyc_20150716_0003".getBytes());
        scan.setStopRow("baiyc_20150716_0005".getBytes());
        /*
         * 如果只设置了 startRow，就查询从startRow到表末尾的记录（不包括表最后的rowkey所在的那一行记录）
         * 如果只设置了 stopRow，就查询从表开头到stopRow的记录（不包括stopRow的那一行记录）
         */
        ResultScanner scanner = table.getScanner(scan);
        HBasePrintUtil.printResultScanner(scanner);
    }
    
    /*
     * 测试RowFilter
     * 扫描全表，查寻rowkey小于等于"baiyc_20150716_0003"的记录
     */
    @Test
    public void testRowFilter() throws Exception {
        Scan scan = new Scan();
        Filter filter = new RowFilter(CompareOp.LESS_OR_EQUAL, new BinaryComparator(Bytes.toBytes("baiyc_20150716_0003")));
        scan.setFilter(filter); 
        ResultScanner scanner = table.getScanner(scan);
        HBasePrintUtil.printResultScanner(scanner);
    }
    
    /*
     * 测试FamilyFilter
     * 扫描全表，查寻列簇大于"base_info"的记录
     */
    @Test
    public void testFamilyFilter() throws Exception {
        Scan scan = new Scan();
        Filter filter = new FamilyFilter(CompareOp.GREATER, new BinaryComparator(Bytes.toBytes("base_info")));
        scan.setFilter(filter); 
        ResultScanner scanner = table.getScanner(scan);
        HBasePrintUtil.printResultScanner(scanner);
    }
    
    /*
     * 测试QualifierFilter
     * 扫描全表，查寻列名等于"name"的记录
     */
    @Test
    public void testQualifierFilter() throws Exception {
        Scan scan = new Scan();
        Filter filter = new QualifierFilter(CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("name")));
        /* 
         * BinaryComparator比较器：匹配完全等值的列名
         * Filter filter = new QualifierFilter(CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes("name")));
         * 
         * BinaryPrefixComparator比较器：匹配列名的前缀为"na"的记录
         * Filter filter = new QualifierFilter(CompareOp.EQUAL, new BinaryPrefixComparator(Bytes.toBytes("na")));
         * 
         * RegexStringComparator比较器：匹配列名满足正则表达式"na."的记录
         * Filter filter = new QualifierFilter(CompareOp.EQUAL, new RegexStringComparator("na."));
         */
        scan.setFilter(filter); 
        ResultScanner scanner = table.getScanner(scan);
        HBasePrintUtil.printResultScanner(scanner);
    }
    
    /*
     * 测试ValueFilter
     * 扫描全表，查寻列的值中包含"mus"子串的记录
     */
    @Test
    public void testValueFilter() throws Exception {
        Scan scan = new Scan();
        Filter filter = new ValueFilter(CompareOp.EQUAL, new SubstringComparator("mus"));
        scan.setFilter(filter); 
        ResultScanner scanner = table.getScanner(scan);
        HBasePrintUtil.printResultScanner(scanner);
    }
    
    /*
     * 测试FilterList
     * 同时添加多个过滤器
     */
    @Test
    public void testFilterList() throws Exception {
        Scan scan = new Scan();
        Filter filter1 = new FamilyFilter(CompareOp.GREATER, new BinaryComparator(Bytes.toBytes("base_info")));
        Filter filter2 = new ValueFilter(CompareOp.NOT_EQUAL, new BinaryComparator(Bytes.toBytes("music")));
        FilterList list = new FilterList(filter1, filter2);
        scan.setFilter(list); 
        ResultScanner scanner = table.getScanner(scan);
        HBasePrintUtil.printResultScanner(scanner);
    }
    
    /*
     * 测试PageFilter
     * 分页过滤器，从指定rowkey开始，显示指定的条数
     */
    @Test
    public void testPageFilter() throws Exception {
        Scan scan = new Scan();
        // 设置每页显示4页
        Filter filter = new PageFilter(4);
        // 设置起始的rowkey
        scan.setStartRow("baiyc_20150716_0003".getBytes());
        scan.setFilter(filter);
        ResultScanner scanner = table.getScanner(scan);
        HBasePrintUtil.printResultScanner(scanner);
    }
    
    /*
     * 测试SingleColumnValueFilter：单列值过滤器，会返回满足条件的整行
     * 扫描全表，查询列族为"base_info"，列名为"name"，且列值包括"zhangsan"子串的所有行
     */
    @Test
    public void testSingleColumnValueFilter() throws Exception {
        Scan scan = new Scan();
        SingleColumnValueFilter filter = new SingleColumnValueFilter(
                Bytes.toBytes("base_info"),
                Bytes.toBytes("name"),
                CompareOp.EQUAL,
                new SubstringComparator("zhangsan"));
        /*
         * 如果不设置为 true，则那些不包含指定column的行也会返回
         * 比如，现在有一行它没有"name"这个列，它的所有的列值中也不包括"shangsan"这个子串，那么这一行也会返回
         * 设置为true，只会返回那些有"name"这个列，并且满足过滤条件的行
         */
        filter.setFilterIfMissing(true); 
        scan.setFilter(filter); 
        ResultScanner scanner = table.getScanner(scan);
        HBasePrintUtil.printResultScanner(scanner);
    }
    
    /*
     * 测试SingleColumnValueExcludeFilter：单列值排除器，返回排除了该列的结果
     * 与上面的过滤器查询出来的行相同，但不打印"name"那一列
     */
    @Test
    public void testSingleColumnValueExcludeFilter() throws Exception {
        Scan scan = new Scan();
        SingleColumnValueExcludeFilter filter = new SingleColumnValueExcludeFilter(
                Bytes.toBytes("base_info"),
                Bytes.toBytes("name"),
                CompareOp.EQUAL,
                new SubstringComparator("zhangsan"));
        filter.setFilterIfMissing(true); 
        scan.setFilter(filter); 
        ResultScanner scanner = table.getScanner(scan);
        HBasePrintUtil.printResultScanner(scanner);
    }
    
    /*
     * 测试PrefixFilter：前缀过滤器，针对行键
     * 扫描全表：查询rowkey的前缀为"baiyc"的全部行
     */
    @Test
    public void testPrefixFilter() throws Exception {
        Scan scan = new Scan();
        Filter filter = new PrefixFilter(Bytes.toBytes("baiyc"));
        scan.setFilter(filter);
        ResultScanner scanner = table.getScanner(scan);
        HBasePrintUtil.printResultScanner(scanner);
    }
    
    /*
     * 测试ColumnPrefixFilter：列前缀过滤器 
     * 扫描全表：查询列名的前缀为"na"的全部记录
     */
    @Test
    public void testColumnPrefixFilter() throws Exception {
        Scan scan = new Scan();
        Filter filter = new ColumnPrefixFilter(Bytes.toBytes("na"));
        scan.setFilter(filter); 
        ResultScanner scanner = table.getScanner(scan);
        HBasePrintUtil.printResultScanner(scanner);
    }
    
    /*
     * 测试MultipleColumnPrefixFilter：基于列名设置多个前缀过滤数据
     * 扫描全表：查询列名的前缀为"na"和列名的前缀为"ag"的全部记录
     */
    @Test
    public void testMultipleColumnPrefixFilter() throws Exception {
        Scan scan = new Scan();
        byte[][] prefixes = new byte[][] {Bytes.toBytes("na"), Bytes.toBytes("ag")};
        Filter filter = new MultipleColumnPrefixFilter(prefixes);
        scan.setFilter(filter);
        ResultScanner scanner = table.getScanner(scan);
        HBasePrintUtil.printResultScanner(scanner);
    }
}
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 136,179评论 19赞 139
  • Hbase过滤器使用
    基于列过滤的过滤器 1，ColumnPaginationFilter列分页过滤器：基于列进行分页，需要设置偏移量与...
    Coffeelong阅读 10,735评论 0赞 7
  • 母亲节方案分析
    今年母亲节，应该卖什么？ 先了解其他花店推出的主打商品 第一位野兽派 第二位花点时间 第三位花加 其他地域性花店（...
    奔跑的CY阅读 3,038评论 0赞 1
  • 第106天，脾气
    来自野火无尽生第106天作业， 《来吧，说说你的脾气》，我的脾气表面很好，但是容易走极端。我会人敬我一尺，我敬人一...
    野火无尽生阅读 1,648评论 0赞 0
  • 清欢
    轻轻地，伸出脚尖，点一下水面，漾开一圈涟漪。凉凉的，由脚尖传遍全身，令人不禁一声叹息。 兴从中来，撩起水花，泼向石...
    身在庐山阅读 2,649评论 4赞 4

友情链接更多精彩内容