概要
- 序列化机制允许将实现序列化的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接口：
- 程序员决定存储那些信息；
- 仅仅提供两个空方法，实现该接口必须为两个空方法提供实现；
- 性能略好
- 顶
- 0
- 踩
- 0