RawComparator

hadoop的原生比较器RawComparator<T> public WritableCom...

1人收藏此文章,我要收藏发表于11个月前(2012-02-08 16:24) , 已有 312次阅读 ，共 0个评论

hadoop为序列化提供了优化，类型的比较对M/R而言至关重要，Key和Key的比较也是在排序阶段完成的，hadoop提供了原生的比较器接口RawComparator<T>用于序列化字节间的比较，该接口允许其实现直接比较数据流中的记录，无需反序列化为对象，RawComparator是一个原生的优化接口类，它只是简单的提供了用于数据流中简单的数据对比方法，从而提供优化：

1 publicinterfaceRawComparator<T>extendsComparator<T> {
2
3 publicintcompare(byte[] b1,ints1,intl1,byte[] b2,ints2,intl2);
4
5 }

该类并非被多数的衍生类所实现，其具体的子类为WritableComparator，多数情况下是作为实现Writable接口的类的内置类，提供序列化字节的比较。下面是RawComparator接口内置类的实现类图：

首先，我们看RawComparator的具体实现类WritableComparator：

WritableComparator类类似于一个注册表，里面记录了所有Comparator类的集合。

Comparators成员用一张Hash表记录Key=Class，value=WritableComprator的注册信息.

WritableComparator主要提供了两个功能

1.提供了对原始compare()方法的一个默认实现

默认实现是先反序列化为对像再通过对像比较（有开销的问题）

public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {

try {

buffer.reset(b1, s1, l1);// parse key1

key1.readFields(buffer);

buffer.reset(b2, s2, l2);// parse key2

key2.readFields(buffer);

} catch (IOException e) {

throw new RuntimeException(e);

}

return compare(key1, key2);// compare them

}

而对应的基础数据类型的compare()的实现却巧妙的利用了特定类型的泛化：（利用了writableComparable的compareTo方法）

public int compare(WritableComparable a, WritableComparable b) {

return a.compareTo(b);

}

例如IntWritable实例是调用了IntWritable里的compareTo方法

public int compareTo(Object o) {

int thisValue = this.value;

int thatValue = ((IntWritable)o).value;

return (thisValue<thatValue ? -1 : (thisValue==thatValue ? 0 : 1));

}

2.充当RawComparable实例的工厂，以注册Writable的实现

例如,为了获取IntWritable的Comparator，可以直接调用其get方法。

WritableComparator：

关键代码：

代码1：registry注册器

----------------------------------------------------------------

// registry注册器：记载了WritableComparator类的集合

privatestaticHashMap<Class,WritableComparator>comparators=

newHashMap<Class, WritableComparator>();

代码2：获取WritableComparator实例

说明：hashMap作为容器类线程不安全，故需要synchronized同步，get方法根据key=Class返回对应的WritableComparator,若返回的是空值NUll，则调用protected Constructor进行构造，而其两个protected的构造函数实则是调用了newKey()方法进行NewInstance

1 publicstaticsynchronizedWritableComparator get(Class<?extendsWritableComparable> c) {
2 WritableComparator comparator = comparators.get(c);
3 if(comparator ==null)
4 comparator =newWritableComparator(c,true);
5 returncomparator;
6 }

代码3：构造方法

---------------------------------------------------------------

01 newWritableComparator(c,true)
02
03 WritableComparator的构造函数源码如下：
04
05 /*
06
07 * keyClass,key1,key2和buffer都是用于WritableComparator的构造函数
08
09 */
10
11 privatefinalClass<?extendsWritableComparable> keyClass;
12
13 privatefinalWritableComparable key1;//WritableComparable接口
14
15 privatefinalWritableComparable key2;
16
17 privatefinalDataInputBuffer buffer;//输入缓冲流
18
19 protectedWritableComparator(Class<?extendsWritableComparable> keyClass,
20
21 booleancreateInstances) {
22
23 this.keyClass = keyClass;
24
25 if(createInstances) {
26
27 key1 = newKey();
28
29 key2 = newKey();
30
31 buffer =newDataInputBuffer();
32
33 }else{
34
35 key1 = key2 =null;
36
37 buffer =null;
38
39 }
40
41 }

