Java 序列化与反序列化

什么是java序列化与反序列化？（了解）

• 序列化：把对象转换为字节序列的过程
• 反序列化：把字节序列恢复为对象的过程

为什么要序列化？（了解）

Java对象是运行在JVM的堆内存中，如果JVM停止后，它的生命也就戛然而止。为了能在JVM停止后，继续使用Java对象，需要将Java对象持久化（持久化就是将对象进行二进制转化为机器能识别的语言）。序列化使得对象可以脱离程序运行而独立存在。
在以下情况需要使用Java序列化：

• 想把的内存中的对象状态保存到一个文件中或者数据库中时候；
• 想用套接字在网络上传送对象的时候；
• 想通过RMI（远程方法调用）传输对象的时候。

什么是serialVersionUID？（熟悉）

序列化版本号ID，是一个用于标识序列化类版本的特殊字段。通常在实现 Serializable 接口的类中使用，用于确保序列化和反序列化的一致性。

点击 Alt + Enter （Intelij IDEA下），可以快速添加serialVersionUID（hash值），如果无法快速新增，可进行如下操作：
setting->Editor->Inspections->搜索UID->勾选Serializable class without ‘serialVersionUID’ 可以检查实现了Serializable的类是否设置了serialVersionUID。

serialVersionUID的生成有以下三种方式：

• 显式声明：默认的1L
• 显式声明：根据包名、类名、继承关系、非私有的方法和属性以及参数、返回值等诸多因素计算出的64位的hash值
• 隐式声明：未显式的声明serialVersionUID时java序列化机制会根据Class自动生成一个serialVersionUID（最好不要这样，因为如果Class发生变化，自动生成的serialVersionUID可能会随之发生变化，导致匹配不上）

常见的序列化有哪些？（了解）

• JDK原生序列化
• JSON序列化
• Protobuf
• Protostuff

序列化考虑的优先级：
安全性-》通用性-》兼容性-》性能-》效率-》空间开销

首选的还是 Hessian 与 Protobuf，因为他们在性能、时间开销、空间开销、通用性、 兼容性和安全性上，都满足了我们的要求。
Hessian 在使用上更加方便，在对象的兼 容性上更好。
Protobuf 则更加高效，通用性上更有优势。

JSON序列化和JDK序列化区别？
对于对象转化成json字符串和json字符串转化成对象，也是属于序列化和反序列化的范畴，相对于JDK提供的序列化机制，各有各的优缺点：

• JDK序列化/反序列化：原生方法不依赖其他类库、但是不能跨平台使用、字节数较大；
• json序列化/反序列化：json字符串可读性高、可跨平台使用无语言限制、扩展性好、但是需要第三方类库、字节数较大；

如何实现序列化？（熟悉）

• 对于要序列化对象的类要去实现Serializable接口（自动）或者Externalizable接口（手动，需重写writeExternal 和 readExternal 方法）
• JDK提供的ObjectOutputStream类的writeObject方法，实现序列化
• JDK提供的ObjectInputStream类的readObject方法，实现反序列化

下面演示JDK实现序列化与反序列化，示例如下：

准备 Children 类：

package demo.serializable;
import java.io.Serializable;
public class Children implements Serializable {
    //显示声明，默认为1L
    private static final long serialVersionUID = 1L;
    public String unSerializable;
}

准备 Parent 类：

package demo.serializable;
import java.io.Serializable;
public class Parent implements Serializable {
    //显示声明serialVersionUID，值为诸多因素计算出的64位的hash值
    private static final long serialVersionUID = 2673051781680263602L;
    public String name;
    public int age;
    public transient String address;
    public Children children;
}

准备 SerializationUtility 类，进行序列化操作：

package demo.serializable;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Base64;
public class SerializationUtility {
    public static void main(String[] args) throws IOException {
        Parent parent = new Parent();
        parent.name = "father";
        parent.age = 50;
        parent.children = new Children();
        String serializedObj = serializeObjectToString(parent);
        System.out.println("Serialized Parent object to string:");
        System.out.println(serializedObj);
    }

    /**
     * 将对象序列化为 字节序列
     */
    public static String serializeObjectToString(Serializable o) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(o);
        oos.close();
        return Base64.getEncoder().encodeToString(baos.toByteArray());
    }
}

准备 DeserializationUtility 类，进行反序列操作：

package demo.serializable;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.Base64;
public class DeserializationUtility {
    public static void main(String[] args) throws ClassNotFoundException, IOException {
        String serializedObj = "rO0ABXNyABhkZW1vLnNlcmlhbGl6YWJsZS5QYXJlbnQlGJZu2UbxsgIAA0kAA2FnZUwACGNoaWxkcmVudAAcTGRlbW8vc2VyaWFsaXphYmxlL0NoaWxkcmVuO0wABG5hbWV0ABJMamF2YS9sYW5nL1N0cmluZzt4cAAAADJzcgAaZGVtby5zZXJpYWxpemFibGUuQ2hpbGRyZW4AAAAAAAAAAQIAAUwADnVuU2VyaWFsaXphYmxlcQB+AAJ4cHB0AAZmYXRoZXI=";
        System.out.println("Deserializing Parent...");
        Parent deserializedObj = (Parent) deSerializeObjectFromString(serializedObj);

        System.out.println("Parent.name:" + deserializedObj.name);
        System.out.println("Parent.age:" + deserializedObj.age);
        //因为address字段加了 transient 修饰，不会进行序列化和反序列化，
        System.out.println("Parent.address：" + deserializedObj.address);
    }

