java中的序列化

一、什么是java序列化

　　序列化：将对象写入IO流

反序列化：从IO流中恢复对象

序列化机制允许将实现序列化的java对象转换为字节序列，这些字节序列可以保存在磁盘上也可以通过网络传输，字节序列也可以再恢复为原来的对象。序列化机制可以让对象不依附于程序独立存在。

二、应用场景

　　所有可在网络上传输的对象都必须是可序列化的，比如RMI（remote method invoke,即远程方法调用），传入的参数或返回的对象都是可序列化的，否则会出错；所有需要保存到磁盘的java对象都必须是可序列化的。通常建议：程序创建的每个JavaBean类都实现Serializeable接口。

三、序列化的实现

　　加入一个对象需要保存在磁盘或者需要进行网络传输，那么这个对象的类就需要支持序列化。序列化实现的方式有两种，实现Serializable接口或Externalizable(强制自定义序列化)接口。

1.Serializable(普通序列化)

序列化：

1package com.javaBase.TestSerializable;
2
3import java.io.FileOutputStream;
4import java.io.ObjectOutputStream;
5import java.io.Serializable;
6
7/**
8 * 〈一句话功能简述〉;
9 * 〈功能详细描述〉
10 *
11 * @author jx
12 * @see [相关类/方法]（可选）
13 * @since [产品/模块版本] （可选）
14 */
15public class Person implements Serializable {
16
17    private String name;
18    private char sex;
19
20    public Person(String name, char sex) {
21        this.name = name;
22        this.sex = sex;
23    }
24
25    @Override
26    public String toString() {
27        return "{name:" + name + ",sex:" + sex + "}";
28    }
29
30    public static void main(String[] args) throws Exception{
31        Person per = new Person("马云",'男');
32        //将per对象序列化保存到文件1.txt
33        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("1.txt"));
34        oos.writeObject(per);
35    }
36}

结果：

反序列化：

1package com.javaBase.TestSerializable;
2
3import java.io.FileInputStream;
4import java.io.FileOutputStream;
5import java.io.ObjectInputStream;
6import java.io.ObjectOutputStream;
7import java.io.Serializable;
8
9/**
10 * 〈一句话功能简述〉;
11 * 〈功能详细描述〉
12 *
13 * @author jx
14 * @see [相关类/方法]（可选）
15 * @since [产品/模块版本] （可选）
16 */
17public class Person implements Serializable {
18
19    private String name;
20    private char sex;
21
22    public Person(String name, char sex) {
23        this.name = name;
24        this.sex = sex;
25    }
26
27    @Override
28    public String toString() {
29        return "{name:" + name + ",sex:" + sex + "}";
30    }
31
32    public static void main(String[] args) throws Exception{
33        //反序列化per对象
34        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("1.txt"));
35        Person perRe = (Person)ois.readObject();
36        System.out.println(perRe);
37    }
38}

结果：

{name:马云,sex:男}

注意点：

如果一个可序列化的类的成员不是基本类型，也不是String类型，那这个引用类型也必须是可序列化的；否则，会导致此类不能序列化。强行序列化会抛出java.io.NotSerializableException异常
java序列化同一个对象，并不会序列化多次产生多个对象
使用transient修饰的属性，java序列化时，会忽略掉此字段，所以反序列化出的对象，被transient修饰的属性是默认值。对于引用类型，值是null；基本类型，值是0；boolean类型，值是false。

2.Externalizable：强制自定义序列化

　　Serializable接口是Externalizable接口的父接口，实现Externalizable接口必须实现下面两个方法：

1readExternal(ObjectInput in);
2          对象实现 readExternal 方法来恢复其内容，它通过调用 DataInput 的方法来恢复其基础类型，调用 readObject 来恢复对象、字符串和数组。
3writeExternal(ObjectOutput out);
4          该对象可实现 writeExternal 方法来保存其内容，它可以通过调用 DataOutput 的方法来保存其基本值，或调用 ObjectOutput 的 writeObject 方法来保存对象、字符串和数组。
5
6public class ExPerson implements Externalizable {
7
8    private String name;
9    private int age;
10    //注意，必须加上pulic 无参构造器
11    public ExPerson() {
12    }
13
14    public ExPerson(String name, int age) {
15        this.name = name;
16        this.age = age;
17    }
18
19    @Override
20    public void writeExternal(ObjectOutput out) throws IOException {
21        //将name反转后写入二进制流
22        StringBuffer reverse = new StringBuffer(name).reverse();
23        System.out.println(reverse.toString());
24        out.writeObject(reverse);
25        out.writeInt(age);
26    }
27
28    @Override
29    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
30        //将读取的字符串反转后赋值给name实例变量
31        this.name = ((StringBuffer) in.readObject()).reverse().toString();
32        System.out.println(name);
33        this.age = in.readInt();
34    }
35
36    public static void main(String[] args) throws IOException, ClassNotFoundException {
37        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ExPerson.txt"));
38             ObjectInputStream ois = new ObjectInputStream(new FileInputStream("ExPerson.txt"))) {
39            oos.writeObject(new ExPerson("brady", 23));
40            ExPerson ep = (ExPerson) ois.readObject();
41            System.out.println(ep);
42        }
43    }
44}

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

3.Externalizable与Serializable的区别

虽然Externalizable接口带来了一定的性能提升，但编程复杂度也提高了，所以一般通过实现Serializable接口进行序列化。

四、序列化版本号serialVersionUID

　　我们知道，反序列化必须拥有class文件，但随着项目的升级，class文件也会升级，序列化怎么保证升级前后的兼容性呢？java序列化提供了一个private static final long serialVersionUID 的序列化版本号，只有版本号相同，即使更改了序列化属性，对象也可以正确被反序列化回来。

　　如果反序列化使用的class的版本号与序列化时使用的不一致，反序列化会报InvalidClassException异常。序列化版本号可自由指定，如果不指定，JVM会根据类信息自己计算一个版本号，这样随着class的升级，就无法正确反序列化；不指定版本号另一个明显隐患是，不利于jvm间的移植，可能class文件没有更改，但不同jvm可能计算的规则不一样，这样也会导致无法反序列化。

什么情况下需要修改serialVersionUID呢？分三种情况。

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

五、序列化原理

所有保存到磁盘的对象都有一个序列化编码号
当程序试图序列化一个对象时，会先检查此对象是否已经序列化过，只有此对象从未（在此虚拟机）被序列化过，才会将此对象序列化为字节序列输出。
如果此对象已经序列化过，则直接输出编号即可。

六、总结

所有需要网络传输的对象都需要实现序列化接口，通过建议所有的javaBean都实现Serializable接口。
对象的类名、实例变量（包括基本类型，数组，对其他对象的引用）都会被序列化；方法、类变量、transient实例变量都不会被序列化。
如果想让某个变量不被序列化，使用transient修饰。
序列化对象的引用类型成员变量，也必须是可序列化的，否则，会报错。
反序列化时必须有序列化对象的class文件。
当通过文件、网络来读取序列化后的对象时，必须按照实际写入的顺序读取。
单例类序列化，需要重写readResolve()方法；否则会破坏单例原则。
同一对象序列化多次，只有第一次序列化为二进制流，以后都只是保存序列化编号，不会重复序列化。
建议所有可序列化的类加上serialVersionUID 版本号，方便项目升级。

参考链接：java序列化，看这篇就够了