Hadoop基础-序列化与反序列化（实现Writable接口）

　　　　　　　　　　　　　　　　　　　Hadoop基础-序列化与反序列化（实现Writable接口）

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

一.序列化简介

1>.什么是序列化

　　序列化也称串行化，是将结构化的对象转换成字节流，以便在网络上进行传输或者写入到磁盘进行永久性存储的过程。

2>.什么是反序列化

　　反序列化也称反串行化，它是指将字节流转回结构化对象的逆过程。

3>.序列化的应用

　　主要用于分布式数据处理的两大领域，即进程间通信和永久存储。

4>.序列化的特点

　　第一：紧凑，体积小，节省带宽；

　　第二：快速，序列化过程快速；

　　第三：可扩展性(向下兼容)，新API支持旧数据格式；

　　第四：支持互操作，跨语言（可惜的是Java序列化和hadoop序列化都没有实现该属性！）；

 　　遗憾的是，Java和hadoop序列化都不支持上述的第四点特性，即跨语言。目前流行的两个序列化框架avro和protobuf（由Google公司研发）都支持以上四个特性哟！这两个框架不是本篇博客的重点，后期我会写两篇关于这两个序列化框架笔记。

二.hadoop串行化介绍

1>.为什么Hadoop要自己定义Hadoop串行化

　　之前我分享过Java序列化的通过ObjectOutputStream流对象可以对任意实现Serializable类接口进行实例化操作的笔记。通过ObjectInputStream流对象可以进行反序列化操作，详情请参考：https://www.cnblogs.com/yinzhengjie/p/8988003.html。

　　遗憾的是Hadoop并没有使用ObjectOutputStream进行序列化操作，而是自己定义了序列化的格式。可能你会跟当初刚刚学习Hadoop的我问同样的问题：“为什么Hadoop不Java自己提供的实现Serializable接口的方式进行序列化操作呢？”，每一件事物的存在都有他的原因，Hadoop自己定义了序列话接口是Hadoop处理的数据是海量的，他们对数据的存储，以及压缩算法是有要求的，感兴趣的小伙伴可以对一个较大数据进行序列化操作，你会发现Hadoop的序列化方式的确挺牛的！

2>.hadoop串行化格式

　　Hadoop把Java的几种数据类型进行了封装，将Long类型的数据封装为LongWritable，将int类型的数据进行封装为IntWritable类型，将String类型数据封装为Text类型，将Byte类型封装为ByteWriterable，将Array类型封装为ArrayWritale类型等等；

三.比较Java和Hadoop对int类型的串行化格式

1>.Java对int值2018进行序列化和反序列化的代码如下

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Hadoop%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 EMAIL:y1053419035@qq.com
 */
 package cn.org.yinzhengjie.serialize;

         import java.io.*;

 public class JavaSerial {
     public final static String fileParh = "D:\\10.Java\\IDE\\yhinzhengjieData\\java.serial";
     public static void main(String[] args) throws Exception {
         intSerialze();
         intDeserialize();
     }
     //定义序列化方式
     public static void intSerialze() throws IOException {
         Integer i = 2018;
         FileOutputStream fos = new FileOutputStream(fileParh);
         ObjectOutputStream oos = new ObjectOutputStream(fos);
         //进行Java的序列化方式
         oos.writeInt(i);
         //释放资源
         oos.close();
         fos.close();    //这里其实可以不用写，因为上面一行释放资源会顺带把它封装的对线下也关流了，不过这行即使咱们写了也是不会报错的！
     }
     //定义反序列化方法
     public static void  intDeserialize() throws Exception {
         FileInputStream fis = new FileInputStream(fileParh);
         ObjectInputStream ois = new ObjectInputStream(fis);
         //调用反序列化流的方法"readInt()"读取对象，要注意的是反序列话的对象需要存在相应的字节码文件。否则会抛异常
         int res = ois.readInt();
         //释放资源
         ois.close();
         fis.close();
         System.out.println(res);
     }
 }

 /*
 以上代码执行结果如下：
 2018
 */

