Java 對象序列化和反序列化 （實現 Serializable 接口）

序列化和反序列化的概念

　　把對象轉換為字節序列的過程稱為對象的序列化。

  　 把字節序列恢復為對象的過程稱為對象的反序列化。

　　對象的序列化主要有兩種用途：
　　1） 把對象的字節序列永久地保存到硬盤上，通常存放在一個文件中；
　　2） 在網絡上傳送對象的字節序列。

 

JDK類庫中的序列化API

　　java.io.ObjectOutputStream代表對象輸出流，它的writeObject(Object obj)方法可對參數指定的obj對象進行序列化，把得到的字節序列寫到一個目標輸出流中。
　　java.io.ObjectInputStream代表對象輸入流，它的readObject()方法從一個源輸入流中讀取字節序列，再把它們反序列化為一個對象，並將其返回。
　　只有實現了Serializable和Externalizable接口的類的對象才能被序列化。Externalizable接口繼承自 Serializable接口，實現Externalizable接口的類完全由自身來控制序列化的行為,

　　而僅實現Serializable接口的類可以 采用默認的序列化方式 。

　　對象序列化包括如下步驟：　

   　1） 創建一個對象輸出流，它可以包裝一個其他類型的目標輸出流，如文件輸出流；
　　2） 通過對象輸出流的writeObject()方法寫對象。

　　對象反序列化的步驟如下：

　　1） 創建一個對象輸入流，它可以包裝一個其他類型的源輸入流，如文件輸入流；
　　2） 通過對象輸入流的readObject()方法讀取對象。

示例：

 新建一個Car 類

package com.oukele.redis2.entity;

import java.io.Serializable;

public class Car implements Serializable {

    /*
     * 編號
     */
    private int id;
    /*
     * 車名
     */
    private String name;
    /*
     * 車速
     */
    private double speed;

    public Car(String name,double speed ){
        this.name = name;
        this.speed = speed;
    }

    public Car(int id, String name, double speed) {
        this.id = id;
        this.name = name;
        this.speed = speed;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public double getSpeed() {
        return speed;
    }

    public void setSpeed(double speed) {
        this.speed = speed;
    }

    @Override
    public String toString() {
        return "Car{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", speed=" + speed +
                '}';
    }
}

新建一個 SerializeUtil 類 （封裝 序列化 和 反序列化 的方法，便於調用 ）

package com.oukele.redis2.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializeUtil {

    /*
    * 序列化
    * */
    public static byte[] serialize(Object object){
        //序列化流 （輸出流） --> 表示向一個目標 寫入數據
        ObjectOutputStream objectOutputStream =null;
        //字節數組輸出流
        ByteArrayOutputStream byteArrayOutputStream = null;
        try{
            //創建一個緩沖區
            byteArrayOutputStream = new ByteArrayOutputStream();
            //將 對象 序列化成 字節后  輸入緩沖區中
            objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            //序列化 對象
            objectOutputStream.writeObject(object);
            //得 到 序列化字節
            byte[] bytes = byteArrayOutputStream.toByteArray();

            //清空輸出流
            objectOutputStream.flush();
            //釋放資源
            objectOutputStream.close();

            return bytes;
        }catch (Exception e){
            System.out.println("出現異常:"+e.getMessage());
        }
        return null;
    }

    /*
    * 反序列化
    * */

    public static  <T> T deserialize(byte[] bytes,Class<T> clazz){
       //字節數組
        ByteArrayInputStream byteArrayInputStream = null;
        try{
            //將 得到的序列化字節 丟進 緩沖區
            byteArrayInputStream = new ByteArrayInputStream(bytes);
            //反序列化流 （輸入流）--> 表示着從 一個 源頭 讀取 數據 ， （讀取 緩沖區中 的字節）
            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
            //反序化成 一個對象
            return (T)objectInputStream.readObject();
        }catch (Exception e){
            System.out.println("出現異常:"+e.getMessage());
        }
        return null;
    }


}

 

測試：

        //序列化一個對象
        byte[] serialize = SerializeUitl.serialize(new Car(2,"寶馬",88.8));
        //反序列化
        Car deserialize = SerializeUitl.deserialize(serialize, Car.class);
        System.out.println(deserialize);

測試結果：

示例源碼地址：