Serializable序列化和Externalizable序列化与反序列化的使用

1、序列化是干啥用的？

序列化的原本意图是希望对一个Java对象作一下“变换”，变成字节序列，这样一来方便持久化存储到磁盘，避免程序运行结束后对象就从内存里消失，另外变换成字节序列也更便于网络运输和传播，所以概念上很好理解：

• 序列化：把Java对象转换为字节序列。
• 反序列化：把字节序列恢复为原先的Java对象。而且序列化机制从某种意义上来说也弥补了平台化的一些差异，毕竟转换后的字节流可以在其他平台上进行反序列化来恢复对象。

2、对象序列化的方式？

在Java中，如果一个对象要想实现序列化，必须要实现下面两个接口之一：

• Serializable 接口
• Externalizable 接口
• 那这两个接口是如何工作的呢？两者又有什么关系呢？我们分别进行介绍。

2.1 Serializable接口

一个对象想要被序列化，那么它的类就要实现此接口或者它的子接口。

这个对象的所有属性（包括private属性、包括其引用的对象）都可以被序列化和反序列化来保存、传递。不想序列化的字段可以使用transient修饰。

由于Serializable对象完全以它存储的二进制位为基础来构造，因此并不会调用任何构造函数，因此Serializable类无需默认构造函数，但是当Serializable类的父类没有实现Serializable接口时，反序列化过程会调用父类的默认构造函数，因此该父类必需有默认构造函数，否则会抛异常。

使用transient关键字阻止序列化虽然简单方便，但被它修饰的属性被完全隔离在序列化机制之外，导致了在反序列化时无法获取该属性的值，而通过在需要序列化的对象的Java类里加入writeObject()方法与readObject()方法可以控制如何序列化各属性，甚至完全不序列化某些属性或者加密序列化某些属性。

2.2 Externalizable 接口

它是Serializable接口的子类，用户要实现的writeExternal()和readExternal() 方法，用来决定如何序列化和反序列化。

因为序列化和反序列化方法需要自己实现，因此可以指定序列化哪些属性，而transient在这里无效。

对Externalizable对象反序列化时，会先调用类的无参构造方法，这是有别于默认反序列方式的。如果把类的不带参数的构造方法删除，或者把该构造方法的访问权限设置为private、默认或protected级别，会抛出java.io.InvalidException: no valid constructor异常，因此Externalizable对象必须有默认构造函数，而且必需是public的。

2.3 对比

使用时，你只想隐藏一个属性，比如用户对象user的密码pwd，如果使用Externalizable，并除了pwd之外的每个属性都写在writeExternal()方法里，这样显得麻烦，可以使用Serializable接口，并在要隐藏的属性pwd前面加上transient就可以实现了。如果要定义很多的特殊处理，就可以使用Externalizable。
当然这里我们有一些疑惑，Serializable 中的writeObject()方法与readObject()方法科可以实现自定义序列化，而Externalizable 中的writeExternal()和readExternal() 方法也可以，他们有什么异同呢？

• readExternal(),writeExternal()两个方法，这两个方法除了方法签名和readObject(),writeObject()两个方法的方法签名不同之外，其方法体完全一样。
• 需要指出的是，当使用Externalizable机制反序列化该对象时，程序会使用public的无参构造器创建实例，然后才执行readExternal()方法进行反序列化，因此实现Externalizable的序列化类必须提供public的无参构造。
• 虽然实现Externalizable接口能带来一定的性能提升，但由于实现ExternaLizable接口导致了编程复杂度的增加，所以大部分时候都是采用实现Serializable接口方式来实现序列化。

3、Serializable 如何序列化对象？

3.1 Serializable演示

然而Java目前并没有一个关键字可以直接去定义一个所谓的“可持久化”对象。对象的持久化和反持久化需要靠程序员在代码里手动显式地进行序列化和反序列化还原的动作。举个例子，假如我们要对Student类对象序列化到一个名为student.txt的文本文件中，然后再通过文本文件反序列化成Student类对象：

1、Student类定义

