认识Java序列化

引言

将 Java 对象序列化为二进制文件的 Java 序列化技术是 Java 系列技术中一个较为重要的技术点，在大部分情况下，开发人员只需要了解被序列化的类需要实现 Serializable 接口，使用 ObjectInputStream 和 ObjectOutputStream 进行对象的读写。然而在有些情况下，光知道这些还远远不够，文章列举了笔者遇到的一些真实情境，它们与 Java 序列化相关，通过分析情境出现的原因，使读者轻松牢记 Java 序列化中的一些高级认识。

文章结构

本文将逐一的介绍几个情境，顺序如下面的列表。

序列化 ID 的问题
静态变量序列化
父类的序列化与 Transient 关键字
序列化存储规则
序列化实现深克隆

序列化工具类

public class JdkSerializationUtil {

    private static final int DEFAULT_BUFFER_SIZE = 2048;

    private static final byte[] DEFAULT_VALUE = new byte[0];

    public static byte[] serialize(Object data) {
        if (Objects.isNull(data)) {
            return DEFAULT_VALUE;
        }
        if (!(data instanceof Serializable)) {
            throw new IllegalArgumentException(data.getClass().getSimpleName() + " requires implements Serializable");
        }
        // 这个括号在JDK1.7之前是没有的，是1.7的新特性。
        // 括号里的内容支持包括流以及任何可关闭的资源，数据流会在 try 执行完毕后自动被关闭，而不用我们手动关闭了
        try (
                ByteArrayOutputStream bos = new ByteArrayOutputStream(DEFAULT_BUFFER_SIZE);
                ObjectOutputStream oos = new ObjectOutputStream(bos)) {

            oos.writeObject(data);
            oos.flush();

            return bos.toByteArray();
        } catch (IOException e) {
            throw new RuntimeException("Failed to serialize Object[" + data.getClass().getSimpleName() + "]", e);
        }
    }

    public static <T> T deserialize(byte[] data, Class<T> clazz) {
        if (data == null && data.length == 0) {
            return null;
        }
        try (
                ByteArrayInputStream bis = new ByteArrayInputStream(data);
                ObjectInputStream ois = new ObjectInputStream(bis);) {
            return (T) ois.readObject();
        } catch (Exception e) {
            throw new RuntimeException("Failed to deserialize the byte array for " + clazz.getSimpleName(), e);
        }
    }
}

序列化 ID 问题

情境：两个客户端 A 和 B 试图通过网络传递对象数据，A 端将对象 C 序列化为二进制数据再传给 B，B 反序列化得到 C。

问题：C 对象的全类路径假设为 com.inout.Test，在 A 和 B 端都有这么一个类文件，功能代码完全一致。也都实现了 Serializable 接口，但是反序列化时总是提示不成功。

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

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

静态变量序列化

静态变量序列化问题代码：

public class StaticVariableTest implements Serializable {

    private static final long serialVersionUID = 1L;

    public static int staticVar = 5;

    private int age;

    public static void main( String[] args ) {

        StaticVariableTest test = new StaticVariableTest();
        test.age = 20;

        byte[] data = JdkSerializationUtil.serialize(test);

        // 序列化后修改为10
        StaticVariableTest.staticVar = 10;

        StaticVariableTest test2 = JdkSerializationUtil.deserialize(data, StaticVariableTest.class);
        System.out.println(test2.staticVar);
    }
}

这个 System.out.println(test2.staticVar) 语句输出的是 10 还是 5 呢？

最后的输出是 10，对于无法理解的读者认为，打印的 staticVar 是从读取的对象里获得的，应该是保存时的状态才对。之所以打印 10 的原因在于序列化时，并不保存静态变量，这其实比较容易理解，序列化保存的是对象的状态，静态变量属于类的状态，因此 序列化并不保存静态变量。

父类的序列化与 Transient 关键字

情境：一个子类实现了 Serializable 接口，它的父类都没有实现 Serializable 接口，序列化该子类对象，然后反序列化后输出父类定义的某变量的数值，该变量数值与序列化时的数值不同。

解决：要想将父类对象也序列化，就需要让父类也实现Serializable 接口。如果父类不实现的话的，就 需要有默认的无参的构造函数。在父类无参构造函数中对变量进行初始化，否则的话，父类变量值都是默认声明的值，如 int 型的默认是 0，string 型的默认是 null。

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

代码如下：

public class SuperUser {

    private static final long serialVersionUID = 1L;

    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "SuperUser{" +
                "age=" + age +
                '}';
    }

}

public class User extends SuperUser implements Serializable {

    private static final long serialVersionUID = 1L;

    private String name;

    private transient String sex;

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                "} " + super.toString();
    }
}

public class SuperTest {

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

        User user = new User();
        user.setName("lisi");
        user.setAge(30);
        user.setSex("男");

