Java序列化（Serializable）与反序列化详解

什么是序列化？

Java序列化是在JDK 1.1中引入的，是Java内核的重要特性之一。

Java序列化API允许我们将一个对象转换为流，并通过网络发送，或将其存入文件或数据库以便未来使用，

反序列化则是将对象流转换为实际程序中使用的Java对象的过程。

序列化有啥用？

1.暂存大对象

2.Java对象需要持久化的时候

3.需要在网络，例如socket中传输Java对象

    因为数据只能够以二进制的形式在网络中进行传输，因此当把对象通过网络发送出去之前需要先序列化成二进制数据，在接收  端读到二进制数据之后反序列化成Java对象

4.深度克隆（复制）

5.跨虚拟机通信

代码怎么写？

1.序列化例子

实体类：Student.java

package com.dylan.serialization;

import java.io.Serializable;

/**
* 学生类
*
* @author xusucheng
* @create 2018-01-08
**/
public class Student implements Serializable {

private int id;
private String name;
private String gender;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

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;
}

public Student(int id, String name, String gender) {
this.id = id;
this.name = name;
this.gender = gender;
}

@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", gender='" + gender + '\'' +
'}';
}
}

package com.dylan.serialization;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

/**
* 序列化例子
*
* @author xusucheng
* @create 2018-01-08
**/
public class SerializationDemo {
public static void main(String[] args) throws IOException{
//学生1
Student s1 = new Student(101,"Jack","Male");
//学生2
Student s2 = new Student(102,"Lily","Female");

List<Student> list = new ArrayList<>();
list.add(s1);
list.add(s2);

//创建文件流
FileOutputStream fos = new FileOutputStream("D:\\test\\student01.ser");
ObjectOutputStream os = new ObjectOutputStream(fos);
os.writeObject(list);

os.close();
System.out.println("序列化完成！");
}
}

2.反序列化例子

package com.dylan.serialization;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import java.util.List;

/**
* 反序列化例子
*
* @author xusucheng
* @create 2018-01-08
**/
public class DeserializationDemo {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("D:\\test\\student01.ser");
ObjectInputStream is = new ObjectInputStream(fis);
Object obj = null;
List<Student> list = new ArrayList<>();
try {
list = (List<Student>)is.readObject();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}

is.close();

//遍历list，输出
for (Student student:list){
System.out.println(student.toString());
}
}
}

3.serialVersionUID的作用

可以看到上面序列化例子中的学生实体类只是实现了Serializable接口，假如我现在接到客户需求，要调整Student类，增加学生年龄属性，调整后如下：

public class Student implements Serializable {

private int id;
private String name;
private String gender;
private int age;
...

此时，我在去执行反序列化程序，结果报错了：



啥玩意？就是说Stuent类调整后，其序列化版本ID发生了变化，java又是根据这个ID来判断是不是同一个类。ID不一样则无法反序列化！

事实上如果一个类没有定义serialVersionUID，它会自动计算出来并分配给该类。当发生以下情况，这个ID就会改变：

在类中添加一些新的变量。

将变量从transient转变为非tansient，对于序列化来说，就像是新加入了一个变量而已

将变量从静态的转变为非静态的，对于序列化来说，就也像是新加入了一个变量而已

这个时候就需要我们手动指定这个serialVersionUID了，它告诉jvm，嗨，这个学生类我更新了一下，反序列化的时候记得尽量向后兼容，别报错。通常我们有以下几种方式：

serialVersionUID生成方式：

1）直接写固定的1L；

2）利用JDK自带serialver命令：切到类路径下



3）IDEA生成serialVersionUID

Intellij IDEA 默认没启用这个功能

Preferences->Editor->Inspections->Serialization issues->Serializable class without serialVersionUID 勾上

应用之后就开启了检测功能

在你的class名前（一定是光标移动到类名前）：按（mac:option+return）或者( win:Alt+Enter) 就会提示自动创建 serialVersionUID 了。



加上serialVersionUID后的实体类如下：

public class Student implements Serializable {

private static final long serialVersionUID = -2110227637642817458L;

private int id;
private String name;
private String gender;
private int age;
...

再次执行反序列化又恢复正常了：

Student{id=101, name='Jack', gender='Male'}

Student{id=102, name='Lily', gender='Female'}

在这里有一个建议，如果没有特殊需求，就是用默认的 1L 就可以，这样可以确保代码一致时反序列化成功。

那么随机生成的序列化 ID 有什么作用呢，有些时候，通过改变序列化 ID 可以用来限制某些用户的使用。

4.static和transient属性无法序列化

transient翻译过来就是短暂的，瞬时的。如果在可序列化的类中某个成员变量加了这个修饰，则说明它只在jvm运行时才保存值，序列化时不会保存的。

为了证明这一点，我们调整一下Student类，加入1个静态变量mess和1个transient变量password。调整后的类如下：

package com.dylan.serialization;

import java.io.Serializable;

/**
* 学生类
*
* @author xusucheng
* @create 2018-01-08
**/
public class Student implements Serializable {

private static final long serialVersionUID = -2110227637642817458L;
private static String mess="null";

private int id;
private String name;
private String gender;
private int age;
private transient String password;

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

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;
}

public Student(int id, String name, String gender) {
this.id = id;
this.name = name;
this.gender = gender;
mess = "something";
}

@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", gender='" + gender + '\'' +
", age=" + age +
", password='" + password + '\'' +
", mess='" + mess + '\'' +
'}';
}
}

再次执行序列化，反序列化后：



结论没问题。

5.序列化实战：Socket传输序列化对象例子

package com.dylan.serialization;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
* @author xusucheng
* @create 2018-01-08
**/
public class Server {
public static void main(String[] args) {

//The client is used to handle connections with a client once a connection is
//established.
Socket client = null;

//The following two objects handles our Serialization operations, ObjectOutputStream
//writes an object to the stream. ObjectInputStream reads an object from the stream.
ObjectOutputStream out = null;
ObjectInputStream in = null;

try {
ServerSocket server = new ServerSocket(8888);
client = server.accept();
out = new ObjectOutputStream(client.getOutputStream());
in = new ObjectInputStream(client.getInputStream());

Student student = (Student) in.readObject();
System.out.println(student);

// close resources
out.close();
in.close();
client.close();
server.close();

} catch (IOException e) {
e.printStackTrace();
System.exit(-1);
}
catch (Exception e) {
e.printStackTrace();
System.exit(-1);
}
}
}

package com.dylan.serialization;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

/**
* @author xusucheng
* @create 2018-01-08
**/
public class Client {
public static void main(String[] args) {
Socket client = null;
ObjectOutputStream out = null;
ObjectInputStream in = null;

try {

client = new Socket("127.0.0.1", 8888);
out = new ObjectOutputStream(client.getOutputStream());
in = new ObjectInputStream(client.getInputStream());

Student student = new Student(991,"Dylan","Male");
out.writeObject(student);
out.flush();

out.close();
in.close();
client.close();

} catch (UnknownHostException e) {
e.printStackTrace();
System.exit(1);
} catch (IOException e) {
e.printStackTrace();
System.exit(1);
}

}
}

说明：假如Student类没有实现序列化接口，在执行Client程序时会报错：



正如我们前面所讲，网络只能传输二进制数据，Java对象要想传输必须先序列化。

运行效果：



以上只是讲解了一下序列化的常用知识点，还有些深入的部分，以后有空再总结。