public class Student implements Serializable {
    private String name;
    private Integer age;
    private Integer score;
    @Override
    public String toString() {
        return "Student:" + '\n' +
        "name = " + this.name + '\n' +
        "age = " + this.age + '\n' +
        "score = " + this.score + '\n'
        ;
    }
    // ... 其他省略 ...
}

2、序列化

public static void serialize(  ) throws IOException {
    Student student = new Student();
    student.setName("CodeSheep");
    student.setAge( 18 );
    student.setScore( 1000 );
    ObjectOutputStream objectOutputStream = 
        new ObjectOutputStream( new FileOutputStream( new File("student.txt") ) );
    objectOutputStream.writeObject( student );
    objectOutputStream.close();
    System.out.println("序列化成功！已经生成student.txt文件");
    System.out.println("==============================================");
}

3、反序列化

public static void deserialize(  ) throws IOException, ClassNotFoundException {
    ObjectInputStream objectInputStream = 
        new ObjectInputStream( new FileInputStream( new File("student.txt") ) );
    Student student = (Student) objectInputStream.readObject();
    objectInputStream.close();
    System.out.println("反序列化结果为：");
    System.out.println( student );
}

4、运行结果
控制台打印：

序列化成功！已经生成student.txt文件
==============================================
反序列化结果为：
Student:
name = CodeSheep
age = 18
score = 1000

3.2 Serializable接口有何用？

上面在定义Student类时，实现了一个Serializable接口，然而当我们点进Serializable接口内部查看，发现它竟然是一个空接口，并没有包含任何方法！

试想，如果上面在定义Student类时忘了加implements Serializable时会发生什么呢？

实验结果是：此时的程序运行会报错，并抛出NotSerializableException异常：

我们按照错误提示，由源码一直跟到ObjectOutputStream的writeObject0()方法底层一看，才恍然大悟：

如果一个对象既不是字符串、数组、枚举，而且也没有实现Serializable接口的话，在序列化时就会抛出NotSerializableException异常
！原来Serializable接口也仅仅只是做一个标记用！！！它告诉代码只要是实现了Serializable接口的类都是可以被序列化的！然而真正的序列化动作不需要靠它完成。

3.3 serialVersionUID号有何用？

相信你一定经常看到有些类中定义了如下代码行，即定义了一个名为serialVersionUID的字段：

private static final long serialVersionUID = -4392658638228508589L;

你知道这句声明的含义吗？

为什么要搞一个名为serialVersionUID的序列号？

继续来做一个简单实验，还拿上面的Student类为例，我们并没有人为在里面显式地声明一个serialVersionUID字段。
我们首先还是调用上面的serialize()方法，将一个Student对象序列化到本地磁盘上的student.txt文件：接下来我们在Student类里面动点手脚，比如在里面再增加一个名为id的字段，表示学生学号：

