序列化 | Gavin's blog

序列化概述

对象的序列化主要有两种用途：

把对象序列化成字节码保存到指定介质上(如磁盘)
用于网络传输

对象序列化需要注意的几个情境

serialVersionUID 的作用

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

serialVersionUID 在 Eclipse 下提供了两种生成策略，一个是固定的 1L，一个是随机生成一个不重复的 long 类型数据，在这里有一个建议，如果没有特殊需求，就是用默认的 1L 就可以，这样可以确保代码一致时反序列化成功。那么随机生成的 serialVersionUID 有什么作用呢，有些时候，通过改变 serialVersionUID 可以用来限制某些用户的使用。

IO Serialization

Client 端通过 Façade Object 才可以与业务逻辑对象进行交互。而 Façade Object 不能直接由 Client 生成，而是需要 Server 端生成，然后序列化后通过网络将二进制对象数据传给 Client，Client 负责反序列化得到 Façade 对象。该模式可以使得 Client 端程序的使用需要服务器端的许可，同时 Client 端和服务器端的 Façade Object 类需要保持一致。当服务器端想要进行版本更新时，只要将服务器端的 Façade Object 类的 serialVersionUID 再次生成，当 Client 端反序列化 Façade Object 就会失败，也就是强制 Client 端从服务器端获取最新程序。

注意，当未显式定义 serialVersionUID 的值时，Java 根据类的多个方面动态生成一个默认值，尽管这样，还是建议你在每一个序列化的类中显式指定 serialVersionUID 的值，因为不同的 jdk 编译很可能会生成不同的 serialVersionUID 默认值，进而导致在反序列化时抛出 InvalidClassExceptions 异常。所以，为了保证在不同的 jdk 编译实现中，其 serialVersionUID 的值也一致，可序列化的类必须显式指定 serialVersionUID 的值。另外，serialVersionUID 的修饰符最好是 private，因为 serialVersionUID 不能被继承，所以建议使用 private 修饰 serialVersionUID。

静态变量序列化

序列化保存的是对象的状态，静态变量属于类的状态，因此序列化并不保存静态变量。

public class Test implements Serializable {

    private static final long serialVersionUID = 1L;

    public static int staticVar = 5;

    public static void main(String[] args) {
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("result.obj"));
            oos.writeObject(new Test());
            oos.close();

            Test.staticVar = 10;

            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("result.obj"));
            Test t = (Test) ois.readObject();
            ois.close();

            System.out.println(t.staticVar); // 10
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

父类的序列化

情境：一个子类实现了 Serializable 接口，它的父类都没有实现 Serializable 接口，序列化该子类对象，然后反序列化后输出父类定义的某变量的数值，该变量数值与序列化时的数值不同。
解决：要想将父类对象也序列化，就需要让父类也实现 Serializable 接口。在父类没有实现 Serializable 接口时，虚拟机是不会序列化父对象的。
一个 Java 对象的构造必须先有父对象才有子对象，反序列化也不例外。所以反序列化时，为了构造父对象，只能调用父类的无参构造函数作为默认的父对象。因此当我们取父对象的变量值时，它的值是调用父类无参构造函数后的值。如果你考虑到这种序列化的情况，在父类无参构造函数中对变量进行初始化，否则的话，父类变量值都是默认声明的值，如 int 类型的默认是 0，String 类型的默认是 null。

Transient 关键字

Transient 关键字的作用是控制变量的序列化，在变量声明前加上该关键字，可以阻止该变量被序列化到文件中，在被反序列化后，transient 变量的值被设为初始值，如 int 类型的是 0，对象类型的是 null。

当然，除了使用 Transient 关键字可以使得字段不被序列化外，我们也可以根据父类对象序列化的规则，将不需要被序列化的字段抽取出来放到父类中，子类实现 Serializable 接口，父类不实现，根据父类序列化规则，父类的字段数据将不被序列化，从而使得代码更加简洁。

对敏感字段加密

情境：服务器端给客户端发送序列化对象数据，对象中有一些数据是敏感的，比如密码字符串等，希望对该密码字段在序列化时进行加密，而客户端如果拥有解密的密钥，只有在客户端进行反序列化时，才可以对密码进行读取，这样可以一定程度保证序列化对象的数据安全。

解决：在序列化过程中，虚拟机会试图调用对象类里的 writeObject 和 readObject 方法，进行用户自定义的序列化和反序列化，如果没有这样的方法，则默认调用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程，比如可以在序列化的过程中动态改变序列化的数值。基于这个原理，可以在实际应用中得到使用，用于敏感字段的加密工作。

public class Test implements Serializable {

    private static final long serialVersionUID = 1L;

