Java中的序列化機制詳細(xì)解讀

更新時間：2023年11月23日 08:58:37 作者：我會努力變強的

這篇文章主要介紹了Java中的序列化機制詳細(xì)解讀,序列化：將對象的狀態(tài)信息轉(zhuǎn)換為可以存儲或傳輸?shù)臄?shù)據(jù)形式(比如二進制)的過程,反序列化：與序列化相對,把序列化轉(zhuǎn)換成的可以存儲或傳輸?shù)臄?shù)據(jù)形式轉(zhuǎn)化為對象的狀態(tài)信息的過程,需要的朋友可以參考下

序列化與反序列化

序列化：將對象的狀態(tài)信息轉(zhuǎn)換為可以存儲或傳輸?shù)臄?shù)據(jù)形式（比如二進制）的過程。
反序列化：與序列化相對，把序列化轉(zhuǎn)換成的可以存儲或傳輸?shù)臄?shù)據(jù)形式轉(zhuǎn)化為對象的狀態(tài)信息的過程。

java序列化與反序列化

序列化：把對象轉(zhuǎn)換為二進制流。
反序列化：把二進制流數(shù)據(jù)轉(zhuǎn)化為對象。

使用場景

永久保存數(shù)據(jù)。把序列化后的數(shù)據(jù)保存到磁盤等存儲設(shè)備中。使用時可以反序列化。比如某些對象不想隨著JVM關(guān)閉而消失，可以序列化到磁盤中。
用于網(wǎng)絡(luò)傳輸。把對象序列化為二進制數(shù)據(jù)，傳輸?shù)竭h程計算機。
java序列化還可以實現(xiàn)對象深拷貝。

使用方式

java實現(xiàn)序列化與反序列化需要ObjectInputStrem（反序列化）和ObjectOutputStream（序列化）。并且序列化對象需要實現(xiàn)Serializable接口。

代碼：

//實現(xiàn)Serializable接口
public class Person implements Serializable{
    private static final long serialVersionUID = 2063917965595163411L;
    private String name;
    private Integer age;
    private String Sex;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getSex() {
        return Sex;
    }
    public void setSex(String sex) {
        Sex = sex;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", Sex='" + Sex + '\'' +
                '}';
    }
}
public class JavaSerializableDemo {
    //初始化一個Person對象
    public static Person initPerson(){
        Person person = new Person();
        person.setAge(18);
        person.setName("Mike");
        person.setSex("man");
        return person;
    }
//序列化
    public static Person serialize(){
        Person person = initPerson();
	//創(chuàng)建一個文件輸出流，把序列化的數(shù)據(jù)寫到文件中。
	//創(chuàng)建一個ObjectOutputStream 用于序列化對象，將序列化的數(shù)據(jù)寫到fileOutputStream 流中。
        try (FileOutputStream fileOutputStream = new FileOutputStream("person");
             ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);){
		//序列化對象
            objectOutputStream.writeObject(person);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return person;
    }
//反序列
    public static Person deSerialize(){
        Person person = null;
        //創(chuàng)建一個文件輸入流，用于讀取序列化文件。
        //創(chuàng)建一個objectInputStream ，用于反序列化對象，通過讀取fileInputStream 流數(shù)據(jù)進行反序列化
        try (FileInputStream fileInputStream = new FileInputStream("person");
        ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);){
			//反序列化
            person = (Person) objectInputStream.readObject();
           return person;
        }catch (IOException e){
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return person;
    }
    public static void main(String[] args) {
        Person person = serialize();
        Person person1 = deSerialize();
        System.out.println("person==>" + person);
        System.out.println("person1==>" +person1);
        //判斷兩個對象是否是用一個對象
        System.out.println("person == person1 ==> " + (person == person1));
        //分別修改屬性，看看會不會影響另外一個對象
        person.setAge(20);
        person1.setName("john");
        System.out.println("person==>" + person);
        System.out.println("person1==>" +person1);
    }
}

