Java序列化与反序列化

目录

一、Java序列化简介

二、什么情况下需要序列化

三、JDK类库中的序列化API

四、简单案例

五、serialVersionUID的作用

六、serialVersionUID的取值

七、static变量序列化

八、transient关键字

九、writeObject()方法与readObject()方法

十、序列化存储规则

十一、父类没有序列化

十二、Externalizable接口

十三、readResolve()方法

一、Java序列化简介

从JDK1.1就存在序列化，序列化是将Java对象转换为字节数组的过程。

反序列化是字节数组转换为Java对象的过程。

二、什么情况下需要序列化

1，需要将java对象存储到磁盘上或数据库中

2，当你想用套接字在网络上传送对象的时候

3，当你想通过RMI传输对象的时候

三、JDK类库中的序列化API

java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)可将参数obj对象进行序列化，

把得到的字节数组写到一个输出流中。

java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节数组，

再把它们反序列化为一个对象，并将其返回。

只有实现了Serializable或其子接口Externalizable的类的对象才能被序列化。

注意的是：实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以采用默认的序列化方式。

　　对象序列化包括如下步骤：

　　1）创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流。

　　2）通过对象输出流的writeObject()方法写对象。

　　对象反序列化的步骤如下：

　　1）创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流。

　　2）通过对象输入流的readObject()方法读取对象。

四、简单案例

清单1 显示一个实现Serializable的Cat类。

package cn.rumor.serial;

import java.io.Serializable;

