HBase Filter 过滤器之 Comparator 原理及源码学习

简介: HBase所有的比较器实现类都继承于父类ByteArrayComparable,而ByteArrayComparable又实现了Comparable接口;不同功能的比较器差别在于对父类compareTo()方法的重写逻辑不同。下面分别对HBase Filter默认实现的七大比较器一一进行介绍。1. BinaryComparator介绍:二进制比较器,用于按字典顺序比较指定字节数组。先看一个小例子:public class BinaryComparatorDemo { public static void main(String[] args) {

HBase所有的比较器实现类都继承于父类ByteArrayComparable,而ByteArrayComparable又实现了Comparable接口;不同功能的比较器差别在于对父类compareTo()方法的重写逻辑不同。

下面分别对HBase Filter默认实现的七大比较器一一进行介绍。

  1. BinaryComparator

介绍:二进制比较器,用于按字典顺序比较指定字节数组。

先看一个小例子:

public class BinaryComparatorDemo {

public static void main(String[] args) {

    BinaryComparator bc = new BinaryComparator(Bytes.toBytes("bbb"));

    int code1 = bc.compareTo(Bytes.toBytes("bbb"), 0, 3);
    System.out.println(code1); // 0
    int code2 = bc.compareTo(Bytes.toBytes("aaa"), 0, 3);
    System.out.println(code2); // 1
    int code3 = bc.compareTo(Bytes.toBytes("ccc"), 0, 3);
    System.out.println(code3); // -1
    int code4 = bc.compareTo(Bytes.toBytes("bbf"), 0, 3);
    System.out.println(code4); // -4
    int code5 = bc.compareTo(Bytes.toBytes("bbbedf"), 0, 6);
    System.out.println(code5); // -3
}

}
不难看出,该比较器的比较规则如下:

两个字符串首字母不同,则该方法返回首字母的asc码的差值
参与比较的两个字符串如果首字符相同,则比较下一个字符,直到有不同的为止,返回该不同的字符的asc码差值
两个字符串不一样长,可以参与比较的字符又完全一样,则返回两个字符串的长度差值
看一下以上规则对应其compareTo()方法的源码实现: 实现一:

static enum UnsafeComparer implements Bytes.Comparer<byte[]> {
INSTANCE;
....
public int compareTo(byte[] buffer1, int offset1, int length1, byte[] buffer2, int offset2, int length2) {

if (buffer1 == buffer2 && offset1 == offset2 && length1 == length2) {
    return 0;
} else {
    int minLength = Math.min(length1, length2);
    int minWords = minLength / 8;
    long offset1Adj = (long)(offset1 + BYTE_ARRAY_BASE_OFFSET);
    long offset2Adj = (long)(offset2 + BYTE_ARRAY_BASE_OFFSET);
    int j = minWords << 3;

    int offset;
    for(offset = 0; offset < j; offset += 8) {
        long lw = theUnsafe.getLong(buffer1, offset1Adj + (long)offset);
        long rw = theUnsafe.getLong(buffer2, offset2Adj + (long)offset);
        long diff = lw ^ rw;
        if (diff != 0L) {
            return lessThanUnsignedLong(lw, rw) ? -1 : 1;
        }
    }

    offset = j;
    int b;
    int a;
    if (minLength - j >= 4) {
        a = theUnsafe.getInt(buffer1, offset1Adj + (long)j);
        b = theUnsafe.getInt(buffer2, offset2Adj + (long)j);
        if (a != b) {
            return lessThanUnsignedInt(a, b) ? -1 : 1;
        }

        offset = j + 4;
    }

    if (minLength - offset >= 2) {
        short sl = theUnsafe.getShort(buffer1, offset1Adj + (long)offset);
        short sr = theUnsafe.getShort(buffer2, offset2Adj + (long)offset);
        if (sl != sr) {
            return lessThanUnsignedShort(sl, sr) ? -1 : 1;
        }

        offset += 2;
    }

    if (minLength - offset == 1) {
        a = buffer1[offset1 + offset] & 255;
        b = buffer2[offset2 + offset] & 255;
        if (a != b) {
            return a - b;
        }
    }

    return length1 - length2;
}

}
实现二:

static enum PureJavaComparer implements Bytes.Comparer<byte[]> {

INSTANCE;

private PureJavaComparer() {
}

public int compareTo(byte[] buffer1, int offset1, int length1, byte[] buffer2, int offset2, int length2) {
    if (buffer1 == buffer2 && offset1 == offset2 && length1 == length2) {
        return 0;
    } else {
        int end1 = offset1 + length1;
        int end2 = offset2 + length2;
        int i = offset1;

        for(int j = offset2; i < end1 && j < end2; ++j) {
            int a = buffer1[i] & 255;
            int b = buffer2[j] & 255;
            if (a != b) {
                return a - b;
            }

            ++i;
        }

        return length1 - length2;
    }
}

}
实现一是对实现二的一个优化,都引自Bytes类,HBase优先执行实现一方案,如果有异常再执行实现二方案。如下:

public static int compareTo(byte[] buffer1, int offset1, int length1, byte[] buffer2, int offset2, int length2) {

return Bytes.LexicographicalComparerHolder.BEST_COMPARER.compareTo(buffer1, offset1, length1, buffer2, offset2, length2);

}
...
...

static final String UNSAFE_COMPARER_NAME = Bytes.LexicographicalComparerHolder.class.getName() + "$UnsafeComparer";
static final Bytes.Comparer<byte[]> BEST_COMPARER = getBestComparer();
static Bytes.Comparer<byte[]> getBestComparer() {

try {
    Class<?> theClass = Class.forName(UNSAFE_COMPARER_NAME);
    Bytes.Comparer<byte[]> comparer = (Bytes.Comparer)theClass.getEnumConstants()[0];
    return comparer;
} catch (Throwable var2) {
    return Bytes.lexicographicalComparerJavaImpl();
}

}

  1. BinaryPrefixComparator

介绍:二进制比较器,只比较前缀是否与指定手游账号交易字节数组相同。

先看一个小例子:

public class BinaryPrefixComparatorDemo {

public static void main(String[] args) {

    BinaryPrefixComparator bc = new BinaryPrefixComparator(Bytes.toBytes("b"));

    int code1 = bc.compareTo(Bytes.toBytes("bbb"), 0, 3);
    System.out.println(code1); // 0
    int code2 = bc.compareTo(Bytes.toBytes("aaa"), 0, 3);
    System.out.println(code2); // 1
    int code3 = bc.compareTo(Bytes.toBytes("ccc"), 0, 3);
    System.out.println(code3); // -1
    int code4 = bc.compareTo(Bytes.toBytes("bbf"), 0, 3);
    System.out.println(code4); // 0
    int code5 = bc.compareTo(Bytes.toBytes("bbbedf"), 0, 6);
    System.out.println(code5); // 0
    int code6 = bc.compareTo(Bytes.toBytes("ebbedf"), 0, 6);
    System.out.println(code6); // -3
}

}
该比较器只是基于BinaryComparator比较器稍作更改而已,以下代码一目了然:

public int compareTo(byte[] value, int offset, int length) {

return Bytes.compareTo(this.value, 0, this.value.length, value, offset, this.value.length <= length ? this.value.length : length);

}
看一下同BinaryComparator方法的异同:

public int compareTo(byte[] value, int offset, int length) {

return Bytes.compareTo(this.value, 0, this.value.length, value, offset, length);

}
区别只在于最后一个传参,即length=min(this.value.length,value.length),取小。这样在后面的字节逐位比较时,即只需比较min length次。

  1. BitComparator

介绍:位比价器,通过BitwiseOp提供的AND(与)、OR(或)、NOT(非)进行比较。返回结果要么为1要么为0,仅支持 EQUAL 和非 EQUAL。

先看一个小例子:

public class BitComparatorDemo {

public static void main(String[] args) {

    // 长度相同按位或比较:由低位起逐位比较,每一位按位或比较都为0,则返回1,否则返回0。
    BitComparator bc1 = new BitComparator(new byte[]{0,0,0,0}, BitComparator.BitwiseOp.OR);
    int i = bc1.compareTo(new byte[]{0,0,0,0}, 0, 4);
    System.out.println(i); // 1
    // 长度相同按位与比较:由低位起逐位比较,每一位按位与比较都为0,则返回1,否则返回0。
    BitComparator bc2 = new BitComparator(new byte[]{1,0,1,0}, BitComparator.BitwiseOp.AND);
    int j = bc2.compareTo(new byte[]{0,1,0,1}, 0, 4);
    System.out.println(j); // 1
    // 长度相同按位异或比较:由低位起逐位比较,每一位按位异或比较都为0,则返回1,否则返回0。
    BitComparator bc3 = new BitComparator(new byte[]{1,0,1,0}, BitComparator.BitwiseOp.XOR);
    int x = bc3.compareTo(new byte[]{1,0,1,0}, 0, 4);
    System.out.println(x); // 1
    // 长度不同,返回1,否则按位比较
    BitComparator bc4 = new BitComparator(new byte[]{1,0,1,0}, BitComparator.BitwiseOp.XOR);
    int y = bc4.compareTo(new byte[]{1,0,1}, 0, 3);
    System.out.println(y); // 1
}

}
上述注释阐述的规则,对应以下代码: ··· public int compareTo(byte[] value, int offset, int length) { if (length != this.value.length) { return 1; } else { int b = 0;

for(int i = length - 1; i >= 0 && b == 0; --i) {
    switch(this.bitOperator) {
    case AND:
        b = this.value[i] & value[i + offset] & 255;
        break;
    case OR:
        b = (this.value[i] | value[i + offset]) & 255;
        break;
    case XOR:
        b = (this.value[i] ^ value[i + offset]) & 255;
    }
}

return b == 0 ? 1 : 0;

}
} ··· 核心思想就是:由低位起逐位比较,直到b!=0退出循环。

  1. LongComparator

介绍:Long 型专用比较器,返回值:0 -1 1。上篇概述没有提到,这里补上。

先看一个小例子:

public class LongComparatorDemo {

public static void main(String[] args) {
    LongComparator longComparator = new LongComparator(1000L);
    int i = longComparator.compareTo(Bytes.toBytes(1000L), 0, 8);
    System.out.println(i); // 0
    int i2 = longComparator.compareTo(Bytes.toBytes(1001L), 0, 8);
    System.out.println(i2); // -1
    int i3 = longComparator.compareTo(Bytes.toBytes(998L), 0, 8);
    System.out.println(i3); // 1
}

}
这个比较器实现相当简单,不多说了,如下:

public int compareTo(byte[] value, int offset, int length) {

Long that = Bytes.toLong(value, offset, length);
return this.longValue.compareTo(that);

}

  1. NullComparatorDemo

介绍:控制比较式,判断当前值是不是为null。是null返回0,不是null返回1,仅支持 EQUAL 和非 EQUAL。

先看一个小例子:

public class NullComparatorDemo {

public static void main(String[] args) {
    NullComparator nc = new NullComparator();
    int i1 = nc.compareTo(Bytes.toBytes("abc"));
    int i2 = nc.compareTo(Bytes.toBytes(""));
    int i3 = nc.compareTo(null);
    System.out.println(i1); // 1
    System.out.println(i2); // 1
    System.out.println(i3); // 0
}

}
这个比较器实现相当简单,不多说了,如下:

public int compareTo(byte[] value) {

return value != null ? 1 : 0;

}

  1. RegexStringComparator

介绍:提供一个正则的比较器,支持正则表达式的值比较,仅支持 EQUAL 和非 EQUAL。匹配成功返回0,匹配失败返回1。

先看一个小例子:

public class RegexStringComparatorDemo {

public static void main(String[] args) {
    RegexStringComparator rsc = new RegexStringComparator("abc");
    int abc = rsc.compareTo(Bytes.toBytes("abcd"), 0, 3);
    System.out.println(abc); // 0
    int bcd = rsc.compareTo(Bytes.toBytes("bcd"), 0, 3);
    System.out.println(bcd); // 1

    String check = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
    RegexStringComparator rsc2 = new RegexStringComparator(check);
    int code = rsc2.compareTo(Bytes.toBytes("zpb@163.com"), 0, "zpb@163.com".length());
    System.out.println(code); // 0
    int code2 = rsc2.compareTo(Bytes.toBytes("zpb#163.com"), 0, "zpb#163.com".length());
    System.out.println(code2); // 1
}

}
其compareTo()方法有两种引擎实现,对应两套正则匹配规则,分别是JAVA版和JONI版(面向JRuby),默认为RegexStringComparator.EngineType.JAVA。如下:

public int compareTo(byte[] value, int offset, int length) {

return this.engine.compareTo(value, offset, length);

}

public static enum EngineType {

JAVA,
JONI;

private EngineType() {
}

}
具体实现都很简单,都是调用正则语法匹配。以下是JAVA EngineType 实现:

public int compareTo(byte[] value, int offset, int length) {

String tmp;
if (length < value.length / 2) {
    tmp = new String(Arrays.copyOfRange(value, offset, offset + length), this.charset);
} else {
    tmp = new String(value, offset, length, this.charset);
}

return this.pattern.matcher(tmp).find() ? 0 : 1;

}
JONI EngineType 实现:

public int compareTo(byte[] value, int offset, int length) {

Matcher m = this.pattern.matcher(value);
return m.search(offset, length, this.pattern.getOptions()) < 0 ? 1 : 0;

}
都很容易理解,不多说了。

  1. SubstringComparator

介绍:判断提供的子串是否出现在value中,并且不区分大小写。包含字串返回0,不包含返回1,仅支持 EQUAL 和非 EQUAL。

先看一个小例子:

public class SubstringComparatorDemo {

public static void main(String[] args) {
    String value = "aslfjllkabcxxljsl";
    SubstringComparator sc = new SubstringComparator("abc");
    int i = sc.compareTo(Bytes.toBytes(value), 0, value.length());
    System.out.println(i); // 0

    SubstringComparator sc2 = new SubstringComparator("abd");
    int i2 = sc2.compareTo(Bytes.toBytes(value), 0, value.length());
    System.out.println(i2); // 1

    SubstringComparator sc3 = new SubstringComparator("ABC");
    int i3 = sc3.compareTo(Bytes.toBytes(value), 0, value.length());
    System.out.println(i3); // 0
}

}
这个比较器实现也相当简单,不多说了,如下:

public int compareTo(byte[] value, int offset, int length) {

return Bytes.toString(value, offset, length).toLowerCase().contains(this.substr) ? 0 : 1;

}
到此,七种比较器就介绍完了。如果对源码不敢兴趣,也建议一定要看看文中的小例子,熟悉下每种比较器的构造函数及结果输出。后续在使用HBase过滤器的过程中,会经常用到。当然除了这七种比较器,大家也可以自定义比较器。

相关实践学习
lindorm多模间数据无缝流转
展现了Lindorm多模融合能力——用kafka API写入,无缝流转在各引擎内进行数据存储和计算的实验。
云数据库HBase版使用教程
&nbsp; 相关的阿里云产品:云数据库 HBase 版 面向大数据领域的一站式NoSQL服务,100%兼容开源HBase并深度扩展,支持海量数据下的实时存储、高并发吞吐、轻SQL分析、全文检索、时序时空查询等能力,是风控、推荐、广告、物联网、车联网、Feeds流、数据大屏等场景首选数据库,是为淘宝、支付宝、菜鸟等众多阿里核心业务提供关键支撑的数据库。 了解产品详情:&nbsp;https://cn.aliyun.com/product/hbase &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验:数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引,您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接,领取免费ECS&amp;RDS资源,30分钟完成数据库上云实战!https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
目录
相关文章
|
5月前
|
存储 分布式数据库 数据库
Hbase学习二:Hbase数据特点和架构特点
Hbase学习二:Hbase数据特点和架构特点
86 0
|
2月前
|
存储 大数据 关系型数据库
HBase系列学习:基础知识
HBase系列学习:基础知识
HBase系列学习:基础知识
|
2月前
|
分布式计算 Hadoop Shell
Hadoop-36 HBase 3节点云服务器集群 HBase Shell 增删改查 全程多图详细 列族 row key value filter
Hadoop-36 HBase 3节点云服务器集群 HBase Shell 增删改查 全程多图详细 列族 row key value filter
59 3
|
5月前
|
大数据 分布式数据库 Hbase
Hbase学习三:Hbase常用命令总结
Hbase学习三:Hbase常用命令总结
710 0
|
7月前
|
SQL Java 分布式数据库
实现HBase表和RDB表的转化(附Java源码资源)
该文介绍了如何将数据从RDB转换为HBase表,主要涉及三个来源:RDB Table、Client API和Files。文章重点讲解了RDB到HBase的转换,通过批处理思想,利用RDB接口批量导出数据并转化为`List&lt;Put&gt;`,然后导入HBase。目录结构包括配置文件、RDB接口及实现类、HBase接口及实现类,以及一个通用转换器接口和实现。代码中,`RDBImpl`负责从RDB读取数据并构造`Put`对象,`HBaseImpl`则负责将`Put`写入HBase表。整个过程通过配置文件`transfer.properties`管理HBase和RDB的映射关系。
59 3
实现HBase表和RDB表的转化(附Java源码资源)
|
6月前
|
存储 SQL 分布式计算
技术心得记录:深入学习HBase架构原理
技术心得记录:深入学习HBase架构原理
|
7月前
|
存储 算法 分布式数据库
HBase原理 | HBase内部探险
HBase原理 | HBase内部探险
121 0
|
存储 缓存 负载均衡
98 hbase原理
98 hbase原理
68 0
|
存储 运维 监控
分布式数据库HBase的重要机制和原理的宕机恢复和故障处理
HBase是一个分布式数据库系统,支持高可用性、高性能和高伸缩性。在分布式环境中,数据的分布式存储和管理是非常重要的。HBase通过分布式存储和管理数据来实现高可用性和高性能。同时,HBase还提供了一些重要的机制和原理来支持宕机恢复和故障处理。
453 1
|
存储 分布式计算 关系型数据库