結(jié)果：

在這里插入圖片描述

第一行和第二行對象的屬性值一樣說明了序列化會保存對象的狀態(tài)信息。第三行返回false，說明java的序列化機制實現(xiàn)的是對象的copy，而不是對象引用的copy。第四行和第五行，修改對象屬性不會影響另外一個對象，也說明了java的序列化機制實現(xiàn)的是對象的copy，而不是對象引用的copy。

如果被序列化的對象的類沒有實現(xiàn)Serializable接口，就會拋出異常。

在這里插入圖片描述

serialVersionUID

serialVersionUID，是序列化版本控制UID，其目的是序列化對象版本控制，有關(guān)各版本反序列化時是否兼容。如果在新版本中這個值修改了，新版本就不兼容舊版本，反序列化時會拋出InvalidClassException異常。如果修改較小，比如僅僅是增加了一個屬性，我們希望向下兼容，老版本的數(shù)據(jù)都能保留，那就不用修改；如果我們刪除了一個屬性，或者更改了類的繼承關(guān)系，必然不兼容舊數(shù)據(jù)，這時就應(yīng)該手動更新版本號，即SerialVersionUid。

如果沒有顯示指定該版本號，編譯器會在編譯類文件時自動幫我們根據(jù)類的信息創(chuàng)建一個版本號。如果沒有指定版本號的情況下修改類文件信息，會導(dǎo)致編譯器生成的版本id不一樣，在反序列化時就會拋出異常。

步驟：

不顯示指定版本id。進行序列化操作。修改Person類，比如新增一個fatherName屬性。然后用之前序列化的文件進行反序列化為修改后的Person類。

結(jié)果：

在這里插入圖片描述

由于Person文件進過了修改，編譯器生成的版本id就會變化。然后就會導(dǎo)致序列化時的版本id與反序列化時的版本id對不上而拋出異常。

指定版本id后，就算修改文件，也不會導(dǎo)致反序列化異常。

靜態(tài)變量的序列化

靜態(tài)變量不會被序列化，也就是序列化時會忽略靜態(tài)變量。因為靜態(tài)變量是類級別的屬性，而java序列化機制保存的是對象的狀態(tài)信息。

代碼： person新增一個live的靜態(tài)屬性。

在這里插入圖片描述

 public static void main(String[] args) {
        //先序列化
        Person person = serialize();
        //修改靜態(tài)變量的值
        person.live = "宇宙";
        //反序列化
        Person person1 = deSerialize();


        System.out.println(person1.live);

    }

結(jié)論：首先把對象序列化，如果會把靜態(tài)變量的值序列化的話，那么反序列化出來的對象的靜態(tài)變量值就應(yīng)該是序列化前的值，也就是地球村。

如果會忽略靜態(tài)變量的話，那么反序列化出來的對象的靜態(tài)變量值就應(yīng)該是序列化后修改的值，也就是宇宙。

在這里插入圖片描述

transient

transient關(guān)鍵字用于修飾成員變量，被修飾的成員變量不會被java的序列化機制序列化。所以反序列化時得到的對象的該屬性會使用默認(rèn)值，對象引用默認(rèn)null，int 默認(rèn)為0等，或者如果該類里面初始化了，就使用初始化的值。

Person加上一個被transient修飾的屬性aliasName

在這里插入圖片描述

修改測試代碼和初始化代碼，初始化aliasName，序列化和反序列化代碼不變：

//初始化一個Person對象
    public static Person initPerson(){
        Person person = new Person();
        person.setAge(18);
        person.setName("Mike");
        person.setSex("man");
        person.setAliasName("Handsome Mike");
        return person;
    }

 public static void main(String[] args) {
        //先序列化
        Person person = serialize();
        //反序列化

        Person person1 = deSerialize();

        //輸出被transient修飾的屬性aliasName

        System.out.println(person.getAliasName());

        System.out.println(person1.getAliasName());

    }

結(jié)果：

在這里插入圖片描述

