Java 中如何实现序列化,有什么意义?【中等】
1.实现序列化:
1)让类实现Serializable接口,该接口是一个标志性接口,标注该类对象是可被序列
2)然后使用一个输出流来构造一个对象输出流并通过writeObect(Obejct)方法就可以将实现对象写出
3)如果需要反序列化,则可以用一个输入流建立对象输入流,然后通过readObeject方法从流中读取对象
2.作用:
1)序列化就是一种用来处理对象流的机制,所谓对象流也就是将对象的内容进行流化,可以对流化后的对象进行读写操作,也可以将流化后的对象传输与网络之间;
2)为了解决对象流读写操作时可能引发的问题(如果不进行序列化,可能会存在数据乱序的问题)
3)序列化除了能够实现对象的持久化之外,还能够用于对象的深度克隆
java序列化详解
一、序列化与反序列化
序列化:指堆内存中的java对象数据,通过某种方式把对存储到磁盘文件中,或者传递给其他网络节点(网络传输)。这个过程称为序列化,通常是指将数据结构或对象转化成二进制的过程。
即将对象转化为二进制,用于保存,或者网络传输。
反序列化:把磁盘文件中的对象数据或者把网络节点上的对象数据,恢复成Java对象模型的过程。也就是将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程
与序列化相反,将二进制转化成对象。
二、序列化的作用
- ① 想把内存中的对象保存到一个文件中或者数据库中时候;
- ② 想用套接字在网络上传送对象的时候;
- ③ 想通过RMI传输对象的时候
一些应用场景,涉及到将对象转化成二进制,序列化保证了能够成功读取到保存的对象。
三、java的序列化实现
要实现对象的序列化,最直接的操作就是实现Serializable接口
使用IO流中的对象流可以实现序列化操作,将对象保存到文件,再读取出来。
首先创建一个对象,并实现Serializable接口:
import java.io.Serializable;
public class User implements Serializable{
private static final long serialVersionUID = 1L;
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + "]";
}
}
用对象流写一个保存对象与读取对象的工具类:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class SerializeUtil {
// 保存对象,序列化
public static void saveObject(Object object) throws Exception {
ObjectOutputStream out = null;
FileOutputStream fout = null;
try {
fout = new FileOutputStream("D:/1.txt");
out = new ObjectOutputStream(fout);
out.writeObject(object);
} finally {
fout.close();
out.close();
}
}
// 读取对象,反序列化
public static Object readObject() throws Exception {
ObjectInputStream in = null;
FileInputStream fin = null;
try {
fin = new FileInputStream("D:/1.txt");
in = new ObjectInputStream(fin);
Object object = in.readObject();
return object;
} finally {
fin.close();
in.close();
}
}
}
测试:
public class Main {
public static void main(String[] args) {
User user = new User();
user.setName("旭旭宝宝");
user.setAge(33);
// 保存
try {
SerializeUtil.saveObject(user);
} catch (Exception e) {
System.out.println("保存时异常:" + e.getMessage());
}
// 读取
User userObject;
try {
userObject = (User) SerializeUtil.readObject();
System.out.println(userObject);
} catch (Exception e) {
System.out.println("读取时异常:" + e.getMessage());
}
}
}
测试结果:
User [name=旭旭宝宝, age=33]
这里我们成功的进行了一次将对象保存到文件中,再读取了出来。如果此时,我们不实现序列化接口,就会出现异常了。我们取消实现的Serialiable接口代码:
public class User {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + "]";
}
}
再测试Main方法:
保存时异常:test001.User
读取时异常:writing aborted; java.io.NotSerializableException: test001.User
可以看到此时报错了,此时使用 e.printStackTrace();查看异常的详细信息:
java.io.WriteAbortedException: writing aborted; java.io.NotSerializableException: test001.User
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1577)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:431)
at test001.SerializeUtil.readObject(SerializeUtil.java:30)
at test001.Main.main(Main.java:19)
Caused by: java.io.NotSerializableException: test001.User
at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
at test001.SerializeUtil.saveObject(SerializeUtil.java:16)
at test001.Main.main(Main.java:12)
可以看到Unknown Source,因为没有进行序列化,所以无法进行保存与读取。
四、序列化ID的作用
可以看到,我们在进行序列化时,加了一个serialVersionUID字段,这便是序列化ID
private static final long serialVersionUID = 1L;
这个序列化ID起着关键的作用,它决定着是否能够成功反序列化!java的序列化机制是通过判断运行时类的serialVersionUID来验证版本一致性的,在进行反序列化时,JVM会把传进来的字节流中的serialVersionUID与本地实体类中的serialVersionUID进行比较,如果相同则认为是一致的,便可以进行反序列化,否则就会报序列化版本不一致的异常。
即序列化ID是为了保证成功进行反序列化
五、默认的序列化ID
当我们一个实体类中没有显式的定义一个名为“serialVersionUID”、类型为long的变量时,Java序列化机制会根据编译时的class自动生成一个serialVersionUID作为序列化版本比较,这种情况下,只有同一次编译生成的class才会生成相同的serialVersionUID。譬如,当我们编写一个类时,随着时间的推移,我们因为需求改动,需要在本地类中添加其他的字段,这个时候再反序列化时便会出现serialVersionUID不一致,导致反序列化失败。那么如何解决呢?便是在本地类中添加一个“serialVersionUID”变量,值保持不变,便可以进行序列化和反序列化。
如果没有显示指定serialVersionUID,会自动生成一个。
只有同一次编译生成的class才会生成相同的serialVersionUID
但是如果出现需求变动,Bean类发生改变,则会导致反序列化失败。为了不出现这类的问题,所以我们最好还是显式的指定一个serialVersionUID。
六、序列化的其他问题
- 静态变量不会被序列化( static,transient)
- 当一个父类实现序列化,子类自动实现序列化,不需要显式实现Serializable接口。
- 当一个对象的实例变量引用其他对象,序列化该对象时也把引用对象进行序列化。
子类序列化时:
- 如果父类没有实现Serializable接口,没有提供默认构造函数,那么子类的序列化会出错;
- 如果父类没有实现Serializable接口,提供了默认的构造函数,那么子类可以序列化,父类的成员变量不会被序列化。如果父类实现了Serializable接口,则父类和子类都可以序列化。
七、使用效率更高的序列化框架—Protostuff
其实java的原生序列化方式(通过实现Serialiable接口),效率并不是最高的。
github上有一个分析序列化效率的项目:https://github.com/eishay/jvm-serializers/wiki
其中看的出来性能最优的为google开发的colfer ,但是由于colfer的使用难度太大,而更多的都是使用protostuff序列化框架。适用改框架要引入两个库(core与runtime)。
①github地址:https://github.com/protostuff/protostuff
③如果用Maven,则添加依赖:
<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-core</artifactId>
<version>1.5.9</version>
</dependency>
<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-core</artifactId>
<version>1.5.9</version>
</dependency>
修改Main代码
import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtobufIOUtil;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
public class Main {
public static void main(String[] args) {
User user = new User();
user.setName("你好");
user.setAge(33);
Schema<User> schema = RuntimeSchema.getSchema(User.class);
// 保存对象,序列化,转化二进制数据
LinkedBuffer buffer = LinkedBuffer.allocate(512);
final byte[] protostuff;
try {
protostuff = ProtobufIOUtil.toByteArray(user, schema, buffer);
} finally {
buffer.clear();
}
// 读取对象,反序列化
User userObject = schema.newMessage();
ProtostuffIOUtil.mergeFrom(protostuff, userObject, schema);
System.out.println(userObject);
}
}
User类,并未实现Serializable接口
public class User {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + "]";
}
}
测试结果
User [name=你好, age=33]
这样即使我们的User类就不用再实现Serialiable接口了,同样可以进行序列化,效率也更高。