文档章节

【Java基础】序列化与反序列化深入分析

刘引惟
 刘引惟
发布于 2017/04/13 17:21
字数 4545
阅读 1
收藏 0

一、前言

  复习Java基础知识点的序列化与反序列化过程,整理了如下学习笔记。

二、为什么需要序列化与反序列化

  程序运行时,只要需要,对象可以一直存在,并且我们可以随时访问对象的一些状态信息,如果程序终止,那么对象是肯定不会存在的,但是有时候,我们需要在程序终止时保存对象的状态信息,之后程序再次运行时可以重新恢复到之前的状态,如,玩家玩游戏退出时,需要保存玩家的状态信息(如等级、装备等等),之后玩家再此登入时,必须要恢复这些状态信息。我们可以通过数据库手段来达到这个保存状态的目的,在Java中,我们有更简便的方法进行处理,那就是序列化与反序列化。序列化是一种对象持久化的手段,反序列化与序列化相反,其是通过序列化后的信息重新组装成对象。序列化与反序列化普遍应用在网络传输、RMI等场景中。

三、序列化概述

  3.1 序列化类结构图

  下面展示了与序列化相关的类的结构图

  说明:虚线框的表示接口类型,实线框表示具体的类。

  3.2 序列化关键字说明

  与序列化相关的关键字如下

  说明:

  1. 关键字transient,用来修饰字段,表示此字段在默认序列化过程中不会被处理,但是可以采用另外的手段进行处理。

  2. 关键字serialVersionUID,表示序列化版本号,当两个类的序列化ID一致时允许反序列化,默认可以采用编译器提供的值1L。

  3.3 序列化方法说明

  与序列化相关的方法如下

  说明:writeObject与readObject方法分别在ObjectOutput接口与ObjectInput接口中声明,在ObjectOutputStream与ObjectInputStream中实现。

四、Serializable

  4.1 Serializable定义

  Serializable定义如下  

public interface Serializable {
}

  说明:Serializable为一个接口,并且没有任何字段和方法,仅仅作为一个标识。

  4.2 使用说明

  当序列化对象时,只需要将对象标记为可序列化,即实现接口Serializable即可。下面的Person类实现了Serializable接口。 

package com.hust.grid.leesf.serializable;

import java.io.Serializable;

public class Person implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String name;
    private String gender;
    private int age;
    private transient Person friend;


    public Person() {
        
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    public Person getFriend() {
        return friend;
    }
    
    public void setFriend(Person friend) {
        this.friend = friend;
    }

    @Override
    public String toString() {
        return "name = " + name + ", gender = " + gender + ", age = " + age
                + ", friend info is [" + friend + "]";
    }
}

  Person类的friend字段设置为transient,表明不会被序列化,定义完Person类之后,我们即可以对Person类进行序列化与反序列化操作了,具体代码如下 

package com.hust.grid.leesf.serializable;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializableDemo {
    public static void main(String[] args) throws Exception {
        Person leesf = new Person();
        Person dyd = new Person();
        leesf.setAge(24);
        leesf.setGender("man");
        leesf.setName("leesf");
        
        dyd.setAge(24);
        dyd.setGender("woman");
        dyd.setName("dyd");    
        
        leesf.setFriend(dyd);
        dyd.setFriend(null);
        
        File file = new File("test");
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
        oos.writeObject(leesf);
        oos.flush();
        oos.close();
        System.out.println(leesf);
            
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        leesf = (Person) ois.readObject();
        ois.close();    
        System.out.println(leesf);    
    }
}

  运行结果如下  

name = leesf, gender = man, age = 24, friend info is [name = dyd, gender = woman, age = 24, friend info is [null]]
name = leesf, gender = man, age = 24, friend info is [null]

  说明:由于friend字段标记为transient,则默认序列化操作时不会进行序列化,反序列化后其值为null。

  4.3 问题说明

  1. Person类不实现Serializable接口

  若Person类不实现Serializable接口,进行序列化时,会发生什么,会出现如下异常。 

Exception in thread "main" java.io.NotSerializableException:****

  表示Person没有实现Serializable接口,具体原因如下

  在调用writeObject方法后,会经过一系列的调用,具体的调用栈如下

  说明:截取了writeObject0函数中的一段代码,可以看到会检查该对象是否是Serializable类型,不是,则会抛出异常。

  2. 处理transient对象

  当字段被transient修饰时,采用默认的序列化机制将不会对其进行处理,但是,如果要序列化transient字段时,如何做呢,可以在要进行序列化的类中添加writeObject和readObject方法,其方法签名如下 

