自定义Hadoop的可序列化类

Java原生语言中要想一个自定义类可序列化，很简单，只要让这个类实现java.io.Serializable接口就可以了，但是在Hadoop框架中，要想让自定义类可以被序列化，我们必须手动让其实现WritableCompable接口并且实现write(),readFields(),compareTo()方法。

下面就是一个我们自定义的可序列化的类：

1. /*  
2.  */ 
3. package com.charles.writable; 
4.  
5. import java.io.DataInput; 
6. import java.io.DataOutput; 
7. import java.io.IOException; 
8.  
9.  
10. import org.apache.hadoop.io.IntWritable; 
11. import org.apache.hadoop.io.Text; 
12. import org.apache.hadoop.io.WritableComparable; 
13.  
14. /** 
15.  * 
16.  * Description: 这是自定义的Hadoop序列化类，它可以用Hadoop序列化反序列化这个类 
17.  * 
18.  * @author charles.wang 
19.  * @created Jun 2, 2012 11:19:25 AM 
20.  *  
21.  */ 
22. public class PersonWritable implements WritableComparable<PersonWritable> { 
23.  
24.     private Text name; 
25.     private IntWritable age; 
26.     private Text title; 
27.      
28.     public PersonWritable(){ 
29.        set("someperson",0,"sometitle"); 
30.     } 
31.      
32.     public PersonWritable(String name ,int age, String title){ 
33.         set(name,age,title); 
34.     } 
35.      
36.      
37.     public void set(String name ,int age,String title){ 
38.         this.name =  new Text(name); 
39.          
40.         age=(age>0)?age:1; 
41.         this.age = new IntWritable(age); 
42.          
43.         this.title=  new Text(title); 
44.     } 
45.      
46.      
47.     /** 
48.      *  这个方法用于定义序列化过程，它把这个对象的所有字段依次序列化 
49.      */ 
50.     @Override 
51.     public void write(DataOutput out) throws IOException { 
52.         // TODO Auto-generated method stub 
53.          
54.         name.write(out); 
55.         age.write(out); 
56.         title.write(out); 
57.          
58.     } 
59.  
60.     /** 
61.      *  这个方法用于定义反序列化过程，它吧序列化后的DataInput的内容还原为Hadoop对象 
62.      */ 
63.     @Override 
64.     public void readFields(DataInput in) throws IOException { 
65.         // TODO Auto-generated method stub 
66.          
67.         name.readFields(in); 
68.         age.readFields(in); 
69.         title.readFields(in); 
70.          
71.     } 
72.  
73.     /** 
74.      * 这是用于2个序列化对象之间的比较 
75.      */ 
76.     @Override 
77.     public int compareTo(PersonWritable pO) { 
78.         // TODO Auto-generated method stub 
79.         int cmp1 = name.compareTo(pO.name); 
80.         if(cmp1 != 0){ 
81.             return cmp1; 
82.         } 
83.          
84.         int cmp2 = age.compareTo(pO.age); 
85.         if(cmp2 !=0){ 
86.             return cmp2; 
87.         } 
88.          
89.         int cmp3 = title.compareTo(pO.title); 
90.         return cmp3; 
91.     } 
92.      
93.     /** 
94.      * 定义hashcode是个好习惯，我们还是使用最常用的字段分别乘以不同的素数然后相加的方法 
95.      */ 
96.     @Override 
97.     public int hashCode(){ 
98.         return name.hashCode()*71+ age.hashCode()*73+title.hashCode()*127; 
99.     } 
100.      
101.     @Override 
102.     public boolean equals (Object o ){ 
103.         if ( o instanceof PersonWritable){ 
104.              
105.             PersonWritable pw = (PersonWritable) o; 
106.             boolean equals = name.equals(pw.name) && age.equals(pw.age) && title.equals(pw.title); 
107.             return equals; 
108.         } 
109.         return false; 
110.     } 
111.      
112.     @Override 
113.     public String toString(){ 
114.         StringBuffer sb = new StringBuffer(); 
115.         sb.append("["); 
116.         sb.append("姓名： "+name+","); 
117.         sb.append("年龄: "+age+","); 
118.         sb.append("头衔： "+title); 
119.         sb.append("]"); 
120.         return sb.toString(); 
121.     } 
122.  
123. }