首页 > 代码库 > Java对象序列化与反序列化
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
Java对象序列化与反序列化
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。