public class Student implements Serializable {
    private String name;
    private Integer age;
    private Integer score;
    private Integer id;

这时候，我们拿刚才已经序列化到本地的student.txt文件，还用如下代码进行反序列化，试图还原出刚才那个Student对象：

运行发现报错了，并且抛出了InvalidClassException异常

这地方提示的信息非常明确了：序列化前后的serialVersionUID号码不兼容！

从这地方最起码可以得出两个重要信息：

1、serialVersionUID是序列化前后的唯一标识符

2、默认如果没有人为显式定义过serialVersionUID，那编译器会为它自动声明一个！

• 第1个问题： serialVersionUID序列化ID，可以看成是序列化和反序列化过程中的“暗号”，在反序列化时，JVM会把字节流中的序列号ID和被序列化类中的序列号ID做比对，只有两者一致，才能重新反序列化，否则就会报异常来终止反序列化的过程。
• 第2个问题： 如果在定义一个可序列化的类时，没有人为显式地给它定义一个serialVersionUID的话，则Java运行时环境会根据该类的各方面信息自动地为它生成一个默认的serialVersionUID，一旦像上面一样更改了类的结构或者信息，则类的serialVersionUID也会跟着变化！

所以，为了serialVersionUID的确定性，写代码时还是建议，凡是implements Serializable的类，都最好人为显式地为它声明一个serialVersionUID明确值！

当然，如果不想手动赋值，你也可以借助IDE的自动添加功能，比如我使用的IntelliJ IDEA，按alt + enter就可以为类自动生成和添加serialVersionUID字段，十分方便：

两种特殊情况

1、凡是被static修饰的字段是不会被序列化的

2、凡是被transient修饰符修饰的字段也是不会被序列化的

对于第一点，因为序列化保存的是对象的状态而非类的状态，所以会忽略static静态域也是理所应当的。

对于第二点，就需要了解一下transient修饰符的作用了。

如果在序列化某个类的对象时，就是不希望某个字段被序列化（比如这个字段存放的是隐私值，如：密码等），那这时就可以用transient修饰符来修饰该字段。

比如在之前定义的Student类中，加入一个密码字段，但是不希望序列化到txt文本，则可以：

public class Student implements Serializable {
    private static final long serialVersionUID = -4392658638228508589L;
    private transient String name;
    private Integer age;
    private Integer score;
    private transient String passwd;

这样在序列化Student类对象时，password字段会设置为默认值null，这一点可以从反序列化所得到的结果来看出：

public static void serialize() throws IOException {
    Student student = new Student();
    student.setName("CodeSheep");
    student.setAge(18);
    student.setScore(1000);
    student.setPasswd("123");

4、实现Externalizable

public UserInfo() {
    userAge=20;//这个是在第二次测试使用，判断反序列化是否通过构造器
}
public void writeExternal(ObjectOutput out) throws IOException  {
    //  指定序列化时候写入的属性。这里仍然不写入年龄
    out.writeObject(userName);
    out.writeObject(usePass);
}
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException  {
    // 指定反序列化的时候读取属性的顺序以及读取的属性
    // 如果你写反了属性读取的顺序，你可以发现反序列化的读取的对象的指定的属性值也会与你写的读取方式一一对应。因为在文件中装载对象是有序的
    userName=(String) in.readObject();
    usePass=(String) in.readObject();
}

我们在序列化对象的时候，由于这个类实现了Externalizable 接口，在writeExternal()方法里定义了哪些属性可以序列化，哪些不可以序列化，所以，对象在经过这里就把规定能被序列化的序列化保存文件，不能序列化的不处理，然后在反序列的时候自动调用readExternal()方法，根据序列顺序挨个读取进行反序列，并自动封装成对象返回，然后在测试类接收，就完成了反序列。

Externalizable 实例类的唯一特性是可以被写入序列化流中，该类负责保存和恢复实例内容。 若某个要完全控制某一对象及其超类型的流格式和内容，则它要实现 Externalizable 接口的 writeExternal 和 readExternal 方法。这些方法必须显式与超类型进行协调以保存其状态。这些方法将代替定制的 writeObject 和 readObject 方法实现。

• writeExternal(ObjectOutput out)
  该对象可实现 writeExternal 方法来保存其内容，它可以通过调用 DataOutput 的方法来保存其基本值，或调用 ObjectOutput 的 writeObject 方法来保存对象、字符串和数组。
• readExternal(ObjectInput in)
  对象实现 readExternal 方法来恢复其内容，它通过调用 DataInput 的方法来恢复其基础类型，调用 readObject 来恢复对象、字符串和数组。

externalizable和Serializable的区别：

1、实现serializable接口是默认序列化所有属性，如果有不需要序列化的属性使用transient修饰。externalizable接口是serializable的子类，实现这个接口需要重写writeExternal和readExternal方法，指定对象序列化的属性和从序列化文件中读取对象属性的行为。

2、实现serializable接口的对象序列化文件进行反序列化不走构造方法，载入的是该类对象的一个持久化状态，再将这个状态赋值给该类的另一个变量。实现externalizable接口的对象序列化文件进行反序列化先走构造方法得到控对象，然后调用readExternal方法读取序列化文件中的内容给对应的属性赋值。

5、序列化的受控和加强

5.1 约束性加持

从上面的过程可以看出，序列化和反序列化的过程其实是有漏洞的，因为从序列化到反序列化是有中间过程的，如果被别人拿到了中间字节流，然后加以伪造或者篡改，那反序列化出来的对象就会有一定风险了。
毕竟反序列化也相当于一种 “隐式的”对象构造 ，因此我们希望在反序列化时，进行受控的对象反序列化动作。

那怎么个受控法呢？答案就是： 自行编写readObject()函数，用于对象的反序列化构造，从而提供约束性。

既然自行编写readObject()函数，那就可以做很多可控的事情：比如各种判断工作。

还以上面的Student类为例，一般来说学生的成绩应该在0 ~ 100之间，我们为了防止学生的考试成绩在反序列化时被别人篡改成一个奇葩值，我们可以自行编写readObject()函数用于反序列化的控制：

private void readObject( ObjectInputStream objectInputStream ) throws IOException, ClassNotFoundException {
    // 调用默认的反序列化函数
    objectInputStream.defaultReadObject();
    // 手工检查反序列化后学生成绩的有效性，若发现有问题，即终止操作！
    if( 0 > score || 100 < score ) {
        throw new IllegalArgumentException("学生分数只能在0到100之间！");
    }
}

比如我故意将学生的分数改为101，此时反序列化立马终止并且报错：

对于上面的代码，为什么自定义的private的readObject()方法可以被自动调用，跟一下底层源码来一探究竟，跟到了ObjectStreamClass类的最底层，是反射机制在起作用！是的，在Java里，果然万物皆可“反射”（滑稽），即使是类中定义的private私有方法，也能被抠出来执行了，简直引起舒适了。

5.2 单例模式增强一个容易被忽略的问题是：可序列化的单例类有可能并不单例！举个代码小例子就清楚了。比如这里我们先用java写一个常见的「静态内部类」方式的单例模式实现：public class Singleton implements Serializable {

private static final long serialVersionUID = -1576643344804979563L;
    private Singleton() {
    }
    private static class SingletonHolder {
        private static final Singleton singleton = new Singleton();
    }
    public static synchronized Singleton getSingleton() {
        return SingletonHolder.singleton;
    }
}

然后写一个验证主函数：

public class Test2 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectOutputStream objectOutputStream =
                new ObjectOutputStream(
                    new FileOutputStream( new File("singleton.txt") )
                );
        // 将单例对象先序列化到文本文件singleton.txt中
        objectOutputStream.writeObject( Singleton.getSingleton() );
        objectOutputStream.close();
        ObjectInputStream objectInputStream =
                new ObjectInputStream(
                    new FileInputStream( new File("singleton.txt") )
                );
        // 将文本文件singleton.txt中的对象反序列化为singleton1
        Singleton singleton1 = (Singleton) objectInputStream.readObject();
        objectInputStream.close();
        Singleton singleton2 = Singleton.getSingleton();
        // 运行结果竟打印 false ！
        System.out.println( singleton1 == singleton2 );
    }
}

运行后我们发现：反序列化后的单例对象和原单例对象并不相等了，这无疑没有达到我们的目标。解决办法是：在单例类中手写readResolve()函数，直接返回单例对象：

private Object readResolve() {
    return SingletonHolder.singleton;
}
package serialize.test;
import java.io.Serializable;
public class Singleton implements Serializable {
    private static final long serialVersionUID = -1576643344804979563L;
    private Singleton() {
    }
    private static class SingletonHolder {
        private static final Singleton singleton = new Singleton();
    }
    public static synchronized Singleton getSingleton() {
        return SingletonHolder.singleton;
    }
    private Object readResolve() {
        return SingletonHolder.singleton;
    }
}

这样一来，当反序列化从流中读取对象时，readResolve()会被调用，用其中返回的对象替代反序列化新建的对象。

利用Serializable和Externalizable序列化与反序列化的使用

1、Serializable序列化时不会调用默认的构造器，而Externalizable序列化时会调用默认构造器的，Serializable不需要自己实现序列化方法可以使用默认的序列化方法，而Externalizable需要自己实现序列化！！！
2、Serializable：一个对象想要被序列化，那么它的类就要实现 此接口，这个对象的所有属性（包括private属性、包括其引用的对象）都可以被序列化和反序列化来保存、传递。
3.如是要一个类是可序列化的，那么它的子类也是可序列化的。
Externalizable：他是Serializable接口的子类，有时我们不希望序列化那么多，可以使用这个接口，这个接口的writeExternal()和readExternal()方法可以指定序列化哪些属性。序列化就是将对象存进文件，反序列化就是将对象从文件中读取出来。
java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。
注意：
对象的序列化并不属于新的Reader和Writer层次结构的一部分，而是沿用老式的InputStream和OutputStream结构，在某些情况下，不得不混合使用两种类型的层次结构。

恢复了一个反序列化的对象后，如果想对其做更多的事情（对象.getClass().xxx），必须保证JVM能在本地类路径或者因特网的其他什么地方找到相关的.class文件。
恢复对象的默认构建器必须是public的，否则会抛异常。
由于Externalizable对象默认时不保存对象的任何字段，所以transient关键字只能伴随Serializable使用，虽然Externalizable对象中使用transient关键字也不报错，但不起任何作用

方法writeObject处理对象的序列化。如果声明该方法，它将会被ObjectOutputStream调用而不是默认的序列化进程。如果你是第一次看见它，你会很惊奇尽管它们被外部类调用但事实上这是两个private的方法。并且它们既不存在于java.lang.Object，也没有在Serializable中声明。那么ObjectOutputStream如何使用它们的呢？这个吗，ObjectOutputStream使用了反射来寻找是否声明了这两个方法。因为ObjectOutputStream使用getPrivateMethod(通过getDeclareMethod可以获得私有方法），所以这些方法不得不被声明为private以至于供ObjectOutputStream来使用。
调用了defaultWriteObject()和defaultReadObject()。它们做的是默认的序列化进程，就像写/读所有的non-transient和 non-static字段(但他们不会去做serialVersionUID的检查).通常说来，所有我们想要自己处理的字段都应该声明为transient。这样的话，defaultWriteObject/defaultReadObject便可以专注于其余字段，而我们则可为这些特定的字段
serialVersionUID的作用：
序列化时为了保持版本的兼容性，即在版本升级时反序列化仍保持对象的唯一性。
在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常，即是InvalidCastException。
具体的序列化过程是这样的：序列化操作的时候系统会把当前类的serialVersionUID写入到序列化文件中，当反序列化时系统会去检测文件中的serialVersionUID，判断它是否与当前类的serialVersionUID一致，如果一致就说明序列化类的版本与当前类版本是一样的，可以反序列化成功，否则失败。
有两种生成方式：
一个是默认的1L，比如：private static final long serialVersionUID = 1L;
一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如：
private static final long serialVersionUID = xxxxL; 例如当你的类Serialized存到硬盘上面后，可是后来你却更改了类别的field(增加或减少或改名)，当你Deserialize时，就会出现Exception的，这样就会造成不兼容性的问题。但当serialVersionUID相同时，它就会将不一样的field以type的预设值Deserialize，可避开不兼容性问题。
案例一：

public class SkillMode implements Externalizable {
     private static final long serialVersionUID = 1L;
     private Logger logger = LoggerFactory.getLogger(SkillMode.class);
     private Map<Integer,DmDialogDefinition> allSkill;
     private String version;
     private String versionMessage;
​     @Override
​     public void writeExternal(ObjectOutput out) throws IOException {
​       out.writeObject(version);
​       out.writeObject(versionMessage);
​       out.writeObject(allSkill); //其他对象都是按照这样的格式读进去
​     }
​     @Override
​     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
​       version = (String) in.readObject();
​       versionMessage = (String) in.readObject();
​       allSkill = (Map<Integer, DmDialogDefinition>) in.readObject();//其他对象都是按照这样的格式读出来
​     }
​     public Map<Integer, DmDialogDefinition> getAllSkill() {
​       return allSkill;
​     }
​     public void setAllSkill(Map<Integer, DmDialogDefinition> allSkill) {
​       this.allSkill = allSkill;
​     }
​     public String getVersion() {
​       return version;
​     }
​     public void setVersion(String version) {
​       this.version = version;
​     }
​     public String getVersionMessage() {
​       return versionMessage;
​     }
​     public void setVersionMessage(String versionMessage) {
​       this.versionMessage = versionMessage;
​     }
​     public void load(File file) throws IOException {
     // 从文件中读出至类中
​       logger.debug("File.load path:{}",file.getAbsolutePath());
​       ObjectInputStream ios = null;
​       InputStream in = null;
​       try {
​         in = new FileInputStream(file);
​         ios = new ObjectInputStream(new BufferedInputStream(in));
​         in = null;
​         this.readExternal(ios);
​       } catch (ClassNotFoundException e) {
​         e.printStackTrace();
​         throw new IOException(e);
​       } finally {
​         saveClose(ios);
​         saveClose(in);
​       }
​     }
​     public void save(File file) throws IOException {
​       ObjectOutputStream oos = null;
​       OutputStream out = null;
​       try {
​         out = new FileOutputStream(file);
​         oos = new ObjectOutputStream(new BufferedOutputStream(out));
​         out = null;
​         this.writeExternal(oos); // 保存对象到文件
​       }  finally {
​         saveClose(oos);
​         saveClose(out);
​       }
​     }
​     private void saveClose(AutoCloseable c){
​       if (c != null){
​         try {
​           c.close();
​         } catch (Exception e) {
​           e.printStackTrace();
​         }
​       }
​     }
​     }
​     用法：
​     1.从文件中读取出来：
​     SkillModel  skillModel = new SkillModel();
​     File file=new File("path") //path为存取的文件路径
​     if(file.exists()){
​      skillModel.load(File);//将从文件中读取出来的值传给定义的skillModel实体
​     }
​     
​     skillModel.save(file);//将skillModel实体存到文件中

案例二：

public class Person implements Serializable {
​     private static final long serialVersionUID = 123456789L;
​     public int id;
​     public String name;
​     public transient String age; //不会被序列化
​     public Person(int id, String name) {
​       this.id = id;
​       this.name = name;
​     }
​     public String toString() {
​       return "Person: " + id + " " + name;
​     }
   }
   序列化功能：
   public class SerialTest {
​     public static void main(String[] args) throws IOException {
​       Person person = new Person(1234, "wang");
​       System.out.println("Person Serial" + person);
​       FileOutputStream fos = new FileOutputStream("Person.txt");
​       ObjectOutputStream oos = new ObjectOutputStream(fos);
​       oos.writeObject(person);
​       oos.flush();
​       oos.close();
​     }
   }
   反序列化功能：
   public class DeserialTest {
  public static void main(String[] args) throws IOException, ClassNotFoundException {
​    Person person;
​    //在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，String的值是"" ，对象型的是 null
​    FileInputStream fis = new FileInputStream("Person.txt");
​    ObjectInputStream ois = new ObjectInputStream(fis);
​    person = (Person) ois.readObject();
​    ois.close();
​    System.out.println("Person Deserial" + person);
  }
}

一个序列化的类要想将父类对象也序列化，就需要让父类也实现Serializable 接口。如果父类不实现的话的，就需要有默认的无参的构造函数。在父类没有实现 Serializable接口时，虚拟机是不会序列化父对象的，而一个 Java 对象的构造必须先有父对象，才有子对象，反序列化也不例外。所以反序列化时，为了构造父对象，只能调用父类的无参构造函数作为默认的父对象。因此当我们取父对象的变量值时，它的值是调用父类无参构造函数后的值。
如果你考虑到这种序列化的情况，在父类无参构造函数中对变量进行初始化，否则的话，父类变量值都是默认声明的值，如 int 型的默认是 0，string 型的默认是 null。

根据父类对象序列化的规则，我们可以将不需要被序列化的字段抽取出来放到父类中，子类实现 Serializable 接口，父类不实现，根据父类序列化规则去父类无参构造方法中初始化。

用Externalizable进行序列化，当读取对象时，会调用被序列化类的无参构造器创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。实现Externalizable接口的类必须要提供一个无参的构造器，且访问权限为 public。

dubbo利用RPC调用时需要将对象序列化之后才能调用。