反序列化的對象Person的aliasName屬性為null。表名在序列化時，該屬性被忽略了。

繼承關(guān)系的序列化

序列化某個類，如果該類有父類且父類沒有實現(xiàn)Serializable接口，則不會序列化父類的屬性，反序列化時父類的屬性會使用默認(rèn)值或者創(chuàng)建對象時就初始化的值。

//person類繼承一個父類。
//實現(xiàn)Serializable接口
public class Person extends SupperPerson implements Serializable{


    private String name;

    private Integer age;

    private String Sex;

    private transient String aliasName;

    public static  String live = "地球村";



    public String getAliasName() {
        return aliasName;
    }

    public void setAliasName(String aliasName) {
        this.aliasName = aliasName;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public String getSex() {
        return Sex;
    }

    public void setSex(String sex) {
        Sex = sex;
    }

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

//父類
public class SupperPerson{

    private String aaa;

    private String bbb;


    public String getAaa() {
        return aaa;
    }

    public void setAaa(String aaa) {
        this.aaa = aaa;
    }

    public String getBbb() {
        return bbb;
    }

    public void setBbb(String bbb) {
        this.bbb = bbb;
    }
}

//初始化：
//初始化一個Person對象
    public static Person initPerson(){
        Person person = new Person();
        person.setAge(18);
        person.setName("Mike");
        person.setSex("man");
        person.setAliasName("Handsome Mike");
        //初始化父類屬性
        person.setAaa("aaaaa");
        person.setBbb("bbbbb");
        return person;
    }

//測試
public static void main(String[] args) {
        //先序列化
        Person person = serialize();
        //反序列化

        Person person1 = deSerialize();

        //輸出被transient修飾的屬性aliasName

        System.out.println(person.getAaa());

        System.out.println(person.getBbb());


        System.out.println(person1.getAaa());

        System.out.println(person1.getBbb());

    }

結(jié)果：

在這里插入圖片描述

父類的屬性aaa和bbb沒有被序列化保存下來。

如果父類也實現(xiàn)了Serializable接口，就會序列化父類的屬性。

在這里插入圖片描述

其他代碼一樣。結(jié)果：

在這里插入圖片描述

反序列化后父類的屬性不再是null。

通常序列化實現(xiàn)深度克隆

克隆一個對象就是保存原對象的狀態(tài)信息新建一個對象，實現(xiàn)對象的拷貝，新對象與原對象在堆上是兩個不同的對象。

public class Student implements Serializable,Cloneable{
    private String name;

    private Integer age;

    private String Sex;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public String getSex() {
        return Sex;
    }

    public void setSex(String sex) {
        Sex = sex;
    }

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //實現(xiàn)父類的clone方法。調(diào)用序列化和反序列化。
        return deSerialize(serialize(this));
    }

    /**
     * 序列化返回序列化的字節(jié)數(shù)組
     * @param student
     * @return
     */
    private  byte[] serialize(Student student){

        try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
             ObjectOutputStream objectOutputStream = new ObjectOutputStream(bos);){


            objectOutputStream.writeObject(student);
            return bos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 通過序列化字節(jié)數(shù)組反序列化成Student對象。
     * @param studentByteArray
     * @return
     */
    private  Student deSerialize(byte[] studentByteArray){
        try (ByteArrayInputStream bis = new ByteArrayInputStream(studentByteArray);
             ObjectInputStream objectInputStream = new ObjectInputStream(bis);){

            Student student = (Student) objectInputStream.readObject();

            return student;

        }catch (IOException e){
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}


//測試
 public static void main(String[] args) {
        Student student = new Student();
        student.setAge(22);
        student.setName("Mike");
        student.setSex("man");

        try {
            Student studentCopy = (Student) student.clone();
            System.out.println(student);
            System.out.println(studentCopy);
            System.out.println(student == studentCopy);
            System.out.println(student.getName() == studentCopy.getName());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

    }

結(jié)果：

在這里插入圖片描述