hadoop 序列化

Hadoop的序列化

在hadoop的框架中要使一个类可序列化，要实现Writable接口的两个方法：

public interface Writable {

  /**

   * Serialize the fields of this object to <code>out</code>.

   *

   * @param out <code>DataOuput</code> to serialize this object into.

   * @throws IOException

   */

  void write(DataOutput out) throws IOException;

 

  /**

   * Deserialize the fields of this object from <code>in</code>. 

   *

   * <p>For efficiency, implementations should attempt to re-use storage in the

   * existing object where possible.</p>

   *

   * @param in <code>DataInput</code> to deseriablize this object from.

   * @throws IOException

   */

  void readFields(DataInput in) throws IOException;

}

Writable

在这两个方法中自己控制对fileds的输入和输出。如果类中包含有其他对象的引用，那么那个对象也是要实现Writable接口的（当然也可以不实现Writable借口，只要自己处理好对对象的fileds的存贮就可以了）。

import java.io.DataInput;

import java.io.DataOutput;

import java.io.IOException;

import org.apache.hadoop.io.IntWritable;

import org.apache.hadoop.io.Text;

import org.apache.hadoop.io.Writable;

public class Attribute implements Writable{

   public static int ATTRIBUTE_TYPE_STRING = 1;//string type  

    public static int ATTRIBUTE_TYPE_NOMINAL = 2;//nominal type  

    public static int ATTRIBUTE_TYPE_REAL = 3;//real type  

      

    private IntWritable type;  

    private Text name; 

    public Attribute() {

      this.type = new IntWritable(0);

      this.name = new Text("");

    }

   

    public Attribute(int type, String name) {

      this.type = new IntWritable(type);

      this.name = new Text(name);

    }

   @Override

   public void readFields(DataInput in) throws IOException {

      type.readFields(in);

      name.readFields(in);

   }

 

   @Override

   public void write(DataOutput out) throws IOException {

      type.write(out);

      name.write(out);

   }

}

 

 

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.DataInput;

import java.io.DataInputStream;

import java.io.DataOutput;

import java.io.DataOutputStream;

import java.io.IOException;

import org.apache.hadoop.io.IntWritable;

import org.apache.hadoop.io.Writable;

public class Test implements Writable{

   private Attribute a;  

    private IntWritable b;

   

    public static void main(String[]args)throws Exception {

      Attribute ab = new Attribute(Attribute.ATTRIBUTE_TYPE_NOMINAL, "name");

      Test test = new Test(ab, new IntWritable(1));

      ByteArrayOutputStream bos = new ByteArrayOutputStream();

      DataOutputStream dos = new DataOutputStream(bos);

      test.write(dos);

     

      Test test2 = new Test();

      test2.readFields(new DataInputStream(new ByteArrayInputStream(bos.toByteArray())));

    }

   

    public Test() {

    }

   

    public Test(Attribute ab,IntWritable iw) {

      this.a = ab;

      this.b = iw;

    }

   

   @Override

   public void readFields(DataInput in) throws IOException {

      a = new Attribute();

      a.readFields(in);

      b = new IntWritable(1);

      b.readFields(in);

   }

 

   @Override

   public void write(DataOutput out) throws IOException {

      a.write(out);

      b.write(out);

   }

}

实现hadoop的序列化机制就是利用java的DataInput和DataOutput来完成对基本类型的序列化，然后让用户自己来处理对自己编写的类的序列化。Hadoop 分布式计算，序列化是Hadoop通过RPC调用，使得每个节点之间有效沟通的方法。于是序列化就成为了分布式计算的一个重要课题。序列化之后，对于分布式计算还需要排序。因此排序也相当重要：

Hadoop要求对象在序列化之后的字节也能够支持排序，以提高计算速度，还不必产生很多无谓的数据。