5.3.3 自定义writable和RawComparatorWritable
5.3.3 自定义writable
（1）构造员工writable
Hadoop虽然已经实现了一些非常有用的Writable，而且你可以使用他们的组合做很多事情，但是如果你想构造一些更加复杂的结果，你可以自定义Writable来达到你的目的，例如员工writable有姓名和角色两个Text属性构成，需要对员工writable姓名和角色同时进行比较排序。定义类实现WritableComparable接口，、实现构造函数、属性getset函数，readfield和write函数、compareTo函数用于比较、toString()函数实现字符串输出。
https://blog.csdn.net/lzm1340458776/article/details/42675433
/**
* 自定义Writable通常都要实现Writable接口
* 如果有比较大小的业务，最好是实现WritableComparable接口
* time : 2015年1月13日下午1:39:12
* @version
*/
public class EmployeeWritable implements WritableComparable<EmployeeWritable>{
//姓名
private Text name;
//角色
private Text role;
//必须提供无参构造方法(一定要创建name和role对象否则会报空指针异常)
public EmployeeWritable() {
name = new Text();
role = new Text();
}
//构造函数
public EmployeeWritable(Text name, Text role) {
this.name = name;
this.role = role;
}
public Text getName() {
return name;
}
public void setName(Text name) {
this.name = name;
}
public Text getRole() {
return role;
}
public void setRole(Text role) {
this.role = role;
}
/**
* 调用成员对象本身的readFields()方法，从输入流中反序列化每一个成员对象
*/
public void readFields(DataInput dataInput) throws IOException {
name.readFields(dataInput);
role.readFields(dataInput);
}
/**
* 通过成员对象本身的write方法，序列化每一个成员对象到输出流中
*/
public void write(DataOutput dataOutput) throws IOException {
name.write(dataOutput);
role.write(dataOutput);
}
/**
* 如果实现了WritableComparable接口必须实现compareTo方法，用于比较，需要反序列化对象得到text然后比较
*/
public int compareTo(EmployeeWritable employeeWritable) {
int cmp = name.compareTo(employeeWritable.name);
//如果不相等
if (cmp != 0){
return cmp;
}
//如果名字相等就比较角色
return role.compareTo(employeeWritable.role);
/**
* MapReduce需要一个分割者(Partitioner)把Map的输出作为输入分成一块块的喂给多个reduce
* 默认的是HashPatitioner，它是通过对象的hashCode函数进行分割。
* 所以hashCode的好坏决定了分割是否均匀，它是一个很关键的方法
*/
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((role == null) ? 0 : role.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
EmployeeWritable other = (EmployeeWritable) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (role == null) {
if (other.role != null)
return false;
} else if (!role.equals(other.role))
return false;
return true;
}
/**
* 自定义自己的输出类型
*/
@Override
public String toString() {
return "EmployeeWritable [姓名=" + name + ", 角色=" + role + "]";
}
}
（2）自定义RawComparatorWritable
上面的EmployeeWritable， MapReduce里的key，需要进行比较时，首先要反序列化成一个对象，然后再调用compareTo对象进行比较，但是这样效率太低了，可以直接通过序列化之后的数值进行比较，来提高效率直接根据序列化之后的值进行比较排序，我们只需要把EmployeeWritable序列化后的结果拆分为成员对象，然后比较成员对象即可，看代码：
public static class Comparator extends WritableComparator{
private static final Text.Comparator TEXT_COMPARATOR = new Text.Comparator();
protected Comparator() {
super(EmployeeWritable.class);
}
//b1是对象a的序列化字节，s1是name的偏移量，l1是总长度
@Override
public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
try {
// /**
* Text是标准的UTF-8字节流，
* 由一个变长整形开头表示Text中文本所需要的长度，接下来就是文本本身的字节数组
* decodeVIntSize返回变长 整形的长度，readVInt 表示 文本字节数组的长度，加起来就是第一个成员name的长度*/
int nameL1 = WritableUtils.decodeVIntSize(b1[s1]) + readVInt(b1, s1);
int nameL2 = WritableUtils.decodeVIntSize(b2[2]) + readVInt(b2, s2);
//和compareTo方法一样，先比较name
int cmp = TEXT_COMPARATOR.compare(b1, s1, nameL1, b2, s2, nameL2);
if (cmp != 0){
return cmp;
}
//再比较role
return TEXT_COMPARATOR.compare(b1, s1+nameL1, l1-nameL1, b2, s2+nameL2, l2-nameL2);
} catch (Exception e) {
throw new IllegalArgumentException();
}
}
static {
//注册raw comparator,更像是绑定，这样MapReduce使用EmployeeWritable时就会直接调用Comparator
WritableComparator.define(EmployeeWritable.class, new Comparator());
}
}