2>.Hadoop对int类型的序列化方式和反序列化的代码如下

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Hadoop%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 EMAIL:y1053419035@qq.com
 */
 package cn.org.yinzhengjie.serialize;

 import org.apache.hadoop.io.IntWritable;
 import java.io.*;

 public class HadoopSerial {
     public final static String fileParh = "D:\\10.Java\\IDE\\yhinzhengjieData\\Datahadoop.serial";
     public static void main(String[] args) throws IOException {
         intSerialze();
         intDeserialize();
     }

     //定义序列化方式
     public static void intSerialze() throws IOException {
         //初始化intWritable
         IntWritable iw = new IntWritable(2018);
         FileOutputStream fos = new FileOutputStream(fileParh);
         DataOutputStream dos = new DataOutputStream(fos);
         //进行Hadoop的序列化方式
         iw.write(dos);
         //别忘记释放资源哟
         dos.close();
         fos.close();
     }

     //定义反序列化方式
     public static void  intDeserialize() throws IOException {
         //初始化intWritable
         IntWritable iw = new IntWritable();
         FileInputStream fis = new FileInputStream(fileParh);
         DataInputStream dis = new DataInputStream(fis);
         //进行Hadoop的反序列化方式，将数据输入流的数据传递给iw对象的readFields方法。
         iw.readFields(dis);
         //再通过iw对象的get方法获取数据
         int res = iw.get();
         System.out.println(res);
     }
 }

 /*
 以上代码执行结果如下：
 2018
 */

3>.查看两种方式的序列化文件大小

　　Datahadoop.serial 文件属性如下：

　　java.serial 文件属性如下：

　　同样都是对一个int类型值为2018的数字进行序列化，为什么Hadoop序列化只需要4个字节，而Java却需要10个字节呢？如果数字是PB的数据量，在选择序列化的方案上你会选择哪个呢？

四.比较java与Hadoop对自定义类的串行化格式

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Hadoop%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 EMAIL:y1053419035@qq.com
 */

 package cn.org.yinzhengjie.serialize;

 import java.io.Serializable;

 public class Student implements Serializable {
     private  String name;
     private  int age;
     private  boolean ismarry;

     public String getName() {
         return name;
     }

     public int getAge() {
         return age;
     }

     public boolean isIsmarry() {
         return ismarry;
     }

     public void setName(String name) {
         this.name = name;
     }

     public void setAge(int age) {
         this.age = age;
     }

     public void setIsmarry(boolean ismarry) {
         this.ismarry = ismarry;
     }

     @Override
     public String toString() {
         return "Student{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 ", ismarry=" + ismarry +
                 '}';
     }
 }

Student.java 文件内容

1>.java对自定义Student类实现序列化和反序列化

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Hadoop%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 EMAIL:y1053419035@qq.com
 */
 package cn.org.yinzhengjie.serialize;

 import java.io.*;

 public class JavaSerial {
     public final static String fileParh = "D:\\10.Java\\IDE\\yhinzhengjieData\\java.student";
     public static void main(String[] args) throws Exception {
         studentSerialze();
         studentDeserialize();
     }
     //定义序列化方式
     public static void studentSerialze() throws IOException {
         //实例化对象yzj
         Student yzj = new Student();
         yzj.setName("尹正杰");
         yzj.setAge(18);
         yzj.setIsmarry(false);
         FileOutputStream fos = new FileOutputStream(fileParh);
         ObjectOutputStream oos = new ObjectOutputStream(fos);
         //进行Java的序列化方式
         oos.writeObject(yzj);
         //释放资源
         oos.close();
         fos.close();    //这里其实可以不用写，因为上面一行释放资源会顺带把它封装的对线下也关流了，不过这行即使咱们写了也是不会报错的！
     }
     //定义反序列化方法
     public static void  studentDeserialize() throws Exception {
         FileInputStream fis = new FileInputStream(fileParh);
         ObjectInputStream ois = new ObjectInputStream(fis);
         //调用反序列化流的方法"readObject()"读取对象，要注意的是反序列话的对象需要存在相应的字节码文件。否则会抛异常
         Object res = ois.readObject();
         //释放资源
         ois.close();
         fis.close();
         System.out.println(res);
     }
 }

 /*
 以上代码执行结果如下：
 Student{name='尹正杰', age=18, ismarry=false}
 */