private void writeObject(ObjectOutputStream stream) throws IOException
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException

  说明:注意,writeObject与readObject是采用private修饰符修饰的,说明,此方法只能在该类的其他方法中被调用,其他类中不能调用此方法,那么当调用ObjectOutputStream的writeObject方法时,如何调用到此方法来执行用户自定义处理逻辑的呢,答案是反射。利用反射可以在别的类中调用到此类中私有的方法,反射很强大。

  利用这个方法,我们修改Person类如下  

package com.hust.grid.leesf.serializable;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Person implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String name;
    private String gender;
    private int age;
    private transient Person friend;


    public Person() {
        
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    public Person getFriend() {
        return friend;
    }
    
    public void setFriend(Person friend) {
        this.friend = friend;
    }

    @Override
    public String toString() {
        return "name = " + name + ", gender = " + gender + ", age = " + age
                + ", friend info is [" + friend + "]";
    }

    private void writeObject(ObjectOutputStream stream) 
            throws IOException {
        stream.defaultWriteObject();
        stream.writeObject(friend);
    }
    
    private void readObject(ObjectInputStream stream) 
            throws IOException, ClassNotFoundException {
        stream.defaultReadObject();
        friend = (Person) stream.readObject();
    }
}

  测试类的代码不做修改,运行结果如下  

name = leesf, gender = man, age = 24, friend info is [name = dyd, gender = woman, age = 24, friend info is [null]]
name = leesf, gender = man, age = 24, friend info is [name = dyd, gender = woman, age = 24, friend info is [null]]

  说明:在实现自定义的逻辑时,在writeObject方法中可以调用defaultWriteObject()方法实现默认序列化(序列化非transient字段),可以单独处理transient关键字;在readObject方法中可以调用defaultReadObject()方法实现默认反序列化,可以单独处理transient关键字(需要赋值)。值得注意的是,writeObject方法中defaultWriteObject和处理transient关键字的逻辑必须与readObject中defaultReadObject和处理transient关键字的逻辑顺序一致,否则会抛出异常。

  在调用writeObject方法后,会经过一系列的调用,具体的调用栈如下

  说明:经过反射,最终会调用到在Person类中定义的writeObject方法。readObject方法的调用可以以此类比,不再累赘。

五、Externalizable

  除了使用Serializable接口进行序列化以外,还可以使用Externalizable接口来进行序列化。

  5.1 Externalizable定义

  Externalizable的定义如下  

public interface Externalizable extends java.io.Serializable {
    void writeExternal(ObjectOutput out) throws IOException;
    void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}

  说明:Externalizable实现了Serializable接口,并且添加了两个方法writeExternal与readExternal,需要序列化的类需要实现Externalizable接口,并且重写接口中定义的两个方法。

  5.2 使用说明

  首先将序列化的类实现Externalizable接口并且重写writeExternal与readExternal方法,并在这两个方法中实现处理逻辑。我们定义Person类如下

package com.hust.grid.leesf.serializable;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class Person implements Externalizable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String name;
    private String gender;
    private int age;
    private transient Person friend;
    
    public Person() {
        
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    public Person getFriend() {
        return friend;
    }
    
    public void setFriend(Person friend) {
        this.friend = friend;
    }

    @Override
    public String toString() {
        return "name = " + name + ", gender = " + gender + ", age = " + age
                + ", friend info is [" + friend + "]";
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeUTF(name);
        out.writeUTF(gender);
        out.writeInt(age);
        out.writeObject(friend);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
        name = in.readUTF();
        gender = in.readUTF();
        age = in.readInt();
        friend = (Person) in.readObject();        
    }    
}

  说明:Person类实现了Externalizable接口,重写了writeExternal与readExternal方法,并且实现了用户自定义序列化与反序列化逻辑。测试类代码不变,运行结果如下: 

name = leesf, gender = man, age = 24, friend info is [name = dyd, gender = woman, age = 24, friend info is [null]]
name = leesf, gender = man, age = 24, friend info is [name = dyd, gender = woman, age = 24, friend info is [null]]

  说明:从结果可知,成功进行了序列化与反序列化过程。值得注意的是,我们必须要给Person类提供一个无参构造器,才能正确完成序列化与反序列化过程。否则会抛出如下异常

  修改Person类如下

