引言
在持久化数据对象的时候我们很少去使用java序列化,而是去使用数据库等方式。但是在我看来,Java 序列化是一个很重要的内容, 序列化不只可以保存对象到磁盘进行持久化,还可以通过网络传输。在平时的面试当中,序列化也是经常谈及的一块内容。
当谈及序列化的时候,大家可能知道将类实现Serializable接口就可以达到序列化的目的, 但是当我们看一些序列化的面试题我们却一脸懵逼。
- 可序列化接口和可外部接口的区别是什么
- 序列化时,你希望某些成员不要序列化?你如何实现它?
- 什么是 serialVersionUID ?如果你不定义这个, 会发生什么?
我们发现我们对这些问题都有很大疑惑,今天我们就来总结一波序列化的常见问题,并且写一个demo来测试一波
问题一:什么是 Java 序列化
序列化是把对象改成可以存到磁盘或通过网络发送到其他运行中的 Java 虚拟机的二进制格式的过程, 并可以通过反序列化恢复对象状态. Java 序列化API给开发人员提供了一个标准机制, 通过实现 java.io.Serializable 或者 java.io.Externalizable 接口, ObjectInputStream 及ObjectOutputStream 处理对象序列化. 实现java.io.Externalizable 接口的话,Java 程序员可自由选择基于类结构的标准序列化或是他们自定义的二进制格式, 通常认为后者才是最佳实践, 因为序列化的二进制文件格式成为类输出 API的一部分, 可能破坏 Java 中私有和包可见的属性的封装。
话不多说,咱们看一下序列化到底有什么用:
实现 java.io.Serializable:
定义用户类
class User implements Serializable {
private String username;
private String passwd;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPasswd() {
return passwd;
}
public void setPasswd(String passwd) {
this.passwd = passwd;
}
}
我们把对象序列化然后通过ObjectOutputStream存储到txt文件中,再通过ObjectInputStream读取txt文件,反序列化成User对象
public class TestSerialize {
public static void main(String[] args) {
User user = new User();
user.setUsername("hengheng");
user.setPasswd("123456");
System.out.println("read before Serializable: ");
System.out.println("username: " + user.getUsername());
System.err.println("password: " + user.getPasswd());
try {
ObjectOutputStream os = new ObjectOutputStream(
new FileOutputStream("/Users/admin/Desktop/test/user.txt"));
os.writeObject(user); // 将User对象写进文件
os.flush();
os.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
try {
ObjectInputStream is = new ObjectInputStream(new FileInputStream(
"/Users/admin/Desktop/test/user.txt"));
user = (User) is.readObject(); // 从流中读取User的数据
is.close();
System.out.println("\nread after Serializable: ");
System.out.println("username: " + user.getUsername());
System.err.println("password: " + user.getPasswd());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
运行结果:
序列化前数据:
username: hengheng
password: 123456
序列化后数据:
username: hengheng
password: 123456
到这里,我们大概知道了什么是序列化。
问题二:序列化时,你希望某些成员不要序列化,该如何实现它?
答案:声明该成员为静态或瞬态, 在 Java 序列化过程中则不会被序列化。
静态变量:加static关键字
瞬态变量: 加transient关键字
首先我们先把变量声明为瞬态试一下
class User implements Serializable {
private String username;
private transient String passwd;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPasswd() {
return passwd;
}
public void setPasswd(String passwd) {
this.passwd = passwd;
}
我们在密码字段前加上了transient关键字,再运行:
运行结果:
序列化前数据:
username: hengheng
password: 123456
序列化后数据:
username: hengheng
password: null
诶,我们发现密码没有被序列化,达到了我们的目的
然后我们再尝试一下把用户名前加static关键字
class User implements Serializable {
private static String username;
private transient String passwd;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPasswd() {
return passwd;
}
public void setPasswd(String passwd) {
this.passwd = passwd;
}
再运行一下看看:
序列化前数据:
username: hengheng
password: 123456
序列化后数据:
username: hengheng
password: null
我们发现运行后的结果和我们预期的不一样,按理说username也应该变为null才对。是什么原因呢?
原因是:反序列化后类中static型变量username的值为当前JVM中对应的静态变量的值,而不是反序列化得出的。我们来证明一下:
public class TestSerialize {
public static void main(String[] args) {
User user = new User();
user.setUsername("hengheng");
user.setPasswd("123456");
System.out.println("序列化前数据: ");
System.out.println("username: " + user.getUsername());
System.err.println("password: " + user.getPasswd());
try {
ObjectOutputStream os = new ObjectOutputStream(
new FileOutputStream("/Users/admin/Desktop/test/user.txt"));
os.writeObject(user); // 将User对象写进文件
os.flush();
os.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
User.username = "小明";
try {
ObjectInputStream is = new ObjectInputStream(new FileInputStream(
"/Users/admin/Desktop/test/user.txt"));
user = (User) is.readObject(); // 从流中读取User的数据
is.close();
System.out.println("\n序列化后数据: ");
System.out.println("username: " + user.getUsername());
System.err.println("password: " + user.getPasswd());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
class User implements Serializable {
public static String username;
private transient String passwd;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPasswd() {
return passwd;
}
public void setPasswd(String passwd) {
this.passwd = passwd;
}
}
我们在反序列化前把静态变量username的值改为『小明』
User.username = "小明";
然后我们再运行一次试一下:
序列化前数据:
username: hengheng
password: 123456
序列化后数据:
username: 小明
password: null
果然,这里的username是jvm中静态变量的值,并不是反序列化得到的值。
问题三:serialVersionUID有什么用
我们经常会在类中自定义一个serialVersionUID:
private static final long serialVersionUID = 8294180014912103005L
这个serialVersionUID有什么用呢?如果不设置的话会有什么后果呢?
serialVersionUID 是一个 private static final long 型 ID, 当它被印在对象上时, 它通常是对象的哈希码。serialVersionUID可以自己定义,也可以自己去生成
不指定 serialVersionUID的后果是:
当你添加或修改类中的任何字段时, 则已序列化类将无法恢复, 因为为新类和旧序列化对象生成的 serialVersionUID 将有所不同。Java 序列化过程依赖于正确的序列化对象恢复状态的, ,并在序列化对象序列版本不匹配的情况下引发 java.io.InvalidClassException 无效类异常
举个例子,大家就明白了:
我们保持之前保存的序列化文件不变,然后去修改User类
class User implements Serializable {
public static String username;
private transient String passwd;
private String age;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPasswd() {
return passwd;
}
public void setPasswd(String passwd) {
this.passwd = passwd;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
}
我们加了一个属性age,然后我们单另写一个反序列化的方法:
public static void main(String[] args) {
try {
ObjectInputStream is = new ObjectInputStream(new FileInputStream(
"/Users/admin/Desktop/test/user.txt"));
User user = (User) is.readObject(); // 从流中读取User的数据
is.close();
System.out.println("\n修改User类之后的数据: ");
System.out.println("username: " + user.getUsername());
System.err.println("password: " + user.getPasswd());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
报错了,我们发现之前的User类生成的serialVersionUID和修改后的serialVersionUID不一样(因为是通过对象的哈希码生成的),导致了InvalidClassException异常。
所以我们要自定义serialVersionUID
class User implements Serializable {
private static final long serialVersionUID = 4348344328769804325L;
public static String username;
private transient String passwd;
private String age;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPasswd() {
return passwd;
}
public void setPasswd(String passwd) {
this.passwd = passwd;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
}
再试一下
序列化前数据:
username: hengheng
password: 123456
序列化后数据:
username: 小明
password: null
发现可以了,所以我们一般都要自定义serialVersionUID
问题四:是否可以自定义序列化过程?
答案当然是可以的
之前我们介绍了序列化的第二种方式:
实现Externalizable接口,然后重写writeExternal() 和readExternal()方法,这样就可以自定义序列化,比如我们把变量设为瞬态试一下。
public class ExternalizableTest implements Externalizable {
private transient String content = "我是被transient修饰的变量哦";
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeObject(content);
}
@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
content = (String) in.readObject();
}
public static void main(String[] args) throws Exception {
ExternalizableTest et = new ExternalizableTest();
ObjectOutput out = new ObjectOutputStream(new FileOutputStream(
new File("test")));
out.writeObject(et);
ObjectInput in = new ObjectInputStream(new FileInputStream(new File(
"test")));
et = (ExternalizableTest) in.readObject();
System.out.println(et.content);
out.close();
in.close();
}
}
运行结果:
我是被transient修饰的变量哦
这里我们实现的是Externalizable接口,则没有任何东西可以自动序列化,需要在writeExternal方法中进行手工指定所要序列化的变量,这与是否被transient修饰无关。
现在是不是对java序列化有了更多的了解