public class Cat implements Serializable {

private String name;

private String gender;

public Cat(String name, String gender) {

this.name = name;

this.gender = gender;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getGender() {

return gender;

}

public void setGender(String gender) {

this.gender = gender;

}

@Override

public String toString() {

return "Cat [name=" + name + ", gender=" + gender + "]";

}

}

清单2 使用Junit进行测试

package cn.rumor.serial;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import org.junit.Test;

public class CatSerTest {

//序列化

@Test

public void testSerial() {

try {

Cat cat = new Cat("rat", "m");

//创建输出流对象

FileOutputStream fos = new FileOutputStream("E:/cat.ser");

ObjectOutputStream oos = new ObjectOutputStream(fos);

oos.writeObject(cat);

oos.close();

} catch (Exception e) {

e.printStackTrace();

}

}

//反序列化

@Test

public void testDeSerial() {

try {

//创建输入流对象

FileInputStream fis = new FileInputStream("E:/cat.ser");

ObjectInputStream ois = new ObjectInputStream(fis);

Cat cat2 = (Cat)ois.readObject();

ois.close();

System.out.println(cat2);

} catch (Exception e) {

e.printStackTrace();

}

}

}

依次执行之后，在E盘生成一个cat.ser文件

控制台打印输入：Cat [name=rat, gender=m]

五、serialVersionUID的作用

​字面意思为“序​列​化​的​版​本​号”，只要实现了Serializable接口都要有一个表示序列化版本号的静态变量。

private static final long serialVersionUID;

serialVersionUID有两种生成策略：

采用+Add default serial version ID这种方式生成的serialVersionUID是1L，例如:

private static final long serialVersionUID = 1L;

采用+Add generated serial version ID这种方式生成的serialVersionUID是根据类名、接口名、方法和属性等来生成的，

例如：

private static final long serialVersionUID = 4820613318225866253L;

如（四）所示，在Cat类里面并没有serialVersionUID，输出正常。

下面我们修改一下Cat类。如下：

清单3 添加color属性

public class Cat implements Serializable {

//无serialVersionUID

//...

private String color;

//...

}

执行反序列化，控制台报异常：

java.io.InvalidClassException: cn.rumor.serial.Cat;

local class incompatible:

stream classdesc serialVersionUID = 7495499194431377682,

local class serialVersionUID = -7456005194464997324

意思就是说，文件流中的class与classpath中的class不兼容了。

如果没有对Java类指定一个版本号，那么java编译器会自动给这个class进行一个摘要算法，生成一个默认的版本号。

在反序列化的时候，会拿这个版本号与本地的版本号进行比对，如果一致那就没问题，否则报出以上异常。

因此，只要我们指定了一个serialVersionUID，无论是添加或删除一个元素，都不会影响以后的反序列化操作。

下面我们修改一下Cat类，生成serialVersionUID。如下：

清单4 生成serialVersionUID

public class Cat implements Serializable {

//添加serialVersionUID

private static final long serialVersionUID = -7456005194464997324L;

//...

}

重新Junit序列化后，添加或删除某个元素，执行反序列化，No problem！

六、serialVersionUID的取值

serialVersionUID的取值是Java运行时环境根据类的内容细节自动生成的。如果对类作了修改，再重新编译，

新生成的类文件的serialVersionUID有可能也会有变化。

类的serialVersionUID的默认值完全依赖于Java编译器的实现，对于同一个类，用不同的编译器编译，

有可能会导致不同的serialVersionUID，也有可能相同。

为了提高serialVersionUID的独立性和确定性，强烈建议在一个可序列化类中显示的定义serialVersionUID，为它赋予明确的值。

显式地定义serialVersionUID有两种用途：

1、在某些场合，希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有相同的serialVersionUID；

2、在某些场合，不希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有不同的serialVersionUID。

七、static变量序列化

清单5 声明static变量

public class Cat implements Serializable {

//...

//声明static变量

public static int legs = 4;

//...

}

清单6 Junit测试

public class CatSerTest {

//序列化

@Test

public void testSerial() {

try {

Cat cat = new Cat("rat", "m");

//创建输出流对象

FileOutputStream fos = new FileOutputStream("E:/cat.ser");

ObjectOutputStream oos = new ObjectOutputStream(fos);

oos.writeObject(cat);

oos.close();

//修改static变量

cat.legs = 5;

//创建输入流对象

FileInputStream fis = new FileInputStream("E:/cat.ser");

ObjectInputStream ois = new ObjectInputStream(fis);

Cat cat2 = (Cat)ois.readObject();

ois.close();

System.out.println(cat2.legs);

} catch (Exception e) {

e.printStackTrace();

}

}

}

清单6中的testSerial方法，将对象序列化后，修改静态变量的数值，再将序列化对象读取出来，

然后通过读取出来的对象获得静态变量的数值并打印出来。

依照清单6，这个System.out.println(cat2.legs)语句输出的是4还是5呢？

最后的输出是5，对于无法理解的读者认为，打印的legs是从读取的对象里获得的，应该是保存时的状态才对。之所以打印5的原因在于序列化时，并不保存静态变量，这其实比较容易理解，序列化保存的是对象的状态，静态变量属于类的状态，因此序列化并不保存静态变量。

八、transient关键字

当某个字段被声明为transient后，默认序列化机制就会忽略该字段。

清单7

public class Cat implements Serializable {

//...

private transient String hello;

//...

@Override

public String toString() {

return "Cat [name=" + name + ", gender=" + gender + ", hello = " + hello + "]";

}

}

控制台打印输入：Cat [name=rat, gender=m, hello=null]

可见，hello字段未被序列化。

九、 writeObject()方法与readObject()方法

1)对敏感数据加密

情境：服务器端给客户端发送序列化对象数据，对象中有一些数据是敏感的，比如密码字符串等，希望对该密码字段在序列化时，进行加密，而客户端如果拥有解密的密钥，只有在客户端进行反序列化时，才可以对密码进行读取，这样可以一定程度保证序列化对象的数据安全。

解决：在序列化过程中，虚拟机会试图调用对象类里的 writeObject 和 readObject 方法，进行用户自定义的序列化和反序列化，如果没有这样的方法，则默认调用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程，比如可以在序列化的过程中动态改变序列化的数值。基于这个原理，可以在实际应用中得到使用，用于敏感字段的加密工作，清单8展示了这个过程。

清单8 字段加密

package cn.rumor.serial;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectInputStream.GetField;

import java.io.ObjectOutputStream;

import java.io.ObjectOutputStream.PutField;

import java.io.Serializable;

