Java对象的序列化

ゝ一纸荒年。 2022-01-26 05:13 230阅读 0赞

##### 基本概念 #####

*  什么是序列化和反序列化  
    序列化就是将对象写入到IO流中，反序列化就是从IO流中恢复对象。
 *  为什么需要序列化  
    序列化后的流，可用于持久化到磁盘，也可以用于网络传输。使得Java对象可以跨进程、跨主机使用。
 *  转成Json和XML算序列化吗  
    Java对象转成字符串、Json、XML等其实也称为“序列化”，但与JVM提供的序列化功能不太一样，可以说序列化是一个比较抽象的概念，但本文主要指JVM的序列化。

##### 如何序列化和反序列化 #####

*  实现Serializable接口  
    序列化最常用的方式是实现Serializable接口，然后让客户端去序列化。

public class Teacher implements Serializable {
        private String name;
        private int age;
    
        public Teacher(String name, int age) {
            System.out.println("调用了构造方法！");
            this.name = name;
            this.age = age;
        }
    	
        // getter方法
    }

public class Client {
        public static void main(String[] args) {
            System.out.println("序列化：");
            try(ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream("object.txt"))) {
                Teacher teacher = new Teacher("Tom", 53);
                System.out.println("序列化之前的hash：" + teacher.hashCode());
                out.writeObject(teacher);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            System.out.println("反序列化：");
            try(ObjectInputStream input = new ObjectInputStream(
                    new FileInputStream("object.txt"))) {
                Teacher teacher = (Teacher) input.readObject();
                System.out.println("Teacher的名字：" + teacher.getName());
                System.out.println("Teacher的年龄：" + teacher.getAge());
                System.out.println("序列化之后的hash：" + teacher.hashCode());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

输出结果：

序列化：
    调用了构造方法！
    序列化之前的hash：142666848
    反序列化：
    Teacher的名字：Tom
    Teacher的年龄：53
    序列化之后的hash：310656974

根据输出结果，我们可以总结出以下三点信息：

1.  不用提供无参构造方法
2.  反序列化时，不会调用构造方法
3.  如果没有重写hashCode，反序列化后，hashCode是不一样的

至于为什么hashCode会不一样？因为Java默认的hashCode是一个内存地址指针。反序列化后，对象自然不在原来的内存地址上，所以hashCode会不一样。所以这里我们提倡要覆盖hashCode方法和equals方法。

*  transient关键字  
    如果一个字段使用了`transient`关键字，那它就不会被序列化。在反序列化时，如果它的引用类型，值就是null，如果是基本类型，就是基本类型的默认值。这里我们尝试把age声明为`transient`的。会输出:

Teacher的年龄：0

*  自定义序列化方法  
    transient关键字虽然使用方便，但“可定制化”不强，比如我虽然不想序列化age字段，但希望它反序列化时默认值是18，这样的需求就得使用自定义序列化方法来实现。

主要有这样几个方法：

private void writeObject(java.io.ObjectOutputStream out) throws IOException;
    private void readObject(java.io.ObjectIutputStream in) throws IOException,ClassNotFoundException;
    private void readObjectNoData() throws ObjectStreamException;
    
    private Object writeReplace() throws ObjectStreamException;
    private Object readResolve() throws ObjectStreamException;

通过重写writeObject与readObject方法，就可以实现自定义的序列化和反序列化。这里需要注意的是两个方法要有“对称性”，自己在重写这两个方法的时候，需要保证被序列化后，能够顺利地被反序列化。

示例代码：

private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject();
        out.writeInt(age);
    }
    
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();
        age = in.readInt();
    }

> PS: 这两个类是私有的，是在什么时候被调用，如何被调用的呢？
> 
> 答案是通过反射。详情可见 ObjectOutputStream 中的 writeSerialData 方法，以及  
> ObjectInputStream 中的 readSerialData 方法。

除此之外，还可以使用writeReplace与readResolve实现更高程度地定制化。

1.  writeReplace：在序列化时，会先调用此方法，再调用writeObject方法。此方法可将任意对象代替目标序列化对象。
2.  readResolve：反序列化时替换反序列化出的对象，反序列化出来的对象被立即丢弃。此方法在readeObject后调用。

那readObjectNoData()方法用来干嘛的呢？详情可以看Serializable接口的注释。大意是：当序列化流不完整时，readObjectNoData()方法可以用来正确地初始化反序列化的对象。

*  实现Externalizable接口  
    `Externalizable`接口是继承自Serializable接口的。

使用Externalizable接口不同于Serializable接口，实现此接口必须实现接口中的两个方法实现自定义序列化，这是强制性的；必须提供public的无参构造器，因为在反序列化的时候需要反射创建对象。

示例代码：

@Override
    public void writeExternal(ObjectOutput out) throws IOException {
        StringBuffer reverse = new StringBuffer(name).reverse();
        out.writeObject(reverse);
        out.writeInt(age);
    }
    
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        this.name = ((StringBuffer) in.readObject()).reverse().toString();
        this.age = in.readInt();
    }