    private String password = "pass";

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    private void writeObject(ObjectOutputStream out) {
        try {
            ObjectOutputStream.PutField putFields = out.putFields();
            System.out.println("原密码: " + password);
            password = "encryption"; // 模拟加密
            putFields.put("password", password);
            System.out.println("加密后的密码: " + password);
            out.writeFields();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void readObject(ObjectInputStream in) {
        try {
            ObjectInputStream.GetField readFields = in.readFields();
            Object object = readFields.get("password", "");
            System.out.println("要解密的字符串: " + object.toString());
            password = "pass";// 模拟解密
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("result.obj"));
            oos.writeObject(new Test());
            oos.close();

            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("result.obj"));
            Test t = (Test) ois.readObject();
            ois.close();

            System.out.println("解密后的字符串: " + t.getPassword());
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

RMI 技术是完全基于 Java 序列化技术的，服务器端接口调用所需要的参数对象来至于客户端，它们通过网络相互传输，这就涉及 RMI 的安全传输的问题。一些敏感的字段，如用户名密码(用户登录时需要对密码进行传输)，我们希望对其进行加密，这时，就可以采用本节介绍的方法在客户端对密码进行加密，服务器端进行解密，确保数据传输的安全性。

序列化存储规则

public class Test implements Serializable {

    private static final long serialVersionUID = 1L;

    public static void main(String[] args) {
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("result.obj"));
            Test test = new Test();
            // 试图将对象两次写入文件
            oos.writeObject(test);
            oos.flush();
            System.out.println(new File("result.obj").length()); // 47
            oos.writeObject(test);
            oos.close();
            System.out.println(new File("result.obj").length()); // 52

            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("result.obj"));
            // 从文件依次读出两个文件
            Test t1 = (Test) ois.readObject();
            Test t2 = (Test) ois.readObject();
            ois.close();

            // 判断两个引用是否指向同一个对象
            System.out.println(t1 == t2); // true
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Java 序列化机制为了节省磁盘空间，具有特定的存储规则，当写入文件的为同一对象时，并不会再将对象的内容进行存储，而只是再次存储一份引用，上面代码输出结果增加的 5 字节的存储空间就是新增引用和一些控制信息的空间。反序列化时，恢复引用关系，使得 t1 和 t2 指向唯一的对象，二者相等，输出 true。该存储规则极大的节省了存储空间。

public class Test implements Serializable {

    private static final long serialVersionUID = 1L;

    private int i = 0;

    public static void main(String[] args) {
        try {
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("result.obj"));
            Test test = new Test();
            test.i = 1;
            out.writeObject(test);
            out.flush();
            test.i = 2;
            out.writeObject(test);
            out.close();

            ObjectInputStream oin = new ObjectInputStream(new FileInputStream("result.obj"));
            Test t1 = (Test) oin.readObject();
            Test t2 = (Test) oin.readObject();

            System.out.println(t1.i + ":" + t2.i);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

上面代码目的是希望将 test 对象写入一次以后修改对象属性值再次保存第二次，然后从 result.obj 中再依次读出两个对象，输出这两个对象的 i 属性值，结果两个输出的都是 1。原因就是第一次写入对象以后，第二次再试图写的时候，虚拟机根据引用关系知道已经有一个相同对象已经写入文件，因此只保存第二次写的引用，所以读取时，都是第一次保存的对象。所以在使用一个文件多次 writeObject 时需要特别注意这个问题。

序列化实现深克隆

浅克隆：复制出来的对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。
深克隆：复制出来的所有变量都含有与原来的对象相同的值，那些引用其他对象的变量将指向复制出来的新对象，而不再是原有的那些被引用的对象，换言之，深复制把要复制的对象所引用的对象都复制了一遍。

public class Test implements Cloneable {

    private Foo foo;

    public Test() {
        this.foo = new Foo();
    }

    /**
     * 重写该方法(让持有的引用foo不再指向原来的对象)
     */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Test test = (Test) super.clone();
        test.foo = (Foo) this.foo.clone();
        return test;
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        Test orig = new Test();
        Test clone = (Test) orig.clone();
        System.out.println(orig.foo == clone.foo);
    }

    static class Foo implements Cloneable {

        @Override
        public Object clone() {
            Foo foo = null;
            try {
                foo = (Foo) super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
            return foo;
        }

    }

}

通过实现 Cloneable 接口并重写 clone 方法虽然能实现深克隆，但是，如果要克隆的对象继承链比较长的话，要实现深克隆，就必须逐层地实现 Cloneable 接口，比较麻烦。
Java可以把对象序列化写进一个流里面，反之也可以把对象从序列化流里面读取出来，但这一进一出，这个对象就不再是原来的对象了，这样就可以简便地实现深克隆了。

public class Test implements Serializable {

    private static final long serialVersionUID = 1L;

    private Foo foo;

    public Test() {
        this.foo = new Foo();
    }

    protected Test serializableClone() {
        Test clone = null;
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(this);
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            clone = (Test) ois.readObject();
        } catch (ClassNotFoundException | IOException e) {
            e.printStackTrace();
        }
        return clone;
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        Test orig = new Test();
        Test clone = orig.serializableClone();
        System.out.println(orig.foo == clone.foo);
    }

    static class Foo implements Serializable {

        private static final long serialVersionUID = 1L;

    }

}

序列化技术

由于 Java 本身的序列化机制存在着序列化结果比较大、传输效率低、不能跨语言的问题，所以出现了基于 XML 和 JSON 以及基于二进制协议的序列化机制，基于二进制协议的比较主流的有 Hessian、MessagePack、Thrift、Protobuf、Avro、Kryo。

参考链接

杨硕, 魏强. Java序列化的高级认识