序列化与反序列化

一、基本概念

1.序列化的定义

对象序列化指的是：将内存中的对象变为二进制数据流的形式进行传输或者是将其保存在文本中。（Object-->byte[])

并不是所有类的对象都可以被序列化，只有实现了Serializable接口的类才可以序列化。Serializable接口并没有任何的方法定义，只是一个标识而已。

2.序列化的分类

1）Java提供的一种序列化技术：Object(In Memory)-->byte[]
2）前端开发中：Object-->JSON-->JavaScript对象
3）JDK提供：Object-->XML

反序列化操作恰恰相反。

3.序列化的作用

常用于远程方法调用中，远程方法调用其实就是将对象序列化为二进制数据后进行网络传输。

4.定义一个可以被序列化的类

import java.io.Serializable;

/**
 * 定义一个可以被序列化的类（实现Serializable接口）
 */
class Person implements Serializable {
    private String name;
    private int age;
    private String email;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getEmail() {
        return email;
    }

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

序列化对象时需要保存的是对象中的属性，所以默认情况下对象的属性将被转为二进制数据流存在。

二、序列化与反序列化操作

1.序列化与反序列化对象

在java.io包中，提供了两个可以进行对象序列化和反序列操作的类：ObjectOutputStream（序列化）和ObjectInputStream类（反序列化）。这个操作采用自动化模式完成，默认情况下所有的属性都会被序列化下来。

ObjectOutputStream的声明：
public class ObjectOutputStream
    extends OutputStream implements ObjectOutput, ObjectStreamConstants;
ObjectOutputStream类的构造方法：
public ObjectOutputStream(OutputStream out) throws IOException;

ObjectInputStream类的声明：
public class ObjectInputStream
    extends InputStream implements ObjectInput, ObjectStreamConstants;
ObjectInputStream类的构造方法：
public ObjectInputStream(InputStream in) throws IOException;

2.序列化和反序列化操作

/**
 * 序列化操作步骤：
 * 1.准备序列化输出的文件
 * 2.准备要参与的序列化对象
 * 3.进行业务操作(Object-->byte[]),调用ObjectOutputStream类的writeObject(对象);
 */

package com.xunpu.testSerializable;

import java.io.*;
import java.nio.file.Paths;

/**
 * 定义一个可以被序列化的类（实现Serializable接口）
 */
class Person implements Serializable {
    private String name;
    private int age;
    private String email;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getEmail() {
        return email;
    }

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

/**
 * 序列化操作步骤：
 * 1.准备序列化输出的文件
 * 2.准备要参与的序列化对象
 * 3.进行业务操作(Object-->byte[]),调用ObjectOutputStream类的writeObject(对象);
 */
public class TestSerializable {
    public static void main(String[] args) {
        File file= Paths.get("E:","JavaFile","person.obj").toFile();
        Person person=new Person("张三",21,"123456789@qq.com");
        try(ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream(file))) {
            out.writeObject(person);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

/**
 * 反序列化业务操作：
 * 调用ObjectInputStream类的readObject(),并赋值给对应的对象。
 */

public class TestSerializable {
    public static void main(String[] args) {
        //1.准备序列化输出对象的文件
        File file= Paths.get("E:","JavaFile","person.obj").toFile();
        //2.准备实例化对象
        Person person=new Person("张三",21,"123456789@qq.com");
        //3.序列化业务操作：
        try(ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream(file))) {
            out.writeObject(person);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    //反序列化操作
        try(ObjectInputStream in=new ObjectInputStream(new FileInputStream(file))) {
            Person person1= (Person) in.readObject();
            System.out.println(person1);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

三、transient关键字

在对象序列化时，被transient修饰的属性将不会被序列化保存起来，输出将会变为空。

应用场景：某些属性不需要被序列化保存时使用。

package com.xunpu.testSerializable;

import java.io.*;
import java.nio.file.Paths;

class Student implements Serializable{
    private String name;
    private int age;
    private transient String id;//希望id属性不被序列化保存。

    public Student(String name, int age, String id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id='" + id + '\'' +
                '}';
    }
}
public class TestTransient {
    public static void main(String[] args) {
        File file= Paths.get("E:","JavaFile","student.obj").toFile();
        Student student=new Student("李四",23,"201011232123");
        try(ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream(file))) {
            out.writeObject(student);//序列化
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //反序列化
        try(ObjectInputStream in=new ObjectInputStream(new FileInputStream(file))){
            Student s= (Student) in.readObject();
            System.out.println(s);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}