        User user2 = JdkSerializationUtil.deserialize(JdkSerializationUtil.serialize(user), User.class);
        System.out.println(user2);
    }
}

输出的结果为：

User{name='lisi', sex='null'} SuperUser{age=0}

序列化存储规则

存储规则问题代码如下：

public class SaveRuleTest implements Serializable {

    private static final long serialVersionUID = 1L;

    private int i;

    public static void main(String[] args) throws Exception {
        mutiSave();
        System.out.println("=========");
        mutiSave2();
    }

    public static void mutiSave() throws Exception {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("result"));

        SaveRuleTest test = new SaveRuleTest();
        // 试图将对象两次写入文件
        oos.writeObject(test);
        oos.flush();
        System.out.println(new File("result").length());

        oos.writeObject(test);
        oos.close();

        System.out.println(new File("result").length());


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

        // 判断两个引用是否指向同一个对象
        System.out.println(t1 == t2);
    }

    public static void mutiSave2() throws Exception {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("result1"));

        SaveRuleTest test = new SaveRuleTest();
        test.i = 1;
        // 试图将对象两次写入文件
        oos.writeObject(test);
        oos.flush();
        System.out.println(new File("result1").length());

        test.i = 2;
        oos.writeObject(test);
        oos.close();

        System.out.println(new File("result1").length());

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

        // 判断两个引用是否指向同一个对象
        System.out.println(t1 == t2);
        System.out.println(t1.i);
        System.out.println(t2.i);
    }
}

程序运行结果为：

62
67
true
=========
62
67
true
1
1

mutiSave()方法执行结果，我们看到，第二次写入对象时文件只增加了 5 字节，并且两个对象是相等的，这是为什么呢？

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

mutiSave2()的目的是希望将 test 对象两次保存到 result.obj 文件中，写入一次以后修改对象属性值再次保存第二次，然后从 result.obj 中再依次读出两个对象，输出这两个对象的 i 属性值。案例代码的目的原本是希望一次性传输对象修改前后的状态。

结果两个输出的都是 1，原因就是第一次写入对象以后，第二次再试图写的时候，虚拟机根据引用关系知道已经有一个相同对象已经写入文件，因此只保存第二次写的引用，所以读取时，都是第一次保存的对象。读者在使用一个文件多次 writeObject 需要特别注意这个问题。

序列化实现深拷贝

public class Teacher implements Serializable {

    private static final long serialVersionUID = -6635991328204468281L;

    private String name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class Student implements Serializable, Cloneable {

    private static final long serialVersionUID = 1L;

    private String name;

    private int age;

    private Teacher teacher;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Teacher getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

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

public class CloneTest {

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

        Teacher teacher = new Teacher();
        teacher.setName("tom");

        Student student = new Student();
        student.setName("zhangsan");
        student.setAge(20);
        student.setTeacher(teacher);

        System.out.println("student:" + student);

        // 浅拷贝
        Student student1 = (Student) student.clone();
        student1.getTeacher().setName("nick");
        System.out.println("student:" + student);
        System.out.println("student1:" + student1);

        // 深拷贝
        Student student2 = JdkSerializationUtil.deserialize(JdkSerializationUtil.serialize(student), Student.class);
        student2.getTeacher().setName("james");

        System.out.println("student:" + student);
        System.out.println("student2:" + student2);
    }
}

输出结果为：

student:Student{name='zhangsan', age=20, teacher=Teacher{name='tom'}}
student:Student{name='zhangsan', age=20, teacher=Teacher{name='nick'}}
student1:Student{name='zhangsan', age=20, teacher=Teacher{name='nick'}}
student:Student{name='zhangsan', age=20, teacher=Teacher{name='nick'}}
student2:Student{name='zhangsan', age=20, teacher=Teacher{name='james'}}

从上面的执行结果我们可以总结出：

浅拷贝（浅复制、浅克隆）：
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。
换言之，浅拷贝仅仅复制所拷贝的对象，而不复制它所引用的对象。

深拷贝（深复制、深克隆）：
被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。
那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。
换言之，深拷贝把要复制的对象所引用的对象都复制了一遍

最后编辑于：2018.09.06 19:42:16

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 217,734评论 6赞 505
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 92,931评论 3赞 394
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 164,133评论 0赞 354
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 58,532评论 1赞 293
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 67,585评论 6赞 392
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 51,462评论 1赞 302
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 40,262评论 3赞 418
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 39,153评论 0赞 276
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 45,587评论 1赞 314
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,792评论 3赞 336
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,919评论 1赞 348
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 35,635评论 5赞 345
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 41,237评论 3赞 329
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,855评论 0赞 22
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,983评论 1赞 269
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 48,048评论 3赞 370
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,864评论 2赞 354