package com.hust.grid.leesf.serializable;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class Person implements Externalizable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String name;
    private String gender;
    private int age;
    private transient Person friend;
    
    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    public Person getFriend() {
        return friend;
    }
    
    public void setFriend(Person friend) {
        this.friend = friend;
    }

    @Override
    public String toString() {
        return "name = " + name + ", gender = " + gender + ", age = " + age
                + ", friend info is [" + friend + "]";
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeUTF(name);
        out.writeUTF(gender);
        out.writeInt(age);
        out.writeObject(friend);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
        name = in.readUTF();
        gender = in.readUTF();
        age = in.readInt();
        friend = (Person) in.readObject();        
    }    
}

  说明:提供一个参数的构造函数,没有无参构造函数,修改测试类代码如下  

package com.hust.grid.leesf.serializable;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializableDemo {
    public static void main(String[] args) throws Exception {
        Person leesf = new Person("leesf");
        Person dyd = new Person("dyd");
        leesf.setAge(24);
        leesf.setGender("man");
        leesf.setName("leesf");
        
        dyd.setAge(24);
        dyd.setGender("woman");
        dyd.setName("dyd");    
        
        leesf.setFriend(dyd);
        dyd.setFriend(null);
        
        File file = new File("test");
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
        oos.writeObject(leesf);
        oos.flush();
        oos.close();
        System.out.println(leesf);
            
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        leesf = (Person) ois.readObject();
        ois.close();    
        System.out.println(leesf);    
    }
}

  运行结果如下

name = leesf, gender = man, age = 24, friend info is [name = dyd, gender = woman, age = 24, friend info is [null]]
Exception in thread "main" java.io.InvalidClassException: com.hust.grid.leesf.serializable.Person; no valid constructor
    at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:150)
    at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:768)
    at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1775)
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:371)
    at com.hust.grid.leesf.serializable.SerializableDemo.main(SerializableDemo.java:32)

  说明:在反序列化的过程抛出了异常,可以看出是Person类没有合法的构造器,合法的构造器就是指无参构造器。当提供了无参构造器之后,就可以正确运行。

  5.3 问题说明

  1. Externalizable,writeObject与readObject方法

  如果Person类实现了Externalizable接口,并且在Person类中添加了writeObject与readObject方法,那么在进行序列化与反序列化时,是以哪种方法为准呢,修改Person类如下

package com.hust.grid.leesf.serializable;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

public class Person implements Externalizable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String name;
    private String gender;
    private int age;
    private transient Person friend;
    
    public Person() {
        
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    public Person getFriend() {
        return friend;
    }
    
    public void setFriend(Person friend) {
        this.friend = friend;
    }

    @Override
    public String toString() {
        return "name = " + name + ", gender = " + gender + ", age = " + age
                + ", friend info is [" + friend + "]";
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        System.out.println("use writeExternal method");
        out.writeUTF(name);
        out.writeUTF(gender);
        out.writeInt(age);
        out.writeObject(friend);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
        System.out.println("use readExternal method");
        name = in.readUTF();
        gender = in.readUTF();
        age = in.readInt();
        friend = (Person) in.readObject();        
    }    
    
    private void writeObject(ObjectOutputStream stream) 
            throws IOException {
        System.out.println("use writeObject method");
        stream.defaultWriteObject();
        stream.writeObject(friend);
    }
    
    private void readObject(ObjectInputStream stream) 
            throws IOException, ClassNotFoundException {
        System.out.println("use readObject method");
        stream.defaultReadObject();
        friend = (Person) stream.readObject();
    }
}

  说明:在方法中添加了打印语句,这样就可以轻易判别采用的何种方式。测试类代码如下  

package com.hust.grid.leesf.serializable;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializableDemo {
    public static void main(String[] args) throws Exception {
        Person leesf = new Person();
        Person dyd = new Person();
        leesf.setAge(24);
        leesf.setGender("man");
        leesf.setName("leesf");
        
        dyd.setAge(24);
        dyd.setGender("woman");
        dyd.setName("dyd");    
        
        leesf.setFriend(dyd);
        dyd.setFriend(null);
        
        File file = new File("test");
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
        oos.writeObject(leesf);
        oos.flush();
        oos.close();
        System.out.println(leesf);
            
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        leesf = (Person) ois.readObject();
        ois.close();    
        System.out.println(leesf);    
    }
}

  运行结果

