java序列化和反序列化

作者: 程序员的交流电 | 来源:发表于2019-11-28 15:23 被阅读0次

java专题之序列化
Java-序列化-反序列化
JAVA反序列化漏洞
Java序列化
JDK 序列化
Java序列化机制
Protostuff序列化和反序列化
Spark序列化
什么是序列化？常见的序列化协议有哪些？
序列化与反序列化

序列化是一种对象持久化的手段。普遍用在网络传输，RMI（远程方法调用），对象保存到本地等。

序列化的含义，意义和使用场景

序列化：将对象写入到IO流中
反序列化：从IO流中恢复对象
意义：序列化机制可以把对象转化为位字节序列，这些字节序列可以保存在磁盘上面，或是进行网络传输，然后使用反序列化，以达到以后恢复称原对象。序列化的机制可以使对象可以脱离程序的运行，而独立的存在。
使用的场景：所有在网络上面传输的对象，必须是可以序列化的。比如RMI（remote method invoke 远程方法调用），传入的参数和返回的结构都是可序列化的。所有需要保存到磁盘的对象都要实现序列化。通常建议创建的javaBean类都实现Serializable接口。

序列化的实现方式

java序列化的实现方式主要实现Serializable接口或者是Externalizable接口

一普通序列化实现Serializable接口

Serializable接口是一个标志接口，不用实现任何的方法。实现接口的对象就是可以序列化的。

1.1序列化

创建一个ObjectOutputStream流
调用ObjectOuputStream流来输出序列化对象

\\java bean
public class Book implements Serializable{
    private String name;
    private int age;
    public Book(String name,int age){
        this.name=name;
        this.age=age;
    }
    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
\\测试方法
public static void test1() {
        //使用try-close的方式来关闭流
        try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(
                new FileOutputStream("D:\\tmp\\abc.txt"))) {
            Book asdf = new Book("asdf", 10);
            objectOutputStream.writeObject(asdf);
            \\冲刷出流，将所有返回的缓冲的数据强制发送到目的地
            objectOutputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

1.2 反序列化

创建一个ObjectInputStream
调用ObjectInputStream对象的readObject方法

public static void test2() {
        //使用try-close关闭流
        try (ObjectInputStream in=new ObjectInputStream(new FileInputStream("D:\\tmp\\abc.txt"))){
            Book book = (Book) in.readObject();
            Book book1 = (Book) in.readObject();
            System.out.println(book);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

1.3 注意点

ObjectInputStream和ObjectOutPutStream都是有两个构造器的，一个是无参构造器但是proteced的，另外一个是有参构造器，参数是流，ObjectInputStream和ObjectOutputStream一般用于java的序列化的，把对象传入IO流里面，反序列化是把对象从IO流里面读取出来，所以，测试指的就是这个IO流。

// ObjectOutputStream构造器
public ObjectOutputStream(OutputStream out) throws IOException {
        verifySubclass();
        bout = new BlockDataOutputStream(out);
        handles = new HandleTable(10, (float) 3.00);
        subs = new ReplaceTable(10, (float) 3.00);
        enableOverride = false;
        writeStreamHeader();
        bout.setBlockDataMode(true);
        if (extendedDebugInfo) {
            debugInfoStack = new DebugTraceInfoStack();
        } else {
            debugInfoStack = null;
        }
    }
//ObjectInputStream构造器
public ObjectInputStream(InputStream in) throws IOException {
        verifySubclass();
        bin = new BlockDataInputStream(in);
        handles = new HandleTable(10);
        vlist = new ValidationList();
        serialFilter = ObjectInputFilter.Config.getSerialFilter();
        enableOverride = false;
        readStreamHeader();
        bin.setBlockDataMode(true);
    }

1.4 属性是引用的序列化

如果一个实现了Serializable的接口的类里面的属性是自定义的引用类型的话，必须也要实现Serializable接口，否则这个类无法序列化。

public class Title {
    private String title;
    public Title(String title){
        this.title=title;
    }
    @Override
    public String toString() {
        return "Title{" +
                "title='" + title + '\'' +
                '}';
    }
}
public class Book implements Serializable{
    private String name;
    private int age;
    private Title title;
    public Book(String name, int age, Title title){
        this.name=name;
        this.age=age;
        this.title=title;
    }
    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", title=" + title +
                '}';
    }
}
报错
java.io.NotSerializableException: com.zhi.ref.Title
    at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
    at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1548)
    at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1509)
    at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1432)
    at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1178)

我们看程序是因为Title的不可以序列化，导致了Book的序列化失败。

1.5 同一个对象序列化多次，对象只会被序列化一次，并且在反序列化的时候，也并不会创建多个对象，任然只会创建一个对象。

一个对象被序列化多次，其实底层只是对这对象序列化了异常

