java 对象序列化

Posted 2020-12-29 Delta

对象序列化

序列化    ：将java对象转换成字节序列，这些字节序列可以保存在磁盘上，或通过网络传输。

反序列化：将字节序列转换成java对象。

 

对象序列化步骤

• 需要序列化的对象所对应的类需要实现Serializable接口；

 

• 创建一个ObjectOutputStream实例，ObjectOutputStream是一个处理流，需要建立在其他节点流的基础之上；

// FileInputStream为节点流
 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));

 

• 调用ObjectOutputStream的writeObject()方法输出对象；

        // 将person对象写入object.txt文件中
        oos.writeObject(person);

 

示例如下：

定义一个Person类，该类实现Serializable接口

class Person implements java.io.Serializable {

    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {this.name = name;}
    public String getName() {return name;}
    public void setAge(int age) {this.age = age;}
    public int getAge() {return age;}

}

 

创建一个Person类的实例对象，并将该对象写入object.txt文件中。

    public static void main(String[] args) throws IOException {

        // FileInputStream为节点流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));

        Person person = new Person("Sunwukong", 500);
        // 将person对象写入object.txt文件中
        oos.writeObject(person);
    }

 

 

对象反序列化

反序列化：将字节序列转换成java对象。

 

对象反序列化步骤

• 创建一个ObjectInputStream实例，ObjectInputStream是一个处理流，需要建立在其他节点流的基础之上；

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));

 

• 调用ObjectInputStream的readObject()方法读取流中的对象，该方法返回一个Object类型的java对象，如果知道java对象的类型，可以将该对象强制类型转换成其真实类型；

Person person = (Person) ois.readObject();

 

示例如下：

恢复object.txt文件中存储的person对象。

    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException{

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
        Person newPerson = (Person) ois.readObject();
        System.out.println(newPerson.getName());   // 输出Sunwukong
        System.out.println(newPerson.getAge());    // 输出500
    }

 

反序列化得到的对象是一个全新的对象，是一个重新建造的对象，与原对象不同。

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        // 序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
        Person person = new Person("Sunwukong", 500);
        oos.writeObject(person);

        // 反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
        Person newPerson = (Person) ois.readObject();
        // newPerson是新建的对象，与person不是同一个对象
        System.out.println(person == newPerson); // 输出false
    }

 

 

限制序列化的实例变量

在一些情况下，一个类的某些实例变量为敏感信息，不希望系统将这些实例变量序列化。

或某些实例变量不可被序列化。

 

通过在实例变量前使用transient关键字，可以指定java序列化时忽略这些实例变量。

 

如在Person类中的实例变量age前使用transient关键字修饰，Person实例对象序列化时会忽视该变量

class Person  {

    private String name;
    // transient修饰age变量
    // 对象序列化时会忽略该变量
    private transient int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {this.name = name;}
    public String getName() {return name;}
    public void setAge(int age) {this.age = age;}
    public int getAge() {return age;}

}

 

    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException{

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
        Person newPerson = (Person) ois.readObject();
        System.out.println(newPerson.getName());   // 输出Sunwukong
        // age变量没有序列化，反序列化得到的值为默认值
        System.out.println(newPerson.getAge());    // 输出0
    }

 

 

 

实例变量为引用类型时

该引用类型必须是可序列化的，否则拥有该实例变量的类是不可序列化的（除非使用transient修饰该实例变量）。

 

当对某个对象进行序列化时，系统自动把该对象的实例变量序列化，如果某个实例变量引用到另一个对象，则被引用的对象也会被序列化；

若果被引用对象的实例变量也引用了其他对象，则被引用的对象也会被实例化；

. . . . . . .

这种情况被称为递归序列化。

 

示例：

定义Teacher类，该类的一个实例变量student为引用类型Person。

class Teacher implements java.io.Serializable {
    private String name;
    // student为引用类型
    private Person student;

    public Teacher(String name, Person student) {
        this.name = name;
        this.student = student;
    }

    public void setName(String name) {this.name = name;}
    public String getName() {return name;}
    public void setStudent(Person student) {this.student = student;}
    public Person getStudent() {return student;}
}

 

创建Teacher类的实例对象，并将该对象序列化（写入object.txt文件中）

        // 序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
        Person person = new Person("Sunwukong", 500);
        Teacher teacher = new Teacher("Tangseng", person);
        // 将teacher对象写入object.txt时，
        // 同时会将teacher中的引用类型变量student所指向的person对象写入object.txt中
        oos.writeObject(teacher);

 

反序列化teacher对象，也可以得到person对象

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
        Teacher newTeacher = (Teacher) ois.readObject();
        System.out.println(newTeacher.getName());   // 输出Tangseng
        Person newPerson = newTeacher.getStudent();
        System.out.println(newPerson.getName());    // 输出Sunwukong       
        System.out.println(newPerson.getAge());     // 输出500

 

 

 

多个对象的序列化

当多个对象序列化时，java序列化机制采用如下算法：

• 所有保存到磁盘中的对象都有一个序列化编号；
• 当程序试图序列化一个对象时，程序将先检查该对象是否已经被序列化过，只有该对象从未序列化过，系统才会将该对象序列化；
• 如果某个对象已经序列化过，程序将只是直接输出一个序列化编号，而不是再次重新序列化该对象。

 

 

示例：

创建一个Person类实例对象person;

创建两个Teacher类实例对象t1与t2，两个对象都包含person;

依次向object.txt文件中写入实例对象t1 、t2、person、t1

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        // 序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));
        Person person = new Person("Sunwukong", 500);
        Teacher t1 = new Teacher("Tangseng", person);
        Teacher t2 = new Teacher("Putizushi", person);
        // 将以上对象写入object.txt时，
        oos.writeObject(t1);
        oos.writeObject(t2);
        oos.writeObject(person);
        oos.writeObject(t1);


        // 反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
        // 依次读取object.txt中的对象
        Teacher newt1 = (Teacher)ois.readObject();
        Teacher newt2 = (Teacher)ois.readObject();
        Person newPerson = (Person) ois.readObject();
        Teacher obj = (Teacher)ois.readObject();

        System.out.println(newt1.getStudent() == newt2.getStudent());  // true
        System.out.println(newt1.getStudent() == newPerson);           // true
        System.out.println(newt1 == obj);                              // true
    }

 

上述程序只有3个对象被序列化：person、t1、t2。

oos.writeObject(t1);    // 序列化t1与person

oos.writeObject(t2);    //  序列化t2，person已经被序列化，t2中存放的是person序列化编码

oos.writeObject(person); // person已经被序列化，存放的是person序列化编码

oos.writeObject(t1);      // t1已经被序列化，存放的是t1序列化编码

 

所以，从object.txt中取出对象时

newPerson与 newt1、newt2中的person都是同一个对象

obj与newt1也是同一个对象。

 

 

其他

关于对象序列化有以下几点需要注意：

对象的类名、实例变量都会被序列化，方法、类变量（static修饰的成员变量）、transient实例变量都不会被序列化。

序列化对象的实例变量应当也是可序列化的，否则使用transient关键字修饰。

反序列化对象时必须有序列化对象的class文件。

反序列化读取对象，必须按实际写入顺序读取。