use writeExternal method
use writeExternal method
name = leesf, gender = man, age = 24, friend info is [name = dyd, gender = woman, age = 24, friend info is [null]]
use readExternal method
use readExternal method
name = leesf, gender = man, age = 24, friend info is [name = dyd, gender = woman, age = 24, friend info is [null]]

  说明:从结果可以看出,是以Externalizable接口中定义的两个方法进行序列化与反序列化的,这时,读者可能又会有另外一个疑问,那就是为什么会打印两次呢?答案是因为该方法被调用了两次,因为Person类有一个Person域,会导致调用两次。

  2. 处理transient字段

  可以在writeExternal与readExternal方法中实现自定义逻辑,对transient字段进行序列化与反序列化。

六、序列化问题

  6.1 采用默认序列化机制,类的静态字段会被序列化吗?

  采用默认序列化机制进行序列化时,类的静态字段会被序列化吗,此时类的静态字段不会被序列化,当然,我们可以采用自定义序列化逻辑对静态变量进行序列化。

  6.2 父类序列化问题

  采用默认序列化机制序列化子类时,其父类的字段会被序列化吗?可以分为如下情形

  1. 父类没有实现Serializable接口,没有提供默认构造函数

  这时,反序列化会出错,提示没有提供正确的构造函数。修改Person类,代码如下

package com.hust.grid.leesf.serializable;

import java.io.Serializable;

class Human {
    private int number;
    
    public Human(int number) {
        this.number = number;
    }
    
    public int getNumber() {
        return number;
    }
    
    public void setNumber(int number) {
        this.number = number;
    }
    
    public String toString() {
        return "number = " + number;
    }
}

public class Person extends Human implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String name;
    private String gender;
    private int age;
    private transient Person friend;
    
    
    
    
    public Person(int number, String name) {
        super(number);
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    public Person getFriend() {
        return friend;
    }
    
    public void setFriend(Person friend) {
        this.friend = friend;
    }

    @Override
    public String toString() {
        return super.toString() + ", name = " + name + ", gender = " + gender + ", age = " + age
                + ", friend info is [" + friend + "]";
    }    
}

  测试类的的代码如下 

package com.hust.grid.leesf.serializable;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializableDemo {
    public static void main(String[] args) throws Exception {
        Person leesf = new Person(1, "leesf");
        Person dyd = new Person(2, "dyd");
        leesf.setAge(24);
        leesf.setGender("man");
        leesf.setName("leesf");
        
        dyd.setAge(24);
        dyd.setGender("woman");
        dyd.setName("dyd");    
        
        leesf.setFriend(dyd);
        dyd.setFriend(null);
        
        File file = new File("test");
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
        oos.writeObject(leesf);
        oos.flush();
        oos.close();
        System.out.println(leesf);
                    
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
        leesf = (Person) ois.readObject();
        ois.close();    
        System.out.println(leesf);    
    }
}

  运行结果 

number = 1, name = leesf, gender = man, age = 24, friend info is [number = 2, name = dyd, gender = woman, age = 24, friend info is [null]]
Exception in thread "main" java.io.InvalidClassException: com.hust.grid.leesf.serializable.Person; no valid constructor
    at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:150)
    at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:768)
    at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1775)
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:371)
    at com.hust.grid.leesf.serializable.SerializableDemo.main(SerializableDemo.java:32)

  说明:可以看出是没有提供合法的构造函数。

  2. 父类没有实现Serializable接口,提供默认构造函数

  第一步中出现了错误,此时,我们修改Person类,代码如下  

package com.hust.grid.leesf.serializable;

import java.io.Serializable;

class Human {
    private int number;
    public Human() {
        
    }
    public Human(int number) {
        this.number = number;
    }
    
    public int getNumber() {
        return number;
    }
    
    public void setNumber(int number) {
        this.number = number;
    }
    
    public String toString() {
        return "number = " + number;
    }
}
public class Person extends Human implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String name;
    private String gender;
    private int age;
    private transient Person friend;
    
    public Person() {
        super();
    }
    
    public Person(int number, String name) {
        super(number);
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    public Person getFriend() {
        return friend;
    }
    
    public void setFriend(Person friend) {
        this.friend = friend;
    }

    @Override
    public String toString() {
        return super.toString() + ", name = " + name + ", gender = " + gender + ", age = " + age
                + ", friend info is [" + friend + "]";
    }    
}

  说明:给Human类提供了无参构造函数。测试类代码不变,运行结果如下

