Hbase过滤器

Hbase过滤器

HBase 的基本 API，包括增、删、改、查等。
增、删都是相对简单的操作，与传统的 RDBMS 相比，这里的查询操作略显苍白，只能根据特性的行键进行查询（Get）或者根据行键的范围来查询（Scan）。
HBase 不仅提供了这些简单的查询，而且提供了更加高级的过滤器（Filter）来查询。

过滤器可以根据列族、列、版本等更多的条件来对数据进行过滤，

基于 HBase 本身提供的三维有序（行键，列，版本有序），这些过滤器可以高效地完成查询过滤的任务，带有过滤器条件的 RPC 查询请求会把过滤器分发到各个 RegionServer（这是一个服务端过滤器），这样也可以降低网络传输的压力。

使用过滤器至少需要两类参数：

一类是抽象的操作符，另一类是比较器

作用

• 过滤器的作用是在服务端判断数据是否满足条件，然后只将满足条件的数据返回给客户端
• 过滤器的类型很多，但是可以分为三大类：
  • 比较过滤器：可应用于rowkey、列簇、列、列值过滤器
  • 专用过滤器：只能适用于特定的过滤器
  • 包装过滤器：包装过滤器就是通过包装其他过滤器以实现某些拓展的功能。

比较过滤器

所有比较过滤器均继承自 CompareFilter。创建一个比较过滤器需要两个参数，分别是比较运算符和比较器实例。

 public CompareFilter(final CompareOp compareOp,final ByteArrayComparable comparator) {
    this.compareOp = compareOp;
    this.comparator = comparator;
  }

比较运算符

• LESS <

• LESS_OR_EQUAL <=

• EQUAL =

• NOT_EQUAL <>

• GREATER_OR_EQUAL >=

• GREATER >

• NO_OP 排除所有

常见的六大比较过滤器

BinaryComparator

按字节索引顺序比较指定字节数组，采用Bytes.compareTo(byte[])

BinaryPrefixComparator

通BinaryComparator，只是比较左端前缀的数据是否相同

NullComparator

判断给定的是否为空

BitComparator

按位比较

RegexStringComparator

提供一个正则的比较器，仅支持 EQUAL 和非EQUAL

SubstringComparator

判断提供的子串是否出现在中

代码演示

rowKey过滤器：RowFilter 行键过滤器

通过RowFilter与BinaryComparator过滤比rowKey 1500100010小的所有值出来

package com.shujia.hbaseapi;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.filter.BinaryComparator;
import org.apache.hadoop.hbase.filter.CompareFilter;
import org.apache.hadoop.hbase.filter.RowFilter;
import org.apache.hadoop.hbase.util.Bytes;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.util.List;

public class HbaseComparatorFilter {
    HConnection conn = null;
    HBaseAdmin hadmin = null;