    /**
     * 反序列化读取
     */
    public static Object deSerializeObjectFromString(String s) throws IOException, ClassNotFoundException {
        byte[] data = Base64.getDecoder().decode(s);
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(data));
        Object o = ois.readObject();
        ois.close();
        return o;
    }
}

序列化注意事项有哪些？（掌握）

在JDK实现序列化与反序列过程中，不难发现：

• 一个对象要进行序列化，如果该对象成员变量是引用类型的，那这个引用类型也一定要是可序列化的，否则会报错（java.io.NotSerializableException）。序列化的对象存在引用类型时，引用类型一定要实现序列化接口。
• 同一个对象多次序列化成字节序列，这多个字节序列反序列化成的对象还是同一个（使用==判断为true，因为所有序列化保存的对象都会生成一个序列化编号，当再次序列化时会去检查此对象是否已经序列化了，如果是，那序列化只会输出上个序列化的编号）。
• 对于不想序列化的字段可以在字段类型之前加上 transient 关键字修饰（反序列化时会被赋予默认值）。
• 静态（static）成员变量是属于类级别的，而序列化是针对对象的，所以不能序列化哦。
• 如果序列化一个可变对象，序列化之后，修改对象属性值，再次序列化，只会保存上次序列化的编号（这是个坑注意下，有兴趣的可以去验证一下）。

序列化源码解析（了解）

原理解析如下：

• ObjectOutputStream 对象调用 writeObject(“需要序列化的对象”)，进行对象的序列化；
• 进入 writeObject 方法，判定是否启用重写，启用则调用重写方法，否则调用 writeObject0(obj, false);
• 进入 writeObject0 方法后，代码拉到方法结尾，可以看到多个if-esle 判断，判定是否实现了Serializable接口，若否则抛出异常NotSerializableException，若是则调用 writeOrdinaryObject(obj, desc, unshared) 方法;
• 进入 writeOrdinaryObject 方法，方法中调用了 writeClassDesc(desc, false) ，该方法主要用于写入类的信息。写入类信息之后，会判定是否实现了Externalizable接口，进行写入对象信息，若是则调用 writeExternalData((Externalizable) obj)自定义的方法，若否则调用 writeSerialData(obj, desc);

JDK的序列化过程可以大致理解如下：
写头部：声明序列化协议、版本
写对象：类名、签名、属性名、属性类型、属性值、开头结尾数据。

源码详情如下：

ObjectOutputStream 对象调用 writeObject(“需要序列化的对象”)，进行对象的序列化。

/**
 * 将对象序列化为 字节序列
 */
public static String serializeObjectToString(Serializable o) throws IOException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(baos);
    //进行序列化
    oos.writeObject(o);
    oos.close();
    return Base64.getEncoder().encodeToString(baos.toByteArray());
}

进入 writeObject 方法，判定是否启用重写，启用则调用重写方法，否则调用 writeObject0(obj, false)，代码如下：

public final void writeObject(Object obj) throws IOException {
    //判定是否启用重写，启用则调用重写方法，否则调用 writeObject0(obj, false)
    if (enableOverride) {
        writeObjectOverride(obj);
        return;
    }
    try {
        writeObject0(obj, false);
    } catch (IOException ex) {
        if (depth == 0) {
            writeFatalException(ex);
        }
        throw ex;
    }
}

进入 writeObject0 方法后，代码拉到方法结尾，可以看到多个if-esle 判断，判定是否实现了Serializable接口，若否则抛出异常NotSerializableException，若是则调用 writeOrdinaryObject(obj, desc, unshared) 方法。代码片段如下：

//ObjectOutputStream 在序列化的时候，会判断被序列化的Object是哪一种类型，String？array？enum？还是 Serializable，如果都不是的话，抛出 NotSerializableException异常。
if (obj instanceof String) {
    writeString((String) obj, unshared);
} else if (cl.isArray()) {
    writeArray(obj, desc, unshared);
} else if (obj instanceof Enum) {
    writeEnum((Enum<?>) obj, desc, unshared);
} else if (obj instanceof Serializable) {
    writeOrdinaryObject(obj, desc, unshared);
} else {
    if (extendedDebugInfo) {
        throw new NotSerializableException(
            cl.getName() + "\n" + debugInfoStack.toString());
    } else {
        throw new NotSerializableException(cl.getName());
    }
}

进入 writeOrdinaryObject 方法，方法中调用了 writeClassDesc(desc, false) 方法，该方法主要用于写入类的信息。写入类信息之后，会写入对象信息。判定是否实现了Externalizable接口，若是则调用 writeExternalData((Externalizable) obj) 自定义的方法，若否则调用 writeSerialData(obj, desc)。代码片段如下：

//写入类信息
writeClassDesc(desc, false);
handles.assign(unshared ? null : obj);
//判定是否实现了Externalizable接口，是则调用 writeExternalData 的自定义方法，否则调用 writeSerialData 方法，写入对象信息。
if (desc.isExternalizable() && !desc.isProxy()) {
    writeExternalData((Externalizable) obj);
} else {
    writeSerialData(obj, desc);
}

至此，整个序列化的过程便结束了，如果有兴趣的可以继续深挖 writeExternalData((Externalizable) obj) 方法的内部。