上述的keyClass，key1,key2,buffer是记录HashMap对应的key值，用于WritableComparator的构造函数，但由其构造函数中我们可以看出WritableComparator根据Boolean createInstance来判断是否实例化key1,key2和buffer,而key1,key2作为实现了WritableComparable接口的标识，在WritableComparator的构造函数里面通过newKey()的方法去实例化实现WritableComparable接口的一个对象，下面是newKey（）的源码，通过hadoop自身的反射去实例化了一个WritableComparable接口对象。

1 <b>publicWritableComparable newKey() {
2
3 returnReflectionUtils.newInstance(keyClass,null);
4
5 }
6
7 </b>

代码4：Compare（）方法

---------------------------------------------------------------------

1.publicintcompare(Object a, Object b)；

2.publicintcompare(WritableComparablea,WritableComparableb)；

3.publicintcompare(byte[] b1,ints1,intl1,byte[] b2,ints2,intl2)；

三个compare（）重载方法中，compare(Object a, Object b)利用子类塑形为WritableComparable而调用了第2个compare方法，而第2个Compare（）方法则调用了Writable.compaerTo();最后一个compare(byte[] b1,ints1,intl1,byte[] b2,ints2,intl2)方法源码如下：

01 publicintcompare(byte[] b1,ints1,intl1,byte[] b2,ints2,intl2) {
02
03 try{
04
05 buffer.reset(b1, s1, l1);// parse key1
06
07 key1.readFields(buffer);
08
09
10
11 buffer.reset(b2, s2, l2);// parse key2
12
13 key2.readFields(buffer);
14
15
16
17 }catch(IOException e) {
18
19 thrownewRuntimeException(e);
20
21 }
22
23
24
25 returncompare(key1, key2);// compare them
26
27 }

Compare方法的一个缺省实现方式，根据接口key1,ke2反序列化为对象再进行比较。

利用Buffer为桥接中介，把字节数组存储为buffer后，调用key1（WritableComparable）的反序列化方法，再来比较key1,ke2，由此处可以看出，该compare方法是将要比较的二进制流反序列化为对象，再调用方法第2个重载方法进行比较。

代码5：方法define方法

该方法用于注册WritebaleComparaor对象到注册表中，注意同时该方法也需要同步，代码如下：

1 publicstaticsynchronizedvoiddefine(Class c,
2 WritableComparator comparator) {
3 comparators.put(c, comparator);
4 }

代码5：余下诸如readInt的静态方法

---------------------------------------------------------------------

这些方法用于实现WritableComparable的各种实例，例如IntWritable实例：内部类Comparator类需要根据自己的IntWritable类型重载WritableComparator里面的compare（）方法，可以说WritableComparator里面的compare（）方法只是提供了一个缺省的实现，而真正的compare（）方法实现需要根据自己的类型如IntWritable进行重载，所以WritableComparator方法中的那些readInt..等方法只是底层的封装的一个实现，方便内部Comparator进行调用而已。

下面我们着重看下BooleanWritable类的内置RawCompartor<T>的实现过程:

01 /**
02 * A Comparator optimized for BooleanWritable.
03 */
04 publicstaticclassComparatorextendsWritableComparator {
05 publicComparator() {//调用父类的Constructor初始化keyClass=BooleanWrite.class
06 super(BooleanWritable.class);
07 }
08 //重写父类的序列化比较方法，用些类用到父类提供的缺省方法
09 publicintcompare(byte[] b1,ints1,intl1,
10 byte[] b2,ints2,intl2) {
11 booleana = (readInt(b1, s1) ==1) ?true:false;
12 booleanb = (readInt(b2, s2) ==1) ?true:false;
13 return((a == b) ?0: (a ==false) ? -1:1);
14 }
15 }
16 //注册
17 static{
18 WritableComparator.define(BooleanWritable.class,newComparator());
19 }

总结：

hadoop 类似于Java的类包，即提供了Comparable接口（对应于writableComparable接口）和Comparator类（对应于RawComparator类）用于实现序列化的比较，在hadoop 的IO包中已经封装了JAVA的基本数据类型用于序列化和反序列化，一般自己写的类实现序列化和反序列化需要继承WritableComparable接口并且内置一个Comparator（继承于WritableComparator）的格式来实现自己的对象。