number = 1, name = leesf, gender = man, age = 24, friend info is [number = 2, name = dyd, gender = woman, age = 24, friend info is [null]]
number = 0, name = leesf, gender = man, age = 24, friend info is [null]

  说明:此时,我们可以看到,可以进行反序列化了,但是父类的number字段被赋值为int的默认值0,Person类的transient字段没有被序列化。

  3. 父类实现Serializable接口

  当父类实现Serializable接口时,修改Person类代码如下 

package com.hust.grid.leesf.serializable;

import java.io.Serializable;

class Human implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private int number;
    public Human() {
        
    }
    public Human(int number) {
        this.number = number;
    }
    
    public int getNumber() {
        return number;
    }
    
    public void setNumber(int number) {
        this.number = number;
    }
    
    public String toString() {
        return "number = " + number;
    }
}
public class Person extends Human implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String name;
    private String gender;
    private int age;
    private transient Person friend;
    
    public Person() {
        super();
    }
    
    public Person(int number, String name) {
        super(number);
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    public Person getFriend() {
        return friend;
    }
    
    public void setFriend(Person friend) {
        this.friend = friend;
    }

    @Override
    public String toString() {
        return super.toString() + ", name = " + name + ", gender = " + gender + ", age = " + age
                + ", friend info is [" + friend + "]";
    }    
}

  测试类的代码不变,运行结果如下 

number = 1, name = leesf, gender = man, age = 24, friend info is [number = 2, name = dyd, gender = woman, age = 24, friend info is [null]]
number = 1, name = leesf, gender = man, age = 24, friend info is [null]

  说明:从结果可知,已经可以进行正确的序列化与反序列化了,子类的transient字段没有被序列化。

  6.3 共享对象序列化问题  

  当序列化的两个对象都包含另外一个对象的引用时,在反序列化时,另外一个对象只会出现一次吗?修改Person类代码如下  

package com.hust.grid.leesf.serializable;

import java.io.Serializable;

public class Person implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private String name;
    private String gender;
    private int age;
    private transient Person friend;
    
    public Person() {
        
    }
    
    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    public Person getFriend() {
        return friend;
    }
    
    public void setFriend(Person friend) {
        this.friend = friend;
    }
}

  测试类代码如下 

package com.hust.grid.leesf.serializable;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

public class SerializableDemo {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) throws Exception {
        Person leesf = new Person("leesf");    
        Person dyd = new Person("dyd");
        Person lr = new Person("lr");
        leesf.setAge(24);
        leesf.setGender("man");
        
        dyd.setAge(24);
        dyd.setGender("woman");
        
        lr.setAge(25);
        lr.setGender("man");
        
        leesf.setFriend(dyd);
        lr.setFriend(dyd);
        dyd.setFriend(null);
        
        List<Person> persons = new ArrayList<Person>();
        persons.add(leesf);
        persons.add(dyd);
        persons.add(lr);
        
        ByteArrayOutputStream bos1 = new ByteArrayOutputStream();
        ByteArrayOutputStream bos2 = new ByteArrayOutputStream();
        
        ObjectOutputStream oos1 = new ObjectOutputStream(bos1);
        oos1.writeObject(persons);
        oos1.writeObject(persons);
        
        ObjectOutputStream oos2 = new ObjectOutputStream(bos2);
        oos2.writeObject(persons);
        
        ByteArrayInputStream bis1 = new ByteArrayInputStream(bos1.toByteArray());
        ByteArrayInputStream bis2 = new ByteArrayInputStream(bos2.toByteArray());
        
        ObjectInputStream ois1 = new ObjectInputStream(bis1);
        ObjectInputStream ois2 = new ObjectInputStream(bis2);
        
        List<Person> persons1 = (List<Person>) ois1.readObject();
        List<Person> persons2 = (List<Person>) ois1.readObject();
        List<Person> persons3 = (List<Person>) ois2.readObject();
        
        System.out.println(persons1);
        System.out.println(persons2);
        System.out.println(persons3);    
    }
}

  运行结果如下  