public class User implements Serializable {

private static final long serialVersionUID = 1L;

private transient String username;

private String password = "pass";

//set/get method.

private void writeObject(ObjectOutputStream out) {

try {

PutField putField = out.putFields();

System.out.println("原密码：" + password);

password = "encryption"; //模拟加密

putField.put("password", password);

System.out.println("加密后的密码：" + password);

out.writeFields();

} catch (IOException e) {

e.printStackTrace();

}

}

private void readObject(ObjectInputStream in) {

try {

GetField getField = in.readFields();

Object object = getField.get("password", "");

System.out.println("要解密的字符串：" + object.toString());

password = "pass"; //模拟解密，需要本地的密钥

} catch (IOException e) {

e.printStackTrace();

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

}

public static void main(String[] args) throws Exception {

FileOutputStream fos = new FileOutputStream("E:/user.ser");

ObjectOutputStream oos = new ObjectOutputStream(fos);

oos.writeObject(new User());

oos.close();

FileInputStream fis = new FileInputStream("E:/user.ser");

ObjectInputStream ois = new ObjectInputStream(fis);

User user = (User)ois.readObject();

ois.close();

System.out.println("解密后的字符串："+user.getPassword());

}

}

执行main方法，控制台输出：

原密码：pass

加密后的密码：encryption

要解密的字符串：encryption

解密后的字符串：pass

特性使用案例

RMI 技术是完全基于 Java 序列化技术的，服务器端接口调用所需要的参数对象来至于客户端，它们通过网络相互传输。这就涉及 RMI 的安全传输的问题。一些敏感的字段，如用户名密码（用户登录时需要对密码进行传输），我们希望对其进行加密，这时，就可以采用本节介绍的方法在客户端对密码进行加密，服务器端进行解密，确保数据传输的安全性。

1)序列化transitive字段

package cn.rumor.serial;

import java.io.*;

public class User implements Serializable {

private static final long serialVersionUID = 1L;

private transient String username;

private String password;

public User(String username, String password) {

this.username = username;

this.password = password;

}

//set/get method.

private void writeObject(ObjectOutputStream out) throws IOException {

out.defaultWriteObject();

out.writeUTF(username);

}

private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {

in.defaultReadObject();

username = in.readUTF();

}

@Override

public String toString() {

return "User [username=" + username + ", password=" + password + "]";

}

public static void main(String[] args) throws Exception {

FileOutputStream fos = new FileOutputStream("E:/user.ser");

ObjectOutputStream oos = new ObjectOutputStream(fos);

oos.writeObject(new User("u1", "p1"));

oos.close();

FileInputStream fis = new FileInputStream("E:/user.ser");

ObjectInputStream ois = new ObjectInputStream(fis);

User user = (User)ois.readObject();

ois.close();

System.out.println(user);

}

}

在writeObject()方法中会先调用ObjectOutputStream中的defaultWriteObject()方法，该方法会执行默认的序列化机制，此时会忽略掉username字段。然后再调用writeUTF()方法显示地将username字段写入到ObjectOutputStream中。readObject()的作用则是针对对象的读取，其原理与writeObject()方法相同。

执行main方法，控制台输出：

User [username=u1, password=p1]

必须注意地是，writeObject()与readObject()都是private方法，那么它们是如何被调用的呢？毫无疑问，是使用反射。详情可见ObjectOutputStream中的writeSerialData方法，以及ObjectInputStream中的readSerialData方法。

十、序列化存储规则

清单9 存储规则问题代码

package cn.rumor.serial;

import java.io.*;

public class User implements Serializable {

private static final long serialVersionUID = 1L;

private transient String username;

private String password;

//set/get method.

public static void main(String[] args) throws Exception {

FileOutputStream fos = new FileOutputStream("E:/user.ser");

ObjectOutputStream oos = new ObjectOutputStream(fos);

User user = new User();

//试图两次写入

oos.writeObject(user); //第一次写

oos.flush();

System.out.println(new File("E:/user.ser").length());

oos.writeObject(user); //第二次写

System.out.println(new File("E:/user.ser").length());

oos.close();

FileInputStream fis = new FileInputStream("E:/user.ser");

ObjectInputStream ois = new ObjectInputStream(fis);

//从文件依次读出两个文件

User user1 = (User)ois.readObject();

User user2 = (User)ois.readObject();

ois.close();

//判断两个引用是否指向同一个对象

System.out.println(user1 == user2);

}

}