2>.Hadoop对自定义Student类实现序列化和反序列化

　　Hadoop对自定义类实现序列化或者反序列化操作的话，需要实现Hadoop的Writable接口,接下来我们举个例子，代码如下：

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Hadoop%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 EMAIL:y1053419035@qq.com
 */

 package cn.org.yinzhengjie.serialize;

 import org.apache.hadoop.io.Writable;

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

 public class StudentWirtable implements Writable {

     //切记这里需要给student赋值，不然可能会报错空指针异常哟！
     private Student student = new Student();

     public Student getStudent() {
         return student;
     }

     public void setStudent(Student student) {
         this.student = student;
     }

     //定义串行化的方法
     public void write(DataOutput dataOutput) throws IOException {
         //定义自定义类的序列化顺序，我这里是先序列化name，在序列化age，最好才序列化ismarry。
         dataOutput.writeUTF(student.getName());
         dataOutput.writeInt(student.getAge());
         dataOutput.writeBoolean(student.isIsmarry());

     }

     //定义反串行化的方法
     public void readFields(DataInput dataInput) throws IOException {
         student.setName(dataInput.readUTF());
         student.setAge(dataInput.readInt());
         student.setIsmarry(dataInput.readBoolean());
     }
 }

　　接下来就是我们调用自己定义的序列化方法啦，测试代码如下：

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Hadoop%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 EMAIL:y1053419035@qq.com
 */
 package cn.org.yinzhengjie.serialize;

 import java.io.*;

 public class HadoopSerial {
     public final static String fileParh = "D:\\10.Java\\IDE\\yhinzhengjieData\\hadoop.student";
     public static void main(String[] args) throws IOException {
         studentSerialze();
         studentDeserialize();
     }

     //定义序列化方式
     public static void studentSerialze() throws IOException {
         //实例化对象yzj
         Student yzj = new Student();
         yzj.setName("尹正杰");
         yzj.setAge(18);
         yzj.setIsmarry(false);
         //初始化StudentWirtable，这是咱们定义的一个容器
         StudentWirtable sw = new StudentWirtable();
         sw.setStudent(yzj);
         FileOutputStream fos = new FileOutputStream(fileParh);
         DataOutputStream dos = new DataOutputStream(fos);
         //进行Hadoop的序列化方式
         sw.write(dos);
         //别忘记释放资源哟
         dos.close();
         fos.close();
     }

     //定义反序列化方式
     public static void  studentDeserialize() throws IOException {
         //初始化intWritable
         StudentWirtable sw = new StudentWirtable();
         DataInputStream dis = new DataInputStream(new FileInputStream(fileParh));
         sw.readFields(dis);
         Student yzj = sw.getStudent();
         dis.close();
         System.out.println(yzj.toString());

     }
 }

 /*
 以上代码执行结果如下：
 Student{name='尹正杰', age=18, ismarry=false}
  */

3>.查看两种方式的序列化文件大小

 　　hadoop.student 文件属性如下：

　　java.student 文件属性如下：

　　如果一个int类型你感觉不出来hadoop序列化和java序列化的区别，那么自定义类的属性进行序列化你应该明显的看出来hadoop序列化要比java传统的序列化方式要节省空间多的多，如果这个数据换成一个PB的大小的话，估计差距就是天壤之别啦！