序列化介绍

为什么需要序列化

Java 平台允许我们在内存中创建可复用的 Java 对象，但一般情况下，只有当 JVM 处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比 JVM 的生命周期更长。但在现实应用中，就可能要求在JVM停止运行之后能够保存(持久化)指定的对象，并在将来重新读取被保存的对象。Java 对象序列化就能够帮助我们实现该功能。

序列化的范围

使用 Java 对象序列化，在保存对象时，会把其状态保存为一组字节，在未来，再将这些字节组装成对象。必须注意地是，对象序列化保存的是对象的”状态”，即它成员变量。由此可知，对象序列化不会关注类中的静态变量。

序列化扩展应用

除了在持久化对象时会用到对象序列化之外，当使用 RMI(远程方法调用)，或在网络中传递对象时，都会用到对象序列化。

如何实现序列化

通过java.io中的类进行序列化和反序列化。

创建需要序列化的bean

import java.io.Serializable;

public class People implements Serializable {

    private String name;

    private static String staticName;

    public String publicName;

    protected String protectedName;

    String defaultName;

    private final String finalName = "finalName";

    private final static String finalStaticName = "staticFinalName";

    public String getName() {
        return name;
    }

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

    public static String getStaticName() {
        return staticName;
    }

    public static void setStaticName(String staticName) {
        People.staticName = staticName;
    }

    public String getPublicName() {
        return publicName;
    }

    public void setPublicName(String publicName) {
        this.publicName = publicName;
    }

    public String getProtectedName() {
        return protectedName;
    }

    public void setProtectedName(String protectedName) {
        this.protectedName = protectedName;
    }

    public String getDefaultName() {
        return defaultName;
    }

    public void setDefaultName(String defaultName) {
        this.defaultName = defaultName;
    }

    public String getFinalName() {
        return finalName;
    }

    public static String getFinalStaticName() {
        return finalStaticName;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", publicName='" + publicName + '\'' +
                ", protectedName='" + protectedName + '\'' +
                ", defaultName='" + defaultName + '\'' +
                ", finalName='" + finalName + '\'' +
                '}';
    }
}

序列化

import com.study.studyserialize.neans.People;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class WriteMain {

    public static void main(String[] args) throws IOException {
        try (ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./people.txt"));) {
            People people = new People();
            people.setName("小美");
            people.setDefaultName("default小美");
            people.setProtectedName("protected小美");
            people.setPublicName("public小美");
            outputStream.writeObject(people);
            System.out.println(people);
            outputStream.flush();
        }
    }

}

执行结果：

image-20200818184345096

image

反序列化

import com.study.studyserialize.neans.People;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ReadMain {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        try (ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./people.txt"));) {
            People people = (People) inputStream.readObject();
            System.out.println(people);
        }
    }

}

image-20200818184444158

==静态成员没有序列化和反序列化。==

序列化相关的类

ObjectInputStream

自定义序列化策略

image-20200818192429134

image-20200818192502049

image.png

保证怎么写入，怎么读取即可。

序列化id

idea开启提示或者忽略提示

image-20200818192721108

image-20200818192819323

虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（就是 private static final long serialVersionUID）

transient 阻止序列化

在变量声明前加上 Transient 关键字，可以阻止该变量被序列化到文件中，在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。
服务器端给客户端发送序列化对象数据，对象中有一些数据是敏感的，比如密码字符串等，希望对该密码字段在序列化时，进行加密，而客户端如果拥有解密的密钥，只有在客户端进行反序列化时，才可以对密码进行读取，这样可以一定程度保证序列化对象的数据安全。

添加transient关键字之前：