清单9中对同一对象两次写入文件，打印出写入一次对象后的存储大小和写入两次后的存储大小，然后从文件中反序列化出两个对象，比较这两个对象是否为同一对象。一般的思维是，两次写入对象，文件大小会变为两倍的大小，反序列化时，由于从文件读取，生成了两个对象，判断相等时应该是输入 false 才对，但是最后结果输出：

#console

80

85

true

我们看到，第二次写入对象时文件只增加了 5 字节，并且两个对象是相等的，这是为什么呢？

解答：Java 序列化机制为了节省磁盘空间，具有特定的存储规则，当写入文件的为同一对象时，并不会再将对象的内容进行存储，而只是再次存储一份引用，上面增加的 5 字节的存储空间就是新增引用和一些控制信息的空间。反序列化时，恢复引用关系，使得清单 3 中的 t1 和 t2 指向唯一的对象，二者相等，输出 true。该存储规则极大的节省了存储空间。

特性案例分析

清单10

package cn.rumor.serial;

import java.io.*;

public class User implements Serializable {

private static final long serialVersionUID = 1L;

public int i;

public static void main(String[] args) throws Exception {

FileOutputStream fos = new FileOutputStream("E:/user.ser");

ObjectOutputStream oos = new ObjectOutputStream(fos);

User user = new User();

user.i = 1; //为变量赋值

oos.writeObject(user); //第一次写

oos.flush();

user.i = 2; //修改变量值

oos.writeObject(user); //第二次写

oos.close();

FileInputStream fis = new FileInputStream("E:/user.ser");

ObjectInputStream ois = new ObjectInputStream(fis);

//从文件依次读出两个文件

User user1 = (User)ois.readObject();

User user2 = (User)ois.readObject();

ois.close();

//打印

System.out.println(user1.i); //1

System.out.println(user2.i); //1

}

}

清单10的目的是希望将 user 对象两次保存到 user.ser 文件中，写入一次以后修改对象属性值再次保存第二次，然后从 user.ser 中再依次读出两个对象，输出这两个对象的 i 属性值。案例代码的目的原本是希望一次性传输对象修改前后的状态。

结果两个输出的都是 1， 原因就是第一次写入对象以后，第二次再试图写的时候，虚拟机根据引用关系知道已经有一个相同对象已经写入文件，因此只保存第二次写的引用，所以读取时，都是第一次保存的对象。读者在使用一个文件多次 writeObject 需要特别注意这个问题。

十一、父类没有序列化

如果子类实现Serializable接口，而父类没有实现。那么序列化子类时，父类不会被序列化。

反序列化后访问父类中的变量时，则为默认值，int为0，对象为null。

如果希望改变父类中的变量值，刚通过父类中的无参构造函数为变量初赋值。

十二、Externalizable接口

无论是使用transient关键字，还是使用writeObject()和readObject()方法，都是基于Serializable接口的序列化。

JDK中提供了另一个序列化接口--Externalizable，使用该接口之后，之前基于Serializable接口的序列化机制就将失效。

此时将User类修改成如下

清单11 实现Externalizable接口

package cn.rumor.serial;

import java.io.*;

public class User implements Externalizable {

private static final long serialVersionUID = 1L;

private transient String username;

private String password;

public User() {

System.out.println("no-arg constructor");

}

public User(String username, String password) {

System.out.println("constructor");

this.username = username;

this.password = password;

}

//set/get

private void writeObject(ObjectOutputStream out) throws IOException {

out.defaultWriteObject();

out.writeObject(username);

}

private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {

in.defaultReadObject();

username = (String)in.readObject();

}

public void writeExternal(ObjectOutput out) throws IOException {

}

public void readExternal(ObjectInput in) throws IOException,

ClassNotFoundException {

}

@Override

public String toString() {

return "User [username=" + username + ", password=" + password + "]";

}

public static void main(String[] args) throws Exception {

FileOutputStream fos = new FileOutputStream("E:/user.ser");

ObjectOutputStream oos = new ObjectOutputStream(fos);

oos.writeObject(new User("u1", "p1"));

oos.close();

FileInputStream fis = new FileInputStream("E:/user.ser");

ObjectInputStream ois = new ObjectInputStream(fis);

User user = (User)ois.readObject();

ois.close();

System.out.println(user);

}

}

控制台输出：

constructor

no-arg constructor

User [username=null, password=null]

