标签：本质 nod 标记接口 throw 通过 比较 数据交换 null blog
在前面几节，我们在将对象保存到文件时，使用的是DataOutputStream，从文件读入对象时，使用的是DataInputStream， 使用它们，需要逐个处理对象中的每个字段，我们提到，这种方式比较啰嗦，Java中有一种更为简单的机制，那就是序列化。
简单来说，序列化就是将对象转化为字节流，反序列化就是将字节流转化为对象。在Java中，具体如何来使用呢？它是如何实现的？有什么优缺点？本节就来探讨这些问题，我们先从它的基本用法谈起。
基本用法
Serializable
要让一个类支持序列化，只需要让这个类实现接口java.io.Serializable，Serializable没有定义任何方法，只是一个标记接口。比如，对于57节提到的Student类，为支持序列化，可改为：
public class Student implements Serializable { String name; int age; double score; public Student(String name, int age, double score) { ... } ... }
声明实现了Serializable接口后，保存/读取Student对象就可以使用另两个流了ObjectOutputStream/ObjectInputStream。
ObjectOutputStream/ObjectInputStream
ObjectOutputStream是OutputStream的子类，但实现了ObjectOutput接口，ObjectOutput是DataOutput的子接口，增加了一个方法：
public void writeObject(Object obj) throws IOException
这个方法能够将对象obj转化为字节，写到流中。
ObjectInputStream是InputStream的子类，它实现了ObjectInput接口，ObjectInput是DataInput的子接口，增加了一个方法：
public Object readObject() throws ClassNotFoundException, IOException
这个方法能够从流中读取字节，转化为一个对象。
使用这两个流，57节介绍的保存学生列表的代码就可以变为：
public static void writeStudents(List<Student> students) throws IOException { ObjectOutputStream out = new ObjectOutputStream( new BufferedOutputStream(new FileOutputStream("students.dat"))); try { out.writeInt(students.size()); for (Student s : students) { out.writeObject(s); } } finally { out.close(); } }
而从文件中读入学生列表的代码可以变为：
public static List<Student> readStudents() throws IOException, ClassNotFoundException { ObjectInputStream in = new ObjectInputStream(new BufferedInputStream( new FileInputStream("students.dat"))); try { int size = in.readInt(); List<Student> list = new ArrayList<>(size); for (int i = 0; i < size; i++) { list.add((Student) in.readObject()); } return list; } finally { in.close(); } }
实际上，只要List对象也实现了Serializable (ArrayList/LinkedList都实现了)，上面代码还可以进一步简化，读写只需要一行代码，如下所示：
public static void writeStudents(List<Student> students) throws IOException { ObjectOutputStream out = new ObjectOutputStream( new BufferedOutputStream(new FileOutputStream("students.dat"))); try { out.writeObject(students); } finally { out.close(); } } public static List<Student> readStudents() throws IOException, ClassNotFoundException { ObjectInputStream in = new ObjectInputStream(new BufferedInputStream( new FileInputStream("students.dat"))); try { return (List<Student>) in.readObject(); } finally { in.close(); } }
是不是很神奇？只要将类声明实现Serializable接口，然后就可以使用ObjectOutputStream/ObjectInputStream直接读写对象了。我们之前介绍的各种类，如String, Date, Double, ArrayList, LinkedList, HashMap, TreeMap等，都实现了Serializable。
复杂对象
上面例子中的Student对象是非常简单的，如果对象比较复杂呢？比如：
我们分别来看下。
引用同一个对象
我们看个简单的例子，类A和类B都引用了同一个类Common，它们都实现了Serializable，这三个类的定义如下：
class Common implements Serializable { String c; public Common(String c) { this.c = c; } } class A implements Serializable { String a; Common common; public A(String a, Common common) { this.a = a; this.common = common; } public Common getCommon() { return common; } } class B implements Serializable { String b; Common common; public B(String b, Common common) { this.b = b; this.common = common; } public Common getCommon() { return common; } }
有三个对象, a, b, c，如下所示：
Common c = new Common("common"); A a = new A("a", c); B b = new B("b", c);
a和b引用同一个对象c，如果序列化这两个对象，反序列化后，它们还能指向同一个对象吗？答案是肯定的，我们看个实验。
ByteArrayOutputStream bout = new ByteArrayOutputStream(); ObjectOutputStream out = new ObjectOutputStream(bout); out.writeObject(a); out.writeObject(b); out.close(); ObjectInputStream in = new ObjectInputStream( new ByteArrayInputStream(bout.toByteArray())); A a2 = (A) in.readObject(); B b2 = (B) in.readObject(); if (a2.getCommon() == b2.getCommon()) { System.out.println("reference the same object"); } else { System.out.println("reference different objects"); }
输出为：
reference the same object
这也是Java序列化机制的神奇之处，它能自动处理这种引用同一个对象的情况。更神奇的是，它还能自动处理循环引用的情况，我们来看下。
循环引用
我们看个例子，有Parent和Child两个类，它们相互引用，类定义如下：
class Parent implements Serializable { String name; Child child; public Parent(String name) { this.name = name; } public Child getChild() { return child; } public void setChild(Child child) { this.child = child; } } class Child implements Serializable { String name; Parent parent; public Child(String name) { this.name = name; } public Parent getParent() { return parent; } public void setParent(Parent parent) { this.parent = parent; } }
定义两个对象：
Parent parent = new Parent("老马"); Child child = new Child("小马"); parent.setChild(child); child.setParent(parent);
序列化parent, child两个对象，Java能正确序列化吗？反序列化后，还能保持原来的引用关系吗？答案是肯定的，我们看代码实验：
ByteArrayOutputStream bout = new ByteArrayOutputStream(); ObjectOutputStream out = new ObjectOutputStream(bout); out.writeObject(parent); out.writeObject(child); out.close(); ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream( bout.toByteArray())); parent = (Parent) in.readObject(); child = (Child) in.readObject(); if (parent.getChild() == child && child.getParent() == parent && parent.getChild().getParent() == parent && child.getParent().getChild() == child) { System.out.println("reference OK"); } else { System.out.println("wrong reference"); }
输出为：
reference OK
神奇吧？
定制序列化
默认的序列化机制已经很强大了，它可以自动将对象中的所有字段自动保存和恢复，但这种默认行为有时候不是我们想要的。
比如，对于有些字段，它的值可能与内存位置有关，比如默认的hashCode()方法的返回值，当恢复对象后，内存位置肯定变了，基于原内存位置的值也就没有了意义。还有一些字段，可能与当前时间有关，比如表示对象创建时的时间，保存和恢复这个字段就是不正确的。
还有一些情况，如果类中的字段表示的是类的实现细节，而非逻辑信息，那默认序列化也是不适合的。为什么不适合呢？因为序列化格式表示一种契约，应该描述类的逻辑结构，而非与实现细节相绑定，绑定实现细节将使得难以修改，破坏封装。
比如，我们在容器类中介绍的LinkedList，它的默认序列化就是不适合的，为什么呢？因为LinkedList表示一个List，它的逻辑信息是列表的长度，以及列表中的每个对象，但LinkedList类中的字段表示的是链表的实现细节，如头尾节点指针，对每个节点，还有前驱和后继节点指针等。
那怎么办呢？Java提供了多种定制序列化的机制，主要的有两种，一种是transient关键字，另外一种是实现writeObject和readObject方法。
将字段声明为transient，默认序列化机制将忽略该字段，不会进行保存和恢复。比如，类LinkedList中，它的字段都声明为了transient，如下所示：
transient int size = 0; transient Node<E> first; transient Node<E> last;
声明为了transient，不是说就不保存该字段了，而是告诉Java默认序列化机制，不要自动保存该字段了，可以实现writeObject/readObject方法来自己保存该字段。
类可以实现writeObject方法，以自定义该类对象的序列化过程，其声明必须为：
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException
可以在这个方法中，调用ObjectOutputStream的方法向流中写入对象的数据。比如，LinkedList使用如下代码序列化列表的逻辑数据：
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException { // Write out any hidden serialization magic s.defaultWriteObject(); // Write out size s.writeInt(size); // Write out all elements in the proper order. for (Node<E> x = first; x != null; x = x.next) s.writeObject(x.item); }
需要注意的是第一行代码：
s.defaultWriteObject();
这一行是必须的，它会调用默认的序列化机制，默认机制会保存所有没声明为transient的字段，即使类中的所有字段都是transient，也应该写这一行，因为Java的序列化机制不仅会保存纯粹的数据信息，还会保存一些元数据描述等隐藏信息，这些隐藏的信息是序列化之所以能够神奇的重要原因。
与writeObject对应的是readObject方法，通过它自定义反序列化过程，其声明必须为：
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException
在这个方法中，调用ObjectInputStream的方法从流中读入数据，然后初始化类中的成员变量。比如，LinkedList的反序列化代码为：
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { // Read in any hidden serialization magic s.defaultReadObject(); // Read in size int size = s.readInt(); // Read in all elements in the proper order. for (int i = 0; i < size; i++) linkLast((E)s.readObject()); }
注意第一行代码：
s.defaultReadObject();
这一行代码也是必须的。
序列化的基本原理
稍微总结一下：
但，序列化到底是如何发生的呢？关键在ObjectOutputStream的writeObject和ObjectInputStream的readObject方法内。它们的实现都非常复杂，正因为这些复杂的实现才使得序列化看上去很神奇，我们简单介绍下其基本逻辑。
writeObject的基本逻辑是：
readObject的基本逻辑是：
版本问题
上面的介绍，我们忽略了一个问题，那就是版本问题。我们知道，代码是在不断演化的，而序列化的对象可能是持久保存在文件上的，如果类的定义发生了变化，那持久化的对象还能反序列化吗？
默认情况下，Java会给类定义一个版本号，这个版本号是根据类中一系列的信息自动生成的。在反序列化时，如果类的定义发生了变化，版本号就会变化，与流中的版本号就会不匹配，反序列化就会抛出异常，类型为java.io.InvalidClassException。
通常情况下，我们希望自定义这个版本号，而非让Java自动生成，一方面是为了更好的控制，另一方面是为了性能，因为Java自动生成的性能比较低，怎么自定义呢？在类中定义如下变量：
private static final long serialVersionUID = 1L;
在Java IDE如Eclipse中，如果声明实现了Serializable而没有定义该变量，IDE会提示自动生成。这个变量的值可以是任意的，代表该类的版本号。在序列化时，会将该值写入流，在反序列化时，会将流中的值与类定义中的值进行比较，如果不匹配，会抛出InvalidClassException。
那如果版本号一样，但实际的字段不匹配呢？Java会分情况自动进行处理，以尽量保持兼容性，大概分为三种情况：
高级自定义
除了自定义writeObject/readObject方法，Java中还有如下自定义序列化过程的机制：
这些机制实际用到的比较少，我们简要说明下。
Externalizable是Serializable的子接口，定义了如下方法：
void writeExternal(ObjectOutput out) throws IOException void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
与writeObject/readObject的区别是，如果对象实现了Externalizable接口，则序列化过程会由这两个方法控制，默认序列化机制中的反射等将不再起作用，不再有类似defaultWriteObject和defaultReadObject调用，另一个区别是，反序列化时，会先调用类的无参构造方法创建对象，然后才调用readExternal。默认的序列化机制由于需要分析对象结构，往往比较慢，通过实现Externalizable接口，可以提高性能。
readResolve方法返回一个对象，声明为：
Object readResolve()
如果定义了该方法，在反序列化之后，会额外调用该方法，该方法的返回值才会被当做真正的反序列化的结果。这个方法通常用于反序列化单例对象的场景。
writeReplace也是返回一个对象，声明为：
Object writeReplace()
如果定义了该方法，在序列化时，会先调用该方法，该方法的返回值才会被当做真正的对象进行序列化。
writeReplace和readResolve可以构成一种所谓的序列化代理模式，这个模式描述在<Effective Java> 第二版78条中，Java容器类中的EnumSet使用了该模式，我们一般用的比较少，就不详细介绍了。
序列化特点分析
序列化的主要用途有两个，一个是对象持久化，另一个是跨网络的数据交换、远程过程调用。
Java标准的序列化机制有很多优点，使用简单，可自动处理对象引用和循环引用，也可以方便的进行定制，处理版本问题等，但它也有一些重要的局限性：
由于这些局限性，实践中往往会使用一些替代方案。在跨语言的数据交换格式中，XML/JSON是被广泛采用的文本格式，各种语言都有对它们的支持，文件格式清晰易读，有很多查看和编辑工具，它们的不足之处是性能和序列化大小，在性能和大小敏感的领域，往往会采用更为精简高效的二进制方式如ProtoBuf, Thrift, MessagePack等。
小结
本节介绍了Java的标准序列化机制，我们介绍了它的用法和基本原理，最后分析了它的特点，它是一种神奇的机制，通过简单的Serializable接口就能自动处理很多复杂的事情，但它也有一些重要的限制，最重要的是不能跨语言。
在接来下的几节中，我们来看一些替代方案，包括XML/JSON和MessagePack。
----------------
未完待续，查看最新文章，敬请关注微信公众号“老马说编程”(扫描下方二维码)，从入门到高级，深入浅出，老马和你一起探索Java编程及计算机技术的本质。用心原创，保留所有版权。
标签：本质 nod 标记接口 throw 通过 比较 数据交换 null blog
原文地址：http://www.cnblogs.com/swiftma/p/6227273.html
