浅谈Hadoop的序列化机制

什么是序列化

序列化是指将结构化对象转换成字节流以便于进行网络传输或写入持久存储的过程。

什么是反序列化

将字节流转换为特定结构化对象的过程。

为什么使用Hadoop的序列化机制，而不是用java序列化机制

Hadoop的数据较为简单，没有继承关系，故而不需要java那种复杂的序列化机制。Hadoop提供更加精简的序列化机制可以减少资源消耗以及传输更少的数据，提高效率。

Hadoop序列化

Hadoop提供了没有提供比较功能的Writable接口实现的序列化机制。
此为，可以和java中的Comparable接口合并，提供一个接口WritableComparable。

编写步骤：
1.继承Writable
2.自定义需要的结构
3.覆盖write（）方法，用DataOutput.write…()方法将数据输入流中。（序列化）
4.覆盖readFields（）方法，用DataInput.read…()方法将流中数据提取出来。（反序列化）
5.覆盖toString（）方法，可以告知框架如何输出该数据。

package hadoop.mr.wordcount;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

import org.apache.hadoop.io.Writable;

public class FlowBean implements Writable{

	//定义结构
	private String phoneNB;
	private long up_flow;
	private long d_flow;
	private long s_flow;
	//定义空参构造函数
	public FlowBean() {}
	
	//定义较为方便的构造函数
	public FlowBean(String phoneNB, long up_flow, long d_flow) {
		this.phoneNB = phoneNB;
		this.up_flow = up_flow;
		this.d_flow = d_flow;
		this.s_flow = up_flow+d_flow;
	}
	
	//反序列化
	@Override
	public void readFields(DataInput in) throws IOException {
		//顺序要和序列化时一致
		phoneNB=in.readUTF();
		up_flow=in.readLong();
		d_flow=in.readLong();
		s_flow=in.readLong();
	}
	//序列化
	@Override
	public void write(DataOutput out) throws IOException {
		out.writeUTF(phoneNB);
		out.writeLong(up_flow);
		out.writeLong(d_flow);
		out.writeLong(s_flow);
	}
	
	//覆盖toString方法，使得最后reduce懂得如何输出
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return ""+up_flow+"/t"+d_flow+"/t"+s_flow;
	}
	
	//get和set方法
	public String getPhoneNB() {
		return phoneNB;
	}

	public void setPhoneNB(String phoneNB) {
		this.phoneNB = phoneNB;
	}

	public long getUp_flow() {
		return up_flow;
	}

	public void setUp_flow(long up_flow) {
		this.up_flow = up_flow;
	}

	public long getD_flow() {
		return d_flow;
	}

	public void setD_flow(long d_flow) {
		this.d_flow = d_flow;
	}

	public long getS_flow() {
		return s_flow;
	}

	public void setS_flow(long s_flow) {
		this.s_flow = s_flow;
	}
}