从该结果，一方面可以看出User对象中任何一个字段都没有被序列化。另一方面，如果细心的话，还可以发现这此次序列化过程调用了Person类的无参构造器。

Externalizable继承于Serializable，当使用该接口时，序列化的细节需要由程序员去完成。如上所示的代码，由于writeExternal()与readExternal()方法未作任何处理，那么该序列化行为将不会保存/读取任何一个字段。这也就是为什么输出结果中所有字段的值均为空。

另外，若使用Externalizable进行序列化，当读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。这就是为什么在此次序列化过程中Person类的无参构造器会被调用。由于这个原因，实现Externalizable接口的类必须要提供一个无参的构造器，且它的访问权限为public。

对上述User类作进一步的修改，使其能够对username与password字段进行序列化，但要忽略掉gender字段，

如下代码所示：

清单12 修改User类

package cn.rumor.serial;

import java.io.*;

public class User implements Externalizable {

private static final long serialVersionUID = 1L;

private transient String username;

private String password;

public User() {

System.out.println("no-arg constructor");

}

public User(String username, String password) {

System.out.println("constructor");

this.username = username;

this.password = password;

}

//set/get

private void writeObject(ObjectOutputStream out) throws IOException {

out.defaultWriteObject();

out.writeObject(username);

}

private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {

in.defaultReadObject();

username = (String)in.readObject();

}

public void writeExternal(ObjectOutput out) throws IOException {

}

public void readExternal(ObjectInput in) throws IOException,

ClassNotFoundException {

}

@Override

public String toString() {

return "User [username=" + username + ", password=" + password + "]";

}

public static void main(String[] args) throws Exception {

FileOutputStream fos = new FileOutputStream("E:/user.ser");

ObjectOutputStream oos = new ObjectOutputStream(fos);

oos.writeObject(new User("u1", "p1"));

oos.close();

FileInputStream fis = new FileInputStream("E:/user.ser");

ObjectInputStream ois = new ObjectInputStream(fis);

User user = (User)ois.readObject();

ois.close();

System.out.println(user);

}

}

控制台输出：

constructor

no-arg constructor

User [username=p1, password=u1]

十三、readResolve()方法

当我们使用Singlton模式时，期望某个类的实例为唯一的，当这个类可以序列化时，情况略有不同。

清单13 新建Person.java

package cn.rumor.serial;

import java.io.*;

public class Person implements Serializable {

private static class InstanceHolder {

private static final Person instance = new Person("victor", 18);

}

public static Person getInstance() {

return InstanceHolder.instance;

}

private static final long serialVersionUID = 1L;

private String name;

private Integer age;

public Person() {

System.out.println("no-arg constructor");

}

public Person(String name, Integer age) {

System.out.println("constructor");

this.name = name;

this.age = age;

}

@Override

public String toString() {

return "User [name=" + name + ", age=" + age + "]";

}

public static void main(String[] args) throws Exception {

FileOutputStream fos = new FileOutputStream("E:/person.ser");

ObjectOutputStream oos = new ObjectOutputStream(fos);

//保存单例对象

oos.writeObject(Person.getInstance());

oos.close();

FileInputStream fis = new FileInputStream("E:/person.ser");

ObjectInputStream ois = new ObjectInputStream(fis);

Person newPerson = (Person)ois.readObject();

ois.close();

System.out.println(newPerson);

//将获取的对象与Person类中的单例对象进行相等性比较

System.out.println(Person.getInstance() == newPerson);

}

}

控制台输出：

constructor

User [name=victor, age=18]

false

发现了没，从流中读取的实例与Person.getInstance实例不是同一个。

为了能序列化过程仍能保持单例的特性，可以在Person类中添加一个readResolve()方法。

package cn.rumor.serial;

import java.io.*;

public class Person implements Serializable {

//...

private Object readResolve() throws ObjectStreamException {

return InstanceHolder.instance;

}

//...

}

控制台输出：

constructor

User [name=victor, age=18]

true

无论是实现Serializable接口，或是Externalizable接口，当从I/O流中读取对象时，readResolve()方法都会被调用到。

实际上就是用readResolve()中返回的对象直接替换在反序列化过程中创建的对象，而被创建的对象则会被垃圾回收掉。

整理自网络，自测通过！