    @Before
    public void init() {
        try {
            //1、获取hadoop的相关环境
            Configuration conf = new Configuration();

            //2、设置zookeeper集群的配置
            conf.set("hbase.zookeeper.quorum", "node01,node02,master01");

            //3、获取hbase的连接对象
            conn = HConnectionManager.createConnection(conf);

            //4、获取HMaster的对象
            hadmin = new HBaseAdmin(conf);

            System.out.println("获取连接成功：" + hadmin);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 通过RowFilter与BinaryComparator过滤比rowKey 1500100010小的所有值出来
     */
    @Test
    public void rowFilerTest() {
        try {
            //获取表的实例
            HTableInterface students = conn.getTable("students");

            Scan scan = new Scan();

            //创建BinaryComparator比较器
            BinaryComparator binaryComparator = new BinaryComparator("1500100010".getBytes());

            //创建行键过滤器 RowFilter
            RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.LESS_OR_EQUAL, binaryComparator);
            scan.setFilter(rowFilter);
            ResultScanner scanner = students.getScanner(scan);
            print(scanner);


        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    @After
    public void close() {
        if (hadmin != null) {
            try {
                hadmin.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        if (conn != null) {
            try {
                conn.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }


    public void print(ResultScanner scanner) {
        try {
            Result rs = null;
            while ((rs = scanner.next()) != null) {
                String id = Bytes.toString(rs.getRow());
//                String name = Bytes.toString(rs.getValue("info".getBytes(), "姓名".getBytes()));
//                String age = Bytes.toString(rs.getValue("info".getBytes(), "年龄".getBytes()));
//                String gender = Bytes.toString(rs.getValue("info".getBytes(), "性别".getBytes()));
//                String clazz = Bytes.toString(rs.getValue("info".getBytes(), "班级".getBytes()));
//
//                System.out.println("学号：" + id + "，姓名：" + name + "，年龄：" + age + "，性别：" + gender + "，班级：" + clazz);、

                //上面的获取操作，是在我们知道一行列的个数以及列的名字的前提下使用的方式
                //当我们不知道列的个数以及列的名字的时候，该如何遍历呢？
                //因为hbase是列式存储数据库，每一行中的列的个数不一样也是很正常的情况
                //获取一行中的所有单元格
                List<Cell> cells = rs.listCells();
                StringBuilder sb = new StringBuilder();
                sb.append("行键：").append(id).append("\t");
                for (Cell cell : cells) {
                    //每个单元格中包含了rowkey,列簇，列名，版本号，列值
                    String qualifier = Bytes.toString(CellUtil.cloneQualifier(cell));
                    String value = Bytes.toString(CellUtil.cloneValue(cell));

                    sb.append(qualifier).append("：").append(value).append("\t");
                    String s = sb.toString();
                    sb = new StringBuilder();
                    System.out.print(s);
                }
                //遍历一行后换行
                System.out.println();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

列簇过滤器：FamilyFilter

通过FamilyFilter与SubstringComparator查询列簇名包含in的所有列簇下面的数据

    @Test
    public void familyFilterTest(){
        try {
            //获取表的实例
            HTableInterface students = conn.getTable("students");

            //创建扫描器对象
            Scan scan = new Scan();

            //创建包含比较器
            SubstringComparator substringComparator = new SubstringComparator("in");

            //创建列簇过滤器
            FamilyFilter familyFilter = new FamilyFilter(CompareFilter.CompareOp.EQUAL, substringComparator);
            scan.setFilter(familyFilter);
            ResultScanner scanner = students.getScanner(scan);
            print(scanner);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

通过FamilyFilter与 BinaryPrefixComparator 过滤出列簇以i开头的列簇下的所有数据

    @Test
    public void familyFilterTest2(){
        try {
            //获取表的实例
            HTableInterface students = conn.getTable("students");

            Scan scan = new Scan();

            //创建前缀比较器
            BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator("i".getBytes());
            //创建列簇过滤器
            FamilyFilter familyFilter = new FamilyFilter(CompareFilter.CompareOp.EQUAL, binaryPrefixComparator);
            scan.setFilter(familyFilter);


            ResultScanner scanner = students.getScanner(scan);
            print(scanner);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

列名过滤器：QualifierFilter

通过QualifierFilter与SubstringComparator查询列名包含ge的列的值

    @Test
    public void qualifierFilterTest(){
        try {
            //获取表的实例
            HTableInterface students = conn.getTable("students");

            //创建扫描器对象
            Scan scan = new Scan();

            //创建包含比较器
            SubstringComparator substringComparator = new SubstringComparator("班");

            //创建列名过滤器
            QualifierFilter qualifierFilter = new QualifierFilter(CompareFilter.CompareOp.EQUAL, substringComparator);

            scan.setFilter(qualifierFilter);

            ResultScanner scanner = students.getScanner(scan);

            print(scanner);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

过滤出列的名字中 包含 "别" 所有的列及列的值

列值过滤器：ValueFilter

通过ValueFilter与BinaryPrefixComparator过滤出所有的cell中值以 "张" 开头的学生

    @Test
    public void valueFilterTest() {
        try {
            //获取表的实例
            HTableInterface students = conn.getTable("students");

            //创建扫描器对象
            Scan scan = new Scan();

            //创建二进制前缀比较器
            BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator("张".getBytes());

            //创建列值过滤器
            ValueFilter valueFilter = new ValueFilter(CompareFilter.CompareOp.EQUAL, binaryPrefixComparator);

            scan.setFilter(valueFilter);

            ResultScanner scanner = students.getScanner(scan);
            print(scanner);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

过滤出文科的学生，只会返回以文科开头的数据列，其他列的数据不符合条件，不会返回

    @Test
    public void valueFilterTest() {
        try {
            //获取表的实例
            HTableInterface students = conn.getTable("students");

            //创建扫描器对象
            Scan scan = new Scan();

            //创建二进制前缀比较器
            BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator("文科".getBytes());

            //创建列值过滤器
            ValueFilter valueFilter = new ValueFilter(CompareFilter.CompareOp.EQUAL, binaryPrefixComparator);

            scan.setFilter(valueFilter);

            ResultScanner scanner = students.getScanner(scan);
            print(scanner);

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

专用过滤器

单列值过滤器：SingleColumnValueFilter

SingleColumnValueFilter会返回满足条件的cell所在行的所有cell的值（即会返回一行数据）

通过SingleColumnValueFilter与查询文科班所有学生信息

    @Test
    public void singleColumnValueFilterTest(){
        try {
            //获取表的实例
            HTableInterface students = conn.getTable("students");

            //创建扫描器对象
            Scan scan = new Scan();

            //使用前缀比较器
            BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator("文科".getBytes());

            //创建单列值过滤器
            SingleColumnValueFilter singleColumnValueFilter = new SingleColumnValueFilter(
                    "info".getBytes(),
                    "班级".getBytes(),
                    CompareFilter.CompareOp.EQUAL,
                    binaryPrefixComparator);

            scan.setFilter(singleColumnValueFilter);

            ResultScanner scanner = students.getScanner(scan);

            print(scanner);


        } catch (IOException e) {
            e.printStackTrace();
        }
    }

列值排除过滤器：SingleColumnValueExcludeFilter

与SingleColumnValueFilter相反，会排除掉指定的列，其他的列全部返回

通过SingleColumnValueExcludeFilter与BinaryComparator查询文科一班所有学生信息，最终不返回clazz列

    @Test
    public void singleColumnValueExcludeFilter(){
        try {
            //获取表的实例
            HTableInterface students = conn.getTable("students");

            //创建扫描器对象
            Scan scan = new Scan();

            //使用前缀比较器
            BinaryPrefixComparator binaryPrefixComparator = new BinaryPrefixComparator("文科".getBytes());

            //创建单列值过滤器
            SingleColumnValueExcludeFilter singleColumnValueExcludeFilter = new SingleColumnValueExcludeFilter(
                    "info".getBytes(),
                    "班级".getBytes(),
                    CompareFilter.CompareOp.EQUAL,
                    binaryPrefixComparator);

            scan.setFilter(singleColumnValueExcludeFilter);

            ResultScanner scanner = students.getScanner(scan);

            print(scanner);


        } catch (IOException e) {
            e.printStackTrace();
        }
    }

rowkey前缀过滤器：PrefixFilter

通过PrefixFilter查询以15001001开头的所有前缀的rowkey

    @Test
    public void prefixFilterTest(){
        try {

            HTableInterface students = conn.getTable("students");

            Scan scan = new Scan();

            //创建行键前缀过滤器
            PrefixFilter prefixFilter = new PrefixFilter("15001001".getBytes());

            scan.setFilter(prefixFilter);

            ResultScanner scanner = students.getScanner(scan);
            print(scanner);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

分页过滤器PageFilter

通过PageFilter查询三页的数据，每页10条

使用PageFilter分页效率比较低，每次都需要扫描前面的数据，直到扫描到所需要查的数据

可设计一个合理的rowkey来实现分页需求

# 注意事项：
客户端进行分页查询，需要传递 startRow(起始 RowKey)，知道起始 startRow 后，就可以返回对应的 pageSize 行数据。这里唯一的问题就是，对于第一次查询，显然 startRow 就是表格的第一行数据，但是之后第二次、第三次查询我们并不知道 startRow，只能知道上一次查询的最后一条数据的 RowKey（简单称之为 lastRow）。

我们不能将 lastRow 作为新一次查询的 startRow 传入，因为 scan 的查询区间是[startRow，endRow) ，即前开后闭区间，这样 startRow 在新的查询也会被返回，这条数据就重复了。

同时在不使用第三方数据库存储 RowKey 的情况下，我们是无法通过知道 lastRow 的下一个 RowKey 的，因为 RowKey 的设计可能是连续的也有可能是不连续的。

由于 Hbase 的 RowKey 是按照字典序进行排序的。这种情况下，就可以在 lastRow 后面加上 0 ，作为 startRow 传入，因为按照字典序的规则，某个值加上 0 后的新值，在字典序上一定是这个值的下一个值，对于 HBase 来说下一个 RowKey 在字典序上一定也是等于或者大于这个新值的。

所以最后传入 lastRow+0，如果等于这个值的 RowKey 存在就从这个值开始 scan,否则从字典序的下一个 RowKey 开始 scan。

25 个字母以及数字字符，字典排序如下:

'0' < '1' < '2' < ... < '9' < 'a' < 'b' < ... < 'z'

需要注意的是在多台 Regin Services 上执行分页过滤的时候，由于并行执行的过滤器不能共享它们的状态和边界，所以有可能每个过滤器都会在完成扫描前获取了 PageCount 行的结果，这种情况下会返回比分页条数更多的数据，分页过滤器就有失效的可能。

    public void PageFilter() {
        try {
            //获取表的实例
            HTableInterface students = conn.getTable("students");
            //定义要查询的页数
            int pageNum = 3;
            //定义每页的条数
            int pageSize = 10;
            Scan scan = new Scan();

            //定义一开始的行
            String current_page_start_row = "";

            for (int i = 1; i <= pageNum; i++) {
                System.out.println("====================当前是第" + i + "页===========================");
                //创建一个分页过滤器
                PageFilter pageFilter = new PageFilter(pageSize);
                scan.setFilter(pageFilter);
                ResultScanner scanner = students.getScanner(scan);
                for (Result rs : scanner) {
                    current_page_start_row = Bytes.toString(rs.getRow());
                    //告诉扫描器是从哪一行开始获取数据
                    scan.withStartRow((current_page_start_row + 0).getBytes());
                    PageFilter pageFilter1 = new PageFilter(pageSize);
                    scan.setFilter(pageFilter1);
                    //获取id
                    String id = Bytes.toString(rs.getRow());
                    String name = Bytes.toString(rs.getValue("info".getBytes(), "name".getBytes()));
                    String age = Bytes.toString(rs.getValue("info".getBytes(), "age".getBytes()));
                    String gender = Bytes.toString(rs.getValue("info".getBytes(), "gender".getBytes()));
                    String clazz = Bytes.toString(rs.getValue("info".getBytes(), "clazz".getBytes()));
                    System.out.println("学号：" + id + ",姓名：" + name + ",年龄：" + age + ",性别：" + gender + ",班级：" + clazz);

                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

包装过滤器

SkipFilter过滤器

SkipFilter包装一个过滤器，当被包装的过滤器遇到一个需要过滤的 KeyValue 实例时，则拓展过滤整行数据。下面是一个使用示例：

// 定义 ValueFilter 过滤器
Filter filter1 = new ValueFilter(CompareOperator.NOT_EQUAL,
      new BinaryComparator(Bytes.toBytes("xxx")));
// 使用 SkipFilter 进行包装
Filter filter2 = new SkipFilter(filter1);

WhileMatchFilter过滤器

WhileMatchFilter 包装一个过滤器，当被包装的过滤器遇到一个需要过滤的 KeyValue 实例时，WhileMatchFilter 则结束本次扫描，返回已经扫描到的结果。下面是其使用示例：

多过滤器综合查询

以上都是讲解单个过滤器的作用，当需要多个过滤器共同作用于一次查询的时候，就需要使用 FilterList。FilterList 支持通过构造器或者 addFilter 方法传入多个过滤器。

通过运用4种比较器过滤出姓于，年纪大于23岁，性别为女，且是理科的学生。

过滤出学号是以15001001开头的文科学生

作业：查询文科一班学生总分排名前10的学生（输出：学号，姓名，班级，总分）结果写到hbase

布隆过滤器

本质上布隆过滤器是一种数据结构，比较巧妙的概率型数据结构，特点是高效地插入和查询，可以用来告诉你 “某样东西一定不存在或者可能存在”。

相比于传统的 List、Set、Map 等数据结构，它更高效、占用空间更少，但是缺点是其返回的结果是概率性的，而不是确切的。

实际上，布隆过滤器广泛应用于网页黑名单系统、垃圾邮件过滤系统、爬虫网址判重系统等，Google 著名的分布式数据库 Bigtable 使用了布隆过滤器来查找不存在的行或列，以减少磁盘查找的 IO 次数，Google Chrome 浏览器使用了布隆过滤器加速安全浏览服务。

在很多 Key-Value 系统中也使用了布隆过滤器来加快查询过程，如 Hbase，Accumulo，Leveldb，一般而言，Value 保存在磁盘中，访问磁盘需要花费大量时间，然而使用布隆过滤器可以快速判断某个 Key 对应的 Value 是否存在，因此可以避免很多不必要的磁盘 IO 操作。

通过一个 Hash 函数将一个元素映射成一个位阵列（Bit Array）中的一个点。这样一来，我们只要看看这个点是不是 1 就知道可以集合中有没有它了。这就是布隆过滤器的基本思想。

运用场景

1、目前有 10 亿数量的自然数，乱序排列，需要对其排序。限制条件在 32 位机器上面完成，内存限制为 2G。如何完成？

2、如何快速在亿级黑名单中快速定位 URL 地址是否在黑名单中？(每条 URL 平均 64 字节)

3、需要进行用户登陆行为分析，来确定用户的活跃情况？

4、网络爬虫-如何判断 URL 是否被爬过？

5、快速定位用户属性（黑名单、白名单等）？

6、数据存储在磁盘中，如何避免大量的无效 IO？

7、判断一个元素在亿级数据中是否存在？

8、缓存穿透。

实现原理

假设我们有个集合 A，A 中有 n 个元素。利用k个哈希散列函数，将A中的每个元素映射到一个长度为 a 位的数组 B中的不同位置上，这些位置上的二进制数均设置为 1。如果待检查的元素，经过这 k个哈希散列函数的映射后，发现其 k 个位置上的二进制数全部为 1，这个元素很可能属于集合A，反之，一定不属于集合A。

比如我们有 3 个 URL {URL1,URL2,URL3}，通过一个hash 函数把它们映射到一个长度为 16 的数组上，如下：

若当前哈希函数为 Hash1()，通过哈希运算映射到数组中，假设Hash1(URL1) = 3，Hash1(URL2) = 6，Hash1(URL3) = 6，如下：

因此，如果我们需要判断URL1是否在这个集合中，则通过Hash(urL1)计算出其下标，并得到其值若为 1 则说明存在。

由于 Hash 存在哈希冲突，如上面URL2,URL3都定位到一个位置上，假设 Hash 函数是良好的，如果我们的数组长度为 m 个点，那么如果我们想将冲突率降低到例如 1%， 这个散列表就只能容纳 m/100 个元素，显然空间利用率就变低了，也就是没法做到空间有效（space-efficient）。

解决方法也简单，就是使用多个 Hash 算法，如果它们有一个说元素不在集合中，那肯定就不在，如下：

Hash1(URL1) = 3,Hash2(URL1) = 5,Hash3(URL1) = 6
Hash1(URL2) = 5,Hash2(URL2) = 8,Hash3(URL2) = 14
Hash1(URL3) = 4,Hash2(URL3) = 7,Hash3(URL3) = 10

以上就是布隆过滤器做法，使用了k个哈希函数，每个字符串跟 k 个 bit 对应，从而降低了冲突的概率。

误判现象

上面的做法同样存在问题，因为随着增加的值越来越多，被置为 1 的 bit 位也会越来越多，这样某个值即使没有被存储过，但是万一哈希函数返回的三个 bit 位都被其他值置位了 1 ，那么程序还是会判断这个值存在。比如此时来一个不存在的 URL1000，经过哈希计算后，发现 bit 位为下：

Hash1(URL1000) = 7,Hash2(URL1000) = 8,Hash3(URL1000) = 14

但是上面这些 bit 位已经被URL1,URL2,URL3置为 1 了，此时程序就会判断 URL1000 值存在。

这就是布隆过滤器的误判现象，所以，布隆过滤器判断存在的不一定存在，但是，判断不存在的一定不存在。

布隆过滤器可精确的代表一个集合，可精确判断某一元素是否在此集合中，精确程度由用户的具体设计决定，达到 100% 的正确是不可能的。但是布隆过滤器的优势在于，利用很少的空间可以达到较高的精确率。

控制粒度

a）ROW
根据KeyValue中的行来过滤storefile
举例：假设有2个storefile文件sf1和sf2，
sf1包含kv1（r1 cf：q1 v），kv2（r2 cf：q1 v）
sf2包含kv3（r3 cf：q1 v），kv4（r4 cf：q1 v）
若是设置了CF属性中的bloomfilter为ROW，那么得（r1）时就会过滤sf2，get（r3）就会过滤sf1
b）ROWCOL
根据KeyValue中的行+限定符来过滤storefile
举例：假设有2个storefile文件sf1和sf2，
sf1包含kv1（r1 cf：q1 v），kv2（r2 cf：q1 v）
sf2包含kv3（r1 cf：q2 v），kv4（r2 cf：q2 v）
若是设置了CF属性中的布隆过滤器为ROW，不管获得（R1，Q1）仍是获得（R1，Q2），都会读取SF1 + SF2;而若是设置了CF属性中的布隆过滤器为 ROWCOL，那么GET（R1， q1）就会过滤sf2，get（r1，q2）就会过滤sf1
c）NO
默认的值，默认不开启布隆过滤器

实现：

在建立表时加入一个参数就能够了

	 try {
            //使用HTableDescriptor类创建一个表对象
            HTableDescriptor students = new HTableDescriptor("students");

            //在创建表的时候，至少指定一个列簇
            HColumnDescriptor info = new HColumnDescriptor("info");
            info.setBloomFilterType(BloomType.ROW); //<===========================================

            //将列簇添加到表中
            students.addFamily(info);
            //真正的执行，是由HMaster
            //hAdmin
            hAdmin.createTable(students);
            System.out.println(Bytes.toString(students.getName()) + "表 创建成功。。。");
        } catch (IOException e) {
            e.printStackTrace();
        }