java 序列化机制深度解析
Posted StubbornAnt
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java 序列化机制深度解析相关的知识,希望对你有一定的参考价值。
概要
- 序列化机制允许将实现序列化的Java对象转换为字节序列,这些字节序列可以被保存在磁盘上或通过网络传输,以备以后重新恢复原来的对象,序列化机制使得对象可以脱离程序的运行而独立存在
- 可序列化的类包括:实现了Serializable的类,数组,枚举,String类也是可序列化对象
- 由于序列化保存的是对象的状态,因此不会保存类的静态变量
-通过ObjectOutputStream和ObjectInputStream对对象进行序列化及反序列化 - 虚拟机是否允许反序列化,不仅取决于类路径和功能代码是否一致,一个非常重要的一点是两个类的序列化 ID 是否一致(就是 private static final long serialVersionUID)
- Transient 关键字的作用是控制变量的序列化,在变量声明前加上该关键字,可以阻止该变量被序列化到文件中
- 反序列化对象时必须有序列化对象的class文件
- 通过文件、网络来读取序列化的对象时,必须按实际写入顺序读取;
不被序列化的内容
- 静态变量不会被序列化
- transient类型成员变量不会被序列化
可序列化的类型
- 实现Serializable接口的类
- String类
- java基本类型
- Enum 枚举类型
- 数组类型
public class Demo
public static void main(String[] args) throws Exception
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("tempFile"));
ObjectInputStream in = new ObjectInputStream(new FileInputStream("tempFile"));
out.writeObject("hello world");
out.writeObject(new int[]1, 2, 3);
out.writeObject(Color.BLACK);
out.writeObject(new Data(1, "one"));
out.writeObject(new Integer(1));
System.out.println(in.readObject());
System.out.println(Arrays.toString((int[]) (in.readObject())));
System.out.println((Color) in.readObject());
Data data = (Data) in.readObject();
System.out.println(data);
System.out.println(in.readObject());
enum Color
BLACK, RED
class Data implements Serializable
int x;
String s;
public Data(int x, String s)
this.x = x;
this.s = s;
@Override
public String toString()
return x + " " + s;
/* 结果:hello world
[1, 2, 3]
BLACK
1 one
1
*/
递归序列化
- 当某个对象进行序列化的时候,系统会自动把该对象的所有Field依次进行序列化
- 如果某个Field引用到另一个对象,则被引用的对象也会被序列化
- 如果被引用的对象的Field也引用了其它对象,则被引用的对象也会被序列化。可序列化的类的成员变量也必须是可序列化的,否则在序列化过程中抛出异常
public class Demo
public static void main(String[] args) throws Exception
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("tempFile"));
ObjectInputStream in = new ObjectInputStream(new FileInputStream("tempFile"));
out.writeObject(new Data(1, "one"));
Data data = (Data) in.readObject();
System.out.println(data);
class Data implements Serializable
int x;
String s;
SubData subdata = new SubData(1);
public Data(int x, String s)
this.x = x;
this.s = s;
@Override
public String toString()
return x + " " + s + subdata.x;
class SubData
int x;
public SubData(int x)
this.x = x;
定制序列化
在序列化过程中,如果被序列化的类中定义了writeObject 和 readObject 方法,虚拟机会试图调用对象类里的 writeObject 和 readObject 方法,进行用户自定义的序列化和反序列化。如果没有这样的方法,则默认调用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程,比如可以在序列化的过程中动态改变序列化的数值。
实例 ArrayList的序列化
- ArrayList实现了Serializable接口默认会将类中所有对象都出到输出流中去
- ArrayList用来保存元素的数组被声明为transient,也就是不会被序列化
- ArrayList重写了writeObject与ReadObject方法,对于数组元素,只输出实例元素,不会输出因为扩容而导致的数组末尾的null值,提高了序列化的效率
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// Write out size as capacity for behavioural compatibility with clone()
s.writeInt(size);
// Write out all elements in the proper order.
for (int i=0; i<size; i++)
s.writeObject(elementData[i]);
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException
elementData = EMPTY_ELEMENTDATA;
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in capacity
s.readInt(); // ignored
if (size > 0)
// be like clone(), allocate array based upon size not capacity
ensureCapacityInternal(size);
Object[] a = elementData;
// Read in all elements in the proper order.
for (int i=0; i<size; i++)
a[i] = s.readObject();
替换序列化对象
wirteReplace():只要该方法存在,由序列化机制调用,在序列化对象时将该对象替换成其它对象;
public class Person4 implements Serializable
private String name;
private int age;
public Person4(String name, int age)
super();
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;
private Object writeReplace() throws ObjectStreamException
ArrayList<Object> list = new ArrayList<Object>();
list.add(name);
list.add(age);
return list;
public static void main(String[] args)
try
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("replace.txt"));
ObjectInputStream ooi = new ObjectInputStream(new FileInputStream("replace.txt"));
Person4 per = new Person4("孙悟空", 500);
// 系统将per对象转换成字节序列并输出
oos.writeObject(per);
// 反序列化读取得到的是ArrayList
ArrayList list = (ArrayList) ooi.readObject();
System.out.println(list.toString());
catch (FileNotFoundException e)
e.printStackTrace();
catch (IOException e)
e.printStackTrace();
catch (ClassNotFoundException e)
e.printStackTrace();
序列化机制深入分析
- 首先序列化与反序列化是通过ObjectOutputStream和ObjectInputStream的writeObject和readObject方法实现的
- Serializable是一个空的标志接口,序列化的机制在于ObjectOutputStream的writeObject方法中,下面的代码可以看出可序列化的类型包含String,数组,枚举,以及实现了Serializable的类
if (obj instanceof String)
writeString((String) obj, unshared);
else if (cl.isArray())
writeArray(obj, desc, unshared);
else if (obj instanceof Enum)
writeEnum((Enum) obj, desc, unshared);
else if (obj instanceof Serializable)
writeOrdinaryObject(obj, desc, unshared);
else
if (extendedDebugInfo)
throw new NotSerializableException(
cl.getName() + "\\n" + debugInfoStack.toString());
else
throw new NotSerializableException(cl.getName());
- 实现了Serializable接口的类的序列化的方法调用过程
writeObject ---> writeObject0 --->writeOrdinaryObject--->writeSerialData
- 序列化类中存在WriteObject方法时,writeSerialData方法会通过反射机制来调用WriteObject方法
if (slotDesc.hasWriteObjectMethod())
...
slotDesc.invokeWriteObject(obj, this);
serialVersonUID
序列化版本兼容
反序列化Java对象时,必须提供该对象的class文件,随着项目的升级,系统的class文件也会升级。如果保持两个class文件兼容性:
- Java的序列化机制允许为序列化类提供一个private static final的serialVersonUID值,该Field值用于标识该Java类的序列化版本;
- 最好在每个要序列化的类中加入private static final long serialVersionUID这个Field,具体数值自己定义。这样,即使对象被序列化之后,它所对应的类修改了,该对象也依然可以被正确反序列化;
如果不显示定义serialVersionUID值:
- 该Field值将由JVM根据类的相关信息计算,而修改后的类计算结果与修改前的类计算结果往往不同,从而造成对象的反序列化因为类版本的不兼容失败;
- 不利于程序在不同的JVM之间移植,因为不同的编译器计算该Field的值计算策略可能不同,从而造成虽然类完全没有改变,但是因为JVM不同,也会出现序列化版本不兼容而无法正确反序列化的现象;
多次序列化同一对象
- 当程序视图序列化一个对象时,程序将先检查该对象是否已经被序列化过,只有该对象从未(在本次虚拟机)中序列化过,系统才会将该对象转换成字节序列并输出;
- 如果某个对象已经序列化过,程序将只是直接输出一个序列化编号,而不是再次重新序列化该对象,因此当重复序列化同一个对象时即便变量域已经改变,反序列化时还是只会保存第一个序列化对象的状态
```java
public class SerializaMutable
public static void main(String[] args)
try
// 创建一个ObjectOutputStream对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("mutable.txt"));
// 创建一个ObjectInputStream对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("mutable.txt"));
Person per = new Person("孙悟空", 500);
// 系统将per对象转换成字节序列并输出
oos.writeObject(per);
per.setName("猪八戒");
// 系统只是输出序列化编号,所以改变后的name不会被序列化
oos.writeObject(per);
Person p1 = (Person) ois.readObject();
Person p2 = (Person) ois.readObject();
// 下面输出true,即反序列化后p1等于p2
System.out.println(p1 == p2);
// 下面依然看到输出“孙悟空”,即改变后的Field没有被序列化
System.out.println(p2.getName());
catch (FileNotFoundException e)
e.printStackTrace();
catch (IOException e)
e.printStackTrace();
catch (ClassNotFoundException e)
e.printStackTrace();
class Person implements Serializable
String name;
int age;
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;
/*
结果:
true
孙悟空
*/
<div class="se-preview-section-delimiter"></div>
Externalizable 序列化机制
- 自定义序列化的成员变量
- void readExternal(ObjectInput in):实现反序列化,调用DataInput(ObjectInput的父接口)的方法来恢复基本类型的Field值,调用ObjectInput的readObject()方法来恢复引用类型的Field值;
- void writeExternal(ObjectOutput out):实现序列化,调用DataOutput(ObjectOutput的父接口)的方法来保存基本类型的Field值,调用ObjectOutput的writeObject()方法来保存引用类型的Field值;
public class Person5 implements Externalizable
private String name;
private int age;
// 必须提供无参数的构造函数,否则报java.io.InvalidClassException
public Person5()
super();
// 注意此处没有提供无参数的构造器
public Person5(String name, int age)
super();
System.out.println("有参数的构造器");
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;
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
// 将去读的字符串反转后赋值给name Field
this.name = ((StringBuffer) in.readObject()).reverse().toString();
this.age = in.readInt();
@Override
public void writeExternal(ObjectOutput out) throws IOException
// 将name Field值反转后写入二进制流
out.writeObject(new StringBuffer(name).reverse());
out.writeInt(age);
public static void main(String[] args)
try
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("external.txt"));
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("external.txt"));
Person5 per = new Person5("孙悟空", 500);
oos.writeObject(per);
Person5 p = (Person5) ois.readObject();
System.out.println(p.getName() + ":" + p.getAge());
catch (FileNotFoundException e)
e.printStackTrace();
catch (IOException e)
e.printStackTrace();
catch (ClassNotFoundException e)
e.printStackTrace();
序列化机制对比
- 实现Serializable接口:
- 系统自动存储必要的信息;
- Java内建支持,抑郁实现,只需要实现该接口即可,无需任何代码支持;
性能略差;
- 实现Externalizable接口:
- 程序员决定存储那些信息;
- 仅仅提供两个空方法,实现该接口必须为两个空方法提供实现;
- 性能略好
以上是关于java 序列化机制深度解析的主要内容,如果未能解决你的问题,请参考以下文章