[com.hust.grid.leesf.serializable.Person@7f31245a, com.hust.grid.leesf.serializable.Person@6d6f6e28, com.hust.grid.leesf.serializable.Person@135fbaa4]
[com.hust.grid.leesf.serializable.Person@7f31245a, com.hust.grid.leesf.serializable.Person@6d6f6e28, com.hust.grid.leesf.serializable.Person@135fbaa4]
[com.hust.grid.leesf.serializable.Person@45ee12a7, com.hust.grid.leesf.serializable.Person@330bedb4, com.hust.grid.leesf.serializable.Person@2503dbd3]

  说明:从结果可知,oos1执行的writeObject是向同一个内存空间写了两次,从结果可看出,两次写入的对象的地址空间都是一样的,即进行了浅拷贝。而oos2执行的writeObject是向另外一个内存空间写了一次,从结果可看出,因为对象的地址不同于之前的对象地址,即采用了深拷贝。

七、总结

  写到这里,关于Java中的序列化与反序列化机制就已经分析完了,经过此次分析,对序列化机制的认识更加深刻。学习一个知识点,就要认认真真,踏踏实实的弄懂一个知识点,写博客就是一个特别好的方式。谢谢各位园友的观看~

 

参考链接

http://blog.csdn.net/jiangwei0910410003/article/details/18989711/

http://www.hollischuang.com/archives/1140

本文转载自:http://www.cnblogs.com/leesf456/p/5328466.html

刘引惟
粉丝 7
博文 85
码字总数 18139
作品 0
浦东
私信 提问
Java对象的序列化与反序列化

序列化与反序列化 序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。一般将一个对象存储至一个储存媒介,例如档案或是记亿体缓冲等。在网络传输过程中,可以是字...

天蚕宝衣
2016/03/07
62
0
深入分析Java的序列化与反序列化

序列化是一种对象持久化的手段。普遍应用在网络传输、RMI等场景中。本文通过分析ArrayList的序列化来介绍Java序列化的相关内容。主要涉及到以下几个问题: 怎么实现Java的序列化 为什么实现了...

老二q
2016/09/13
32
0
深度解析单例与序列化之间的爱恨情仇~

转载:原文链接:https://mp.weixin.qq.com/s/iXC47w4tMfpZzTNxS_JQOw 首先来写一个单例的类:code 1 接下来是一个测试类: code 2 输出结构为false,说明: 通过对Singleton的序列化与反序列化...

u010398771
2018/02/04
0
0
百度、阿里、腾讯、京东、大型互联网分布式架构必备技能

分布式架构 迎接高并发大数据的挑战,从深度到广度完善知识体系,成为下一个互联网高薪人才。 理论结合实战,透彻理解分布式架构及其解决方案。 面向人群 1、工作1-5年需要突破瓶颈; 2、传统...

Java高级架构
2017/12/21
0
0
PHP反序列化漏洞系列之–PHP序列化和反序列化原理

0.前言 本文为笃行日常学习记录,web安全php漏洞系列。 对象的序列化和反序列化作用就不再赘述,php中序列化的结果是一个php自定义的字符串格式,有点类似json. 我们在任何语言中设计对象的序列...

fobnn
2018/08/27
0
0

没有更多内容

加载失败,请刷新页面

加载更多

mysql报错 [ERROR] Fatal error: Can't open and lock privilege tables: Table 'mysql.host' doesn't exist

CentOS 6.5 下安装配置 mysql 使用yum安装,具体过程参见最下边的参考文章。 安装之后启动失败: [root@localhost ~]# service mysqld startStarting mysqld: ...

BG2KNT
33分钟前
3
0
IOC的学习(1)

IOC IOC创建bean的4种方式: 无参构造器, 有参构造器,其中<constructor-arg>可以通过index="0"或者type="int"来指定构造方法参数。 静态工厂方法,factory-method。 普通工厂方法,需要指定......

太猪-YJ
47分钟前
2
0
tomcat 莫名奔溃问题

Apr 24, 2019 6:18:11 PM org.apache.coyote.AbstractProtocol pause INFO: Pausing ProtocolHandler ["http-nio-8080"] Apr 24, 2019 6:18:12 PM org.apache.coyote.AbstractProtocol pause......

mellen
今天
3
0
组件开发规范 class名身份识别

组件需要通过一个组件共有的class来标识这个组件,外部调用的时候,可以通过锁定这个class来方便地改变组件的css样式。 设置方式 .my-checkbox { width: 20px; height: 20px; font-...

Carbenson
今天
3
0
如何在工作中快速成长?致工程师的10个简单技巧

阿里妹导读:阿里有句非常经典的土话,“今天的最好表现,是明天的最低要求。”如何挖掘潜能、发现更好的自己?今天,阿里巴巴高级无线开发专家江建明将认知升级的方法总结出来,帮助你获得快...

阿里云云栖社区
今天
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部