public static void main(String[] args) {
        test1();
        test2();
    }
    public static void test2() {
        //使用try-close关闭流
        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:\\tmp\\abc.txt"))) {
            Book book1 = (Book) in.readObject();
            Book book2 = (Book) in.readObject();
            Title title = (Title) in.readObject();
            System.out.println(book1==book2);
            System.out.println(book1.getTitle()==title);
            System.out.println(book1.getTitle()==title);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void test1() {
        //使用try-close的方式来关闭流
        try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(
                new FileOutputStream("D:\\tmp\\abc.txt"))) {
            final Title title = new Title("1111");
            Book book1 = new Book("asdf", 10, title);
            Book book2 = new Book("asdfddddd", 20, title);
            objectOutputStream.writeObject(book1);
            objectOutputStream.writeObject(book2);
            objectOutputStream.writeObject(title);
            objectOutputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

结果

false
true
true
true

由此可得，当一个对象被序列化多次，并不会将此对象序列化多次得到多个对象，反序列化的时候，任然只会有一个对象。
java序列化算法

所有保存到磁盘的对象都有一个序列化编码
当程序试图序列化一个对象到磁盘，首先会检查这个对象是否已经序列化过，只有这个对象从未被当前的虚拟机序列化过，才会将次对象序列称直接输出
当已经序列化过了，就会直接返回序列化编号的。
java序列化算法潜在问题
由于java序列化算法不会重复的序列化同一个对象，当在次序列化的时候，就会只记录序列化的编号，当对象的内容改变，在次的序列化任然不会再次的序列化，还是保存序列化编号

1.6 可选自定义序列化

有的时候，对象中有些属性是不用序列化的，比如密码等，这个时候，我们就可以使用transient关键字，在虚拟机序列化对象的时候，这个属性就不会序列化到指定的目的地里面。

将age使用transient进行一个序列化
输出结果如下：
age是默认值0，如果是对引用类型的使用transient，直接就会是null
Book{name='asdf', age=0, title=Title{title='1111'}}

虽然，使用trnasient简单，但是将这个属性完全的隔离在序列化之外。java提供了可选的自定义序列化，可以进行进行序列化的控制，或对序列化的数据进行编码和加密。

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 void readObject(ObjectInputStream inputStream) throws Exception{
        this.name=inputStream.readObject().toString();
        this.age=inputStream.readInt();
    }
//对你想要操作的属性进行编码或者是加密
    private void writeObject(ObjectOutputStream outputStream) throws IOException{
        outputStream.writeObject(name);
        outputStream.writeInt(age+100);
    }

readObjectNoData方法是在当数据流不完整的时候，或是不同的类接收反序列化的对象的时候，或者是序列化流被篡改的时候，系统都会调用readObjectNoData来进反序列化对象，一般是用不到的。
使用这个中重写以上三个方法的方式可以解决上面被transient关键字修饰的完全屏蔽序列化的这个弊端。
下面有一种更加彻底的序列化方式
Object writeReplace() throws ObjectStreamException;
Object readResolve() throws ObjectStreamException;
writeReplace方法：在序列化的时，会调用这个方法，在调用writeObject方法，这个方法的优点是可以用任意的对象来替代序列化对象。

Externalizable序列化方式

通过实现Externalizable接口，必须实现writeExternal、readExternal方法。

public interface Externalizable extends java.io.Serializable {
    void writeExternal(ObjectOutput out) throws IOException;
    void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}
public class ExPerson implements Externalizable {
    private String name;
    private int age;
    //注意，必须加上pulic无参构造器
    public ExPerson() {}
    public ExPerson(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        //将name反转后写入二进制流
        StringBuffer reverse = new StringBuffer(name).reverse();
        System.out.println(reverse.toString());
        out.writeObject(reverse);
        out.writeInt(age);
    }
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
//将读取的字符串反转后赋值给name实例变量
        this.name = ((StringBuffer) in.readObject()).reverse().toString();
        System.out.println(name);
        this.age = in.readInt();
    }
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ExPerson.txt"));
             ObjectInputStream ois = new ObjectInputStream(new FileInputStream("ExPerson.txt"))) {
            oos.writeObject(new ExPerson("brady", 23));
            ExPerson ep = (ExPerson) ois.readObject();
            System.out.println(ep);
        }
    }
}

注意：Externalizable接口不同于Serializable接口，实现此接口必须实现接口中的两个方法实现自定义序列化，这是强制性的；特别之处是必须提供pulic的无参构造器，因为在反序列化的时候需要反射创建对象。
这里和Serializable不一样，Serializable接口是不需要提供无参构造器的，因为直接由虚拟机来创建对象的。不通过构造方法。
Externalizable是通过反射来创建对象的。

三、序列化版本号serialVersionUID

我们知道，反序列化必须拥有class文件，但随着项目的升级，class文件也会升级，序列化怎么保证升级前后的兼容性呢？
java序列化提供了一个private static final long serialVersionUID 的序列化版本号，只有版本号相同，即使更改了序列化属性，对象也可以正确被反序列化回来。
如果反序列化使用的class的版本号与序列化时使用的不一致，反序列化会报InvalidClassException异常。
序列化版本号可自由指定，如果不指定，JVM会根据类信息自己计算一个版本号，这样随着class的升级，就无法正确反序列化；不指定版本号另一个明显隐患是，不利于jvm间的移植，可能class文件没有更改，但不同jvm可能计算的规则不一样，这样也会导致无法反序列化。
什么情况下需要修改serialVersionUID呢？分三种情况。

如果只是修改了方法，反序列化不容影响，则无需修改版本号；
如果只是修改了静态变量，瞬态变量（transient修饰的变量），反序列化不受影响，无需修改版本号；
-如果修改了非瞬态变量，则可能导致反序列化失败。如果新类中实例变量的类型
-序列化时类的类型不一致，则会反序列化失败，这时候需要更改serialVersionUID
-如果只是新增了实例变量，则反序列化回来新增的是默认值；如果减少了实例变量，反序列化时会忽略掉减少的实例变量。

参考 https://juejin.im/post/5ce3cdc8e51d45777b1a3cdf
https://www.cnblogs.com/lanxuezaipiao/p/3369962.html