Java对象序列化与反序列化
对象序列化的目标是将对象保存在磁盘中或者在网络中进行传输。实现的机制是允许将对象转为与平台无关的二进制流。
java中对象的序列化机制是将允许对象转为字节序列。这些字节序列可以使Java对象脱离程序存在，从而可以保存在磁盘上，也可以在网络间传输。
对象的序列化是将一个Java对象写入IO流；与此对应的，反序列化则是从IO流中恢复一个Java对象。
实现序列化
如果要将一个java对象序列化，那么对象的类需要是可序列化的。要让类可序列化，那么这个类需要实现如下两个接口：
- Serializable
- Externalizable
使用Serializable序列化
实现Serializable接口非常简单，只要让java实现Serializable接口即可，无需实现任何方法。
一个类一旦实现了Serializable接口，那么该类的对象就是可序列化的。实现类的对象的序列化可以使用ObjectOutputStream，实现步骤如下：
- 创建ObjectOutputStream对象；
- 调用ObjectOutputStream的writeObject方法输出对象。
以下是一个实例：
package com.zhyea.test; import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable; /**
* 序列化测试类
*
* @author robin
* @date 2014年12月18日
*/
public class SerialTest { public static void main(String[] args) {
ObjectOutputStream oos = null;
try {
oos = new ObjectOutputStream(new FileOutputStream("D:\\object.txt"));
Person robin = new Person("robin", 29);
oos.writeObject(robin);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != oos) {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
} /**
* 序列化测试用对象
*
* @author robin
* @date 2014年12月18日
*/
class Person implements Serializable{ private static final long serialVersionUID = -6412852654889352693L; /**
* 姓名
*/
private String name;
/**
* 年龄
*/
private int age; public Person() {
} public Person(String name, int age) {
this.name = name;
this.age = 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;
}
}
如上的代码实现了将一个Person对象保存在了磁盘的一个文本文件object.txt上。运行程序在D盘上生成了一个object.txt文件。以下是文件内容：
有乱码（字节流转字符流导致的），但仍不影响我们分辨出里面是不是我们保存的对象。
接下来需要反序列化将Person对象从磁盘上读出。相应的反序列化需要使用的类是ObjectInputStream，反序列化步骤如下：
- 创建ObjectInputStream对象；
- 使用ObjectInputStream的readObject方法取出对象。
接下来，重构下我们的代码，实现反序列化，如下：
package com.zhyea.test; import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable; /**
* 序列化测试类
*
* @author robin
* @date 2014年12月18日
*/
public class SerialTest { public static void main(String[] args) {
Person robin = new Person("robin", 29);
String savePath = "D:\\object.txt"; SerialTest test = new SerialTest(); try {
test.serialize(robin, savePath);
Person person = (Person) test.deSerialize(savePath);
System.out.println("Name:" + person.getName() + " Age:"
+ person.getAge());
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
} /**
* 实现序列化
*
* @param obj
* 要被序列化保存的对象
* @param path
* 保存地址
* @throws IOException
*/
public void serialize(Object obj, String path) throws IOException {
ObjectOutputStream oos = null;
try {
oos = new ObjectOutputStream(new FileOutputStream(path));
oos.writeObject(obj);
} finally {
if (null != oos)
oos.close();
}
} /**
* 反序列化取出对象
*
* @param path
* 被序列化对象保存的位置
* @return
* @throws IOException
* @throws ClassNotFoundException
*/
public Object deSerialize(String path) throws IOException,
ClassNotFoundException {
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream(path));
return ois.readObject();
} finally {
if (null != ois)
ois.close();
}
} } /**
* 序列化测试用对象
*
* @author robin
* @date 2014年12月18日
*/
class Person implements Serializable { private static final long serialVersionUID = -6412852654889352693L; /**
* 姓名
*/
private String name;
/**
* 年龄
*/
private int age; public Person() {
} public Person(String name, int age) {
this.name = name;
this.age = 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;
}
}
关于对象序列化与反序列化还有几点需要注意：
- 反序列化无需通过构造器初始化对象；
- 如果使用序列化机制向文件中写入了多个对象，那么取出和写入的顺序必须一致；
- Java对类的对象进行序列化时，若类中存在对象引用（且值不为null），也会对类的引用对象进行序列化。
使用transient
在一些特殊场景下，比如银行账户对象，出于保密考虑，不希望对存款金额进行序列化。或者类的一些引用类型的成员是不可序列化的。此时可以使用transient关键字修饰不想被或者不能被序列化的成员变量。
继续调整我们的代码来做演示：
package com.zhyea.test; import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable; /**
* 序列化测试类
*
* @author robin
* @date 2014年12月18日
*/
public class SerialTest { public static void main(String[] args) {
Person robin = new Person("robin", 29);
School school = new School("XX学校"); Teacher tRobin = new Teacher(robin);
tRobin.setSchool(school);
tRobin.setSalary(12.0); String savePath = "D:\\object.txt"; SerialTest test = new SerialTest(); try {
test.serialize(savePath, tRobin); Teacher t = (Teacher) test.deSerialize(savePath);
System.out.println("Name:" + t.getPerson().getName()
+" Salary:" + t.getSalary());
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
} /**
* 实现序列化
*
* @param obj
* 要被序列化保存的对象
* @param path
* 保存地址
* @throws IOException
*/
public void serialize(String path, Object ... obj) throws IOException {
....
} /**
* 反序列化取出对象
*
* @param path
* 被序列化对象保存的位置
* @return
* @throws IOException
* @throws ClassNotFoundException
*/
public Object deSerialize(String path) throws IOException,
ClassNotFoundException {
...
} } /**
* Teacher类
* @author robin
* @date 2014年12月18日
*/
class Teacher implements Serializable{ private static final long serialVersionUID = -8751853088437904443L; private Person person;
private transient School school;
private transient double salary; public Teacher(Person person){
this.person = person;
} /*略去get、set，请自行补充*/
} /**
* School类，不可序列化
*
* @author robin
* @date 2014年12月18日
*/
class School{
private String name; public School(String name){
this.name = name;
} /*略去get、set，请自行补充*/
} /**
* Person类，可序列化
*
* @author robin
* @date 2014年12月18日
*/
class Person implements Serializable { ....
}
在不对Teacher类的school成员添加transient标识的情况下，若school值不为null，会报NotSerializableException。异常信息如下：
在不对Teacher类的salary成员添加transient标识的时候，会如实输出salary的值，添加后则只会输出salary的默认初始值即0.0。
需要注意的是transient只能修饰属性（filed），不能修饰类或方法。
自定义序列化
transient提供了一种简洁的方式将被transient修饰的成员属性完全隔离在序列化机制之外。这样子固然不错，但是Java还提供了一种自定义序列化机制让开发者更自由地控制如何序列化各个成员属性，或者不序列化某些属性（与transient效果相同）。
在需要自定义序列化和反序列化的类中需要提供以下方法：
- private void writeObject(ObjectOutputStream out)
- private void readObject(ObjectInputStream in)
- private void readObjectNoData()
先说下前两个方法writeObject和readObject，这两个方法和ObjectOutputStream及ObjectInputStream里对应的方法名称相同。实际上，尽管这两个方法是private型的，但是仍然是在被序列化（或反序列化）阶段被外部类ObjectOutputStream（或ObjectInputStream）调用。仅以序列化为例，ObjectOutputStream在执行自己的writeObject方法前会先通过反射在要被序列化的对象的类中（有点绕口是吧）查找有无自定义的writeObject方法，如有的话，则会优先调用自定义的writeObject方法。因为查找反射方法时使用的是getPrivateMethod，所以自定以的writeObject方法的作用域要被设置为private。通过自定义writeObject和readObject方法可以完全控制对象的序列化与反序列化。
如下是示例代码：
package com.zhyea.test; import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable; import com.sun.xml.internal.ws.encoding.soap.DeserializationException; /**
* 序列化测试类
*
* @author robin
* @date 2014年12月18日
*/
public class SerialTest { public static void main(String[] args) {
Person robin = new Person("robin", 29); String savePath = "D:\\object.txt"; SerialTest test = new SerialTest(); try {
test.serialize(savePath, robin);
Person person = (Person) test.deSerialize(savePath); System.out.println("Name:" + person.getName()
+" Age:" + person.getAge()); } catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
} /**
* 实现序列化
*
* @param obj
* 要被序列化保存的对象
* @param path
* 保存地址
* @throws IOException
*/
public void serialize(String path, Person ... obj) throws IOException {
ObjectOutputStream oos = null;
...
} /**
* 反序列化取出对象
*
* @param path
* 被序列化对象保存的位置
* @return
* @throws IOException
* @throws ClassNotFoundException
*/
public Object deSerialize(String path) throws IOException,
ClassNotFoundException {
...
} } /**
* Person类，可序列化
*
* @author robin
* @date 2014年12月18日
*/
class Person implements Serializable { private static final long serialVersionUID = -6412852654889352693L; /**
* 姓名
*/
private String name;
/**
* 年龄
*/
private int age; public Person() {} public Person(String name, int age) {
this.name = name;
this.age = age;
} /* 略去get和set，请自行实现 */ private void writeObject(ObjectOutputStream out) throws IOException{
out.writeObject(name);
out.writeInt(age + 1); System.out.println("my write");
} private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException{
this.name = "zhangsan";
this.age = 30;
System.out.println("my read");
}
}
以下是输出结果：
关于readObjectNoData，在网上找了如下一段说明：
readObjectNoData
原始情况
pojo
public class Person implements Serializable {
private int age;
public Person() { }
//setter getter...
}
序列化
Person p = new Person();
p.setAge(10);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("c:/person.ser"));
oos.writeObject(p);
oos.flush();
oos.close();
类结构变化后, 序列化数据不变 pojo
Animal
implements Serializable
显式编写readObjectNoData
public class Animal implements Serializable {
private String name;
public Animal() { }
//setter getter...
private void readObjectNoData() {
this.name = "zhangsan";
}
}
Person
extends Animal
public class Person extends Animal implements Serializable {
private int age;
public Person() { }
// setter getter...
}
反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("c:/person.ser"));
Person sp = (Person) ois.readObject();
System.out.println(sp.getName());
readObject时, 会调用readObjectNoData
readObjectNoData在我理解看来像是一种异常处理机制，用来在序列化的流不完整的情况下返回正确的值。
使用 writeReplace和readResolve
writeReplace和readResolve是一种更彻底的序列化的机制，它甚至可以将序列化的目标对象替换为其它的对象。
但是与writeObject和readObject不同的是，这二者不是必须要一起使用的，而且尽量应分开使用。若一起使用的话，只有writeReplace会生效。
代码可以说明一切，首先是writeReplace：
package com.zhyea.test; import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamException;
import java.io.Serializable; /**
* 序列化测试类
*
* @author robin
* @date 2014年12月18日
*/
public class SerialTest { public static void main(String[] args) {
Person robin = new Person("robin", 29);
String savePath = "D:\\object.txt";
SerialTest test = new SerialTest();
try {
//序列化
test.serialize(savePath, robin);
//反序列化
String person = (String) test.deSerialize(savePath); System.out.println(person); } catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
} /**
* 实现序列化
*
* @param obj
* 要被序列化保存的对象
* @param path
* 保存地址
* @throws IOException
*/
public void serialize(String path, Person ... obj) throws IOException {
ObjectOutputStream oos = null;
....
} /**
* 反序列化取出对象
*
* @param path
* 被序列化对象保存的位置
* @return
* @throws IOException
* @throws ClassNotFoundException
*/
public Object deSerialize(String path) throws IOException,
ClassNotFoundException {
....
} } /**
* Person类，可序列化
*
* @author robin
* @date 2014年12月18日
*/
class Person implements Serializable { private static final long serialVersionUID = -6412852654889352693L; /**
* 姓名
*/
private String name;
/**
* 年龄
*/
private int age; public Person() {} public Person(String name, int age) {
this.name = name;
this.age = age;
} /* set和get方法请自行添加 */ private Object writeReplace() throws ObjectStreamException{
System.out.println("my writeReplace");
return "robin";
} private Object readResolve() throws ObjectStreamException{
System.out.println("my readResolve");
return "zhangsan";
} private void writeObject(ObjectOutputStream out) throws IOException{
....
} private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException{
....
}
}
以下是运行结果：
在Person类中，保留了之前的writeObject和readObject方法，并且还添加了readResolve方法。但是从运行结果可以看出来，这3个方法都没有被调用，只有writeReplace方法被使用。可以理解为当使用writeReplace时，其他的自定义方法都不会被调用，即writeReplace的优先级最高。
现在注释掉writeReplace方法，再次执行，结果如下：
这次writeObject，readObject和readResolve方法都被调用。readResolve方法紧跟着readObject方法被调用且最终返回的值是readResolve返回的值，readObject里反序列化生成的对象被抛弃。
此外还有一点需要说明：writeReplace和readResolve可以使用任何作用域，这意味着子类也可以调用超类的这两个方法。但是如果子类还有不同的序列化及反序列化需求，这就需要子类重写这个方法，有些时候这样做是没有必要的。因此一般情况下将这两个方法的作用域设置为private。
使用Externalizable
一开始有提到过实现Externalizable接口也可以实现类的序列化。使用这种方法，可以由开发者完全决定如何序列化和反序列化目标对象。Externalizable接口提供了writeExternal和readExternal两个方法。
实际上这种方法和前面的自定义序列化方法很相似，只是Externalizable强制自定义序列化。在使用了Externalizable的类中仍可以使用writeReplace和readResolve方法。使用Externalizable进行序列化较之使用Serializable性能略好，但是复杂度较高。
版本问题
执行序列化和反序列化时有可能会遇到JRE版本问题。尤其是在网络的两端进行通信时，这种情况更为多见。
为了解决这种问题，Java允许为序列化的类提供一个serialVersionUID的常量标识该类的版本。只要serialVersionUID的值不变，Java就会把它们当作相同的序列化版本。
如果不显式定义serialVersionUID，那么JVM就会计算出一个serialVersionUID的值。不同的编译器下会产生不同的serialVersionUID值。serialVersionUID值不同则会导致编译失败。可以使用jdk的bin目录下的serial.exe查看可序列化类的serialVersionUID，指令如下：
serial Person
如果对类的修改确实会导致反序列化失败，则应主动调整serialVersionUID的值。导致类的反序列化失败的修改有以下几种情形：
- 只是修改了类的方法，不会影响反序列化。
- 只是修改了类的static Field或transient Field，不会影响反序列化。
- 修改了类的非static和非transient Field，会影响序列化。
序列化注意事项
关于对象的序列化，总结下注意事项：
- 对象的类名、Field（包括基本类型、数组及对其他对象的引用）都会被序列化，对象的static Field，transient Field及方法不会被序列化；
- 实现Serializable接口的类，如不想某个Field被序列化，可以使用transient关键字进行修饰；
- 保证序列化对象的引用类型Filed的类也是可序列化的，如不可序列化，可以使用transient关键字进行修饰，否则会序列化失败；
- 反序列化时必须要有序列化对象的类的class文件；
- 当通过文件网络读取序列化对象的时候，必需按写入的顺序来读取。
Java对象序列化与反序列化的更多相关文章
- java 对象序列化与反序列化
Java序列化与反序列化是什么? 为什么需要序列化与反序列化? 如何实现Java序列化与反序列化? 本文围绕这些问题进行了探讨. 1.Java序列化与反序列化 Java序列化是指把Java对象转换为 ...
- Java对象序列化与反序列化一 JSON
Java对象序列化与反序列化一 JSON 1. 依赖库 jackson-all-1.6.1.jar 2. 代码 public class Student { private String nam ...
- Java对象序列化和反序列化的工具方法
import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import ja ...
- Java 对象序列化和反序列化
之前的文章中我们介绍过有关字节流字符流的使用,当时我们对于将一个对象输出到流中的操作,使用DataOutputStream流将该对象中的每个属性值逐个输出到流中,读出时相反.在我们看来这种行 ...
- java对象序列化、反序列化
平时我们在Java内存中的对象,是无法进行IO操作或者网络通信的,因为在进行IO操作或者网络通信的时候,人家根本不知道内存中的对象是个什么东西,因此必须将对象以某种方式表示出来,即存储对象中的状态.一 ...
- java对象序列化和反序列化，redis存入和获取对象
最近使用redis发现直接存储序列化后的对象更方便,现提供java序列化和反序列化的代码 1.序列化代码: public static byte[] serialize(Object object) ...
- Java 对象序列化和反序列化 （实现 Serializable 接口）
序列化和反序列化的概念 把对象转换为字节序列的过程称为对象的序列化. 把字节序列恢复为对象的过程称为对象的反序列化. 对象的序列化主要有两种用途: 1) 把对象的字节序列永久地保存到硬盘上,通常存放 ...
- JAVA对象序列化和反序列化学习
JAVA序列化就是将JAVA对象转化为字节序列的过程,而JAVA反序列化就是将字节序列转化为JAVA对象的过程. 这一过程是通过JAVA虚拟机独立完成,所以一个对象序列化后可以在任意时间和任意机器上反 ...
- Java基础—序列化与反序列化（转载）
转载自: Java序列化与反序列化 1.Java序列化与反序列化 Java序列化是指把Java对象转换为字节序列的过程:而Java反序列化是指把字节序列恢复为Java对象的过程. 2.为什么需要序列化 ...
随机推荐
- 基于Web和二维码的文件传输服务
在工作中难免需要对外提供一些我们抓取的log或者操作视频之类的资料,但由于工作环境日渐规范和严格,公司的网络环境和客户的网络环境是被独立开来的.这样做的好处不必多说,但同时也给我们工作带来的诸多不便. ...
- canvas基本使用
1.什么是CANVAS canvas是html5新增的画布元素,可以通过javascript来在画布上绘制图形,图标以及任何视觉性的图像. 2.canvas的用途 替代flash,做各种动态效果,做小 ...
- SET NAMES 'charset_name'
设置写入db和db返回读出结果的字符集character set https://dev.mysql.com/doc/refman/5.7/en/charset-connection.html SET ...
- Python菜鸟之路：原生Ajax/Jquery Ajax/IFrame Ajax的选用
原生Ajax Jquery Ajax IFrame Ajax 如果发送的是普通的数据,比如用户简单的输入.选择的值,推荐使用Jquery ,其次用XMLHttpRquest对象,最次使用IFrame ...
- ArcGIS runtime for wpf 部署
简介 ArcGIS runtime for wpf 是一个轻量级的产品,部署方便,甚至可以做到直接部署在U盘中,做到即插即用. 部署一般需要遵循如下几个步骤: 1. 设定部署许可 虽然ArcGIS r ...
- Cocos2dx3.1-Android环境搭建初体验
初玩Cocos2dx,多多包涵. 感觉版本号之间的差异比較大.相对前面的版本号来说.3.X更easy上手.更方便了. 一.安装python.我的python-2.7.3. 配置环境变量 系统变量里:在 ...
- 你真的会用Gson吗?Gson使用指南
你真的会用Gson吗?Gson使用指南(一) 你真的会用Gson吗?Gson使用指南(二) 你真的会用Gson吗?Gson使用指南(三) 你真的会用Gson吗?Gson使用指南(四)
- Python基础-面向对象1
class Bar: def fansik(self, name, age): print(name, age) obj = Bar() print(obj.fansik('fanjinbao', 1 ...
- vue项目如何打包扔向服务器
vue项目如何打包扔向服务器 当我们将 vue 项目完成后,面临的就是如何将项目进行打包上线,放到服务器中.我使用的是 vue-cli(simple) 脚手架,所以就讲一下如何将项目进行打包,并放 ...
- Extracts
@1:四层和七层负载均衡的区别:所谓四层负载均衡,也就是主要通过报文中的目标地址和端口,再加上负载均衡设备设置的服务器选择方式,决定最终选择的内部服务器.以常见的TCP为例,负载均衡设备在接收到第一个 ...