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:[e-mail]
*/
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:[e-mail]
*/
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:[e-mail]
*/

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 +
                '}';
    }
}

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:[e-mail]
*/
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:[e-mail]
*/

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:[e-mail]
*/
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的大小的話，估計差距就是天壤之別啦！