##### 常见问题 #####

*  如果不实现Serializable接口会怎样？  
    如果不实现Serializable接口(这里包括也不实现Externalizable)，客户端在序列化时，会报NotSerializableException异常。
 *  如果内部属性是引用类型，怎么办？  
    如果要序列化的对象内部有引用类型的属性，那这个属性也必须实现序列化，否则同样会报NotSerializableException异常。
 *  子类实现序列化，父类不实现序列化  
    子类实现序列化，父类不实现序列化，此时父类要实现一个无参数构造器，否则反序列化时会抛InvalidClassException异常。因为如果父类不实现序列化，反序列化时会调用父类的无参构造器。

// 父类：
    public class Person {
        private String nationality;
    
        public Person(String nationality) {
            this.nationality = nationality;
        }
    }
    
    // 子类：
    public class Teacher extends Person implements Serializable {
        private String name;
        private int age;
    
    
    
        public Teacher(String name, int age) {
            super("China"); // 调用父类的有参构造方法
            System.out.println("调用了构造方法！");
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public int getAge() {
            return age;
        }
    }
    
    // 客户端：
    public class Client {
        public static void main(String[] args) {
            System.out.println("序列化：");
            try(ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream("object.txt"))) {
                Teacher teacher = new Teacher("Tom", 53);
                System.out.println("序列化之前的hash：" + teacher.hashCode());
                out.writeObject(teacher);
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            System.out.println("反序列化：");
            try(ObjectInputStream input = new ObjectInputStream(
                    new FileInputStream("object.txt"))) {
                Teacher teacher = (Teacher) input.readObject();
                System.out.println("Teacher的名字：" + teacher.getName());
                System.out.println("Teacher的年龄：" + teacher.getAge());
                System.out.println("序列化之后的hash：" + teacher.hashCode());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

输出结果：

序列化：
    调用了构造方法！
    序列化之前的hash：1060830840
    反序列化：
    java.io.InvalidClassException: serialize.Teacher; no valid constructor
    	at java.base/java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:159)
    	at java.base/java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:864)
    	at java.base/java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2061)
    	at java.base/java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1594)
    	at java.base/java.io.ObjectInputStream.readObject(ObjectInputStream.java:430)
    	at serialize.Client.main(Client.java:20)

*  同一个对象多次序列化会发生什么？  
    Java序列化同一对象，并不会将此对象序列化多次得到多个对象。Java会给每个序列化成功的对象一个“序列化编号”。当程序试图序列化一个对象时，会先检查此对象是否已经序列化过，只有此对象从未（在此虚拟机）被序列化过，才会将此对象序列化为字节序列输出。否则，直接输出编号。

out.writeObject(teacher); // 序列化一次
    
    // 反序列化两次，会抛EOFException异常
    Teacher teacher = (Teacher) input.readObject();
    Teacher teacher2 = (Teacher) input.readObject();

Teacher teacher = new Teacher("Tom", 53);
    out.writeObject(teacher); 
    teacher.setAge(23)
    out.writeObject(teacher); // 序列化两次
    
    // 反序列化两次
    Teacher teacher = (Teacher) input.readObject();
    Teacher teacher2 = (Teacher) input.readObject();
    System.out.println(teacher.equals(teacher2)); // true
    System.out.println("Teacher的年龄：" + teacher.getAge()); // 53

*  序列化和反序列化的顺序？  
    反序列化时，取出对象的顺序与序列化是一致的。也就是说，先存先取，后存后取。

Teacher teacher1 = new Teacher("Tom", 53);
    out.writeObject(teacher1);
    Teacher teacher2 = new Teacher("Bob", 29);
    out.writeObject(teacher2);
    
    Teacher teacher1 = (Teacher) input.readObject();
    System.out.println(teacher1.getName()); // Tom
    Teacher teacher2 = (Teacher) input.readObject();
    System.out.println(teacher2.getName()); // Bob

#### 参考文章 ####

[java序列化，看这篇就够了][java]  
[深度解析JAVA序列化][JAVA]

[java]: https://juejin.im/post/5ce3cdc8e51d45777b1a3cdf#heading-6
[JAVA]: https://www.jianshu.com/p/2ba8e4991cff