Java序列化的原理

转自：http://jianleixing.iteye.com/blog/2015495

Java序列化的原理

前沿 
欢迎进入JDK源码阅读之序列化专题！java序列化从JDK1.1版本就开始，是一项比较成熟的技术。对于初学者可能很容易就能学会如何编写序列化类，但是对其详细的原理以及一些细节上的技术了解还是比较少的。本专题将分三个部分从JDK源代码的角度向大家介绍java序列化相关的知识： 
    Part1：对序列化协议做出比较深入的探讨，最后总结出序列化的基本算法； 
    Part2：了解自定义序列化的方法及其原理，理解其在安全方面的重要作用； 
    Part3：了解java序列化的可重构性，有利于软件的可扩宽性。 
基本概念 
对象的序列化（Object serialization）机制,就是将对象编码成一个字节流(序列化serialization)，以及从字节流编码中重新构建对象(反序列化deserialization)的过程。一旦将对象序列化后，一方面可以将其持久化到磁盘上，供以后反序列化使用；另一方面在分布式环境中经常将对象从这一端网络传递到另一端，需要一种在两端传输数据的协议，而java序列化机制就提供了这种协议的实现。 
如何序列化一个对象 
一个对象如果想实现序列化只需实现java.io.Serializable接口，该接口没有方法，只是一种标记。JDK中源代码如下： 
java.io.ObjectOutputStream.writeObject() 
└java.io.ObjectOutputStream.writeObject0(); 
--------------------------------------------------------------------- 
1085 private void writeObject0(Object obj, boolean unshared) 
1086 throws IOException 
-中略- 
      //判断该类是否实现了java.io.Serializable接口 
1157 } else if (obj instanceof Serializable) { 
1158 writeOrdinaryObject(obj, desc, unshared); 
1159 } else { 
1160 if (extendedDebugInfo) { 
1161     throw new NotSerializableException( 
1162 cl.getName() + "\n" + debugInfoStack.toString()); 
1163 } else { 
1164     throw new NotSerializableException(cl.getName()); 
1165 } 
1166 } 
-中略- 
--------------------------------------------------------------------- 
由程序的1157行可知如果序列化了未实现Serializable接口的对象，将会抛出NotSerializableException（1164行）异常，说明该类不具有序列化。现在我们根据具体的实例来说明序列化的基本原理。 

假设我们创建一个实现Serializable接口的Fruit水果类，其中包含了一个int类型weight重量属性；同时创建了继承自该类的Apple苹果子类，其中包含有一个String类型的name名称属性。 
Fruit.java 如下： 
--------------------------------------------------------------------- 
package com.fnst.infoQ; 

public class Fruit implements Serializable{ 
private int weight; 
public Fruit() {this.weight = 10;} 
} 
--------------------------------------------------------------------- 
Apple.java 如下： 
--------------------------------------------------------------------- 
package com.fnst.infoQ; 

public class Apple extends Fruit{ 
    private String name; 
    public Apple(String _name){this.name = _name;} 
    public Apple() {this.name = "Default Apple";} 

public static void main(String args[]) throws IOException {  
    FileOutputStream fos = new FileOutputStream("a.txt");  
    ObjectOutputStream oos = new ObjectOutputStream(fos);  
    Apple apple = new Apple();  
    oos.writeObject(apple);  
    oos.flush();  
    oos.close();  
}  
} 
--------------------------------------------------------------------- 
执行程序后，Apple对象序列化到a.txt文件中，其中内容如下： 
--------------------------------------------------------------------- 
AC ED 00 05 73 72 00 14 63 6F 6D 2E 66 6E 73 74 
2E 69 6E 66 6F 51 2E 41 70 70 6C 65 55 D6 C7 F2 
12 79 30 B5 02 00 01 4C 00 04 6E 61 6D 65 74 00 
12 4C 6A 61 76 61 2F 6C 61 6E 67 2F 53 74 72 69 
6E 67 3B 78 72 00 14 63 6F 6D 2E 66 6E 73 74 2E 
69 6E 66 6F 51 2E 46 72 75 69 74 64 79 B9 B9 16 
D6 47 FB 02 00 01 49 00 06 77 65 69 67 68 74 78 
70 00 00 00 0A 74 00 0D 44 65 66 61 75 6C 74 20 
41 70 70 6C 65 
--------------------------------------------------------------------- 
Java序列化序列化对象的信息包括：类元数据描述、类的属性、父类信息以及属性域的值。Java将这些信息分成3部分：序列化头信息、类的描述部分以及属性域的值部分。现在对a.txt文件加以分析，其中包含一些序列化机制中提供的特殊字段，这些字段被定义在java.io.ObjectStreamConstants接口中。 

第一部分 序列化头信息（见颜色） 
[1]. 0xAC 0xED ：STREAM_MAGIC 流的幻数，用于标记序列化协议 
[2]. 0x00 0x05 ：STREAM_VERSION 标记序列化协议的版本 
以上两行信息在ObjectOutputStream类对象构造时就被写入到了序列化缓冲区中，代码如下； 
java.io.ObjectOutputStream() 【构造函数】 
└java.io.ObjectOutputStream.writeStreamHeader 
--------------------------------------------------------------------- 
615 protected void writeStreamHeader() throws IOException { 
616 bout.writeShort(STREAM_MAGIC); //将流的幻数写入流缓冲区，步骤1 
617     bout.writeShort(STREAM_VERSION);//将序列化协议写入流缓冲区，步骤2 
618 } 
--------------------------------------------------------------------- 
ObjectOutputStream的构造函数中会调用writeStreamHeader方法，将序列化的头信息写入到流缓冲区中。 
第二部分 类的描述部分（见颜色） 
//首先是父类描述部分 
[3]. 0x73  ： TC_OBJECT. 声明这是一个新的对象. 
[4]. 0x72  ： TC_CLASSDESC 声明这是一个新的类描述 
[5]. 0x00 0x14 ：类名字的长度,换算成十进制就是20 
[6]. 0x63 0x6F 0x6D 0x2E 0x66 0x6E 0x73 0x74 0x2E 0x69 0x6E 0x66 0x6F 0x51 
0x2E 0x41 0x70 0x70 0x6C 0x65 ：代表类的名称com.fnst.InfoQ.Apple 
[7]. 0x55 0xD6 0xC7 0xF2 0x12 0x79 0x30 0xB5 : 序列化ID的类型为long型因此占用8个字节 
[8]. 0x02 ：标记号，该字节的8位分表代表不同的含义， 
SC_EXTERNALIZABLE 0x04 : 该类实现了java.io.Externalizable接口 
SC_BLOCK_DATA 0x08 : Externalizable接口的writeExternal方法写入的数据SC_SERIALIZABLE 0x02 : 该类实现了java.io.Serializable接口SC_WRITE_METHOD 0x01 : 该序列化类实现了writeObject方法 
SC_ENUM 0x10 : 该类是枚举（enum）类型 
该标记号通过上述信息进行或运算（|）而获得。 
[9]. 0x00 0x01 ： 代表类属性域的个数 
[10].0x4C ： 域类型，0x4C代表L即该域类型为java对象类型 
[11].0x00 0x04 ： 域名称长度 
[12].0x6E 0x61 0x6D 0x65 ：域名称name 
//如果域不是基本类型，则用一个字符串表示其域的类型 
[13].0x74 : TC_STRING 一个新字符串 
[14].0x00 0x12 ：域类型的长度 
[15].0x4C 0x6A 0x61 0x76 0x61 0x2F 0x6C 0x61 0x6E 0x67 0x2F 0x53 0x74 0x72 0x69 0x6E 0x67 0x3B ：对象类型签名Ljava.lang.String; 
[16].0x78 ： TC_ENDBLOCKDATA 对象数据块结束标志 
//其次是父类描述部分 
[17].0x72 : TC_CLASSDESC 声明这是一个新的类描述 
[18].0x00 0x14 : 类名长度，换算成十进制就是20 
[19].0x63 0x6F 0x6D 0x2E 0x66 0x6E 0x73 0x74 0x2E 0x69 0x6E 0x66 0x6F 0x51 0x2E 0x46 0x72 0x75 0x69 0x74 ：类权限定名com.fnst.InfoQ.Fruit 
[20].0x64 0x79 0xB9 0xB9 0x16 0xD6 0x47 0xFB : 序列化ID 
[21].0x02 ： 标记号 
[22].0x00 0x01 ： 域个数 
[23].0x49 : 域类型，0x49代表I即int类型 
[24].0x00 0x06 ： 域名称长度 
[25].0x77 0x65 0x69 0x67 0x68 0x74 : 域名称weight 
[26].0x78 ： TC_ENDBLOCKDATA 对象数据块结束标志 
[27].0x70 ： TC_NULL 再没有父类的标志 
以上信息的写入由java.io.FileOutputStream的writeObject方法完成，代码的调用关系如下： 
java.io.FileOutputStream.writeObject () 
└java.io.FileOutputStream.writeObject0() 
  └java.io.FileOutputStream.writeOrdinaryObject() 
    └java.io.FileOutputStream.writeClassDesc() 
      └java.io.FileOutputStream.writeNonProxyDesc() 
        └java.io.writeClassDescriptor() 
          └java.io.ObjectStreamClass. writeNonProxy() 
java.io.FileOutputStream.writeOrdinaryObject()方法 
--------------------------------------------------------------------- 
1381 private void writeOrdinaryObject(Object obj, 
1382      ObjectStreamClass desc, 
1383      boolean unshared) 
-中略- 
1394 bout.writeByte(TC_OBJECT);//写入流缓冲区中一个新对象的开始标志，步骤[3] 
1395 writeClassDesc(desc, false);//写入流缓冲区中该对象的类描述信息 
-中略- 
1340 writeSerialData(obj, desc);//写入类对象各个域（包括父类的域）的值 
-中略- 
--------------------------------------------------------------------- 

java.io.FileOutputStream.writeNonProxyDesc()方法 
--------------------------------------------------------------------- 
1243 private void writeNonProxyDesc(ObjectStreamClass desc, boolean unshared) 
1244 throws IOException 
1245 { 
1246   bout.writeByte(TC_CLASSDESC);//写入流缓冲区一个新类描述，步骤[4] 
1247   handles.assign(unshared ? null : desc); 
-中略- 
      //判断使用的序列化版本协议。 
1249 if (protocol == PROTOCOL_VERSION_1) { 
1250   // do not invoke class descriptor write hook with old protocol 
1251   desc.writeNonProxy(this); 
1252 } else { 
1253    writeClassDescriptor(desc);//写入该类的描述信息 
1254 } 
-中略- 
      //写入流缓冲区对象数据块结束标志，步骤[16] 
1260 bout.writeByte(TC_ENDBLOCKDATA); 
1261 
      //递归写入该类父类的类描述信息 
1262 writeClassDesc(desc.getSuperDesc(), false); 
--------------------------------------------------------------------- 

java.io.ObjectStreamClass. writeNonProxy()方法 
--------------------------------------------------------------------- 
665 void writeNonProxy(ObjectOutputStream out) throws IOException { 
666 out.writeUTF(name); //写入类名称的长度域内容，步骤[5],[6] 
667 out.writeLong(getSerialVersionUID());//写入类的序列化ID，步骤[7] 
668 
669 byte flags = 0;//flags 即为要写入的标记位 
     //该类是否实现了java.io.Externalizable接口 
670 if (externalizable) { 
671     flags |= ObjectStreamConstants.SC_EXTERNALIZABLE; 
672     int protocol = out.getProtocolVersion(); 
673     if (protocol != ObjectStreamConstants.PROTOCOL_VERSION_1) { 
674    flags |= ObjectStreamConstants.SC_BLOCK_DATA; 
675     } 
     //该类是否实现了java.io.Serializable 
676 } else if (serializable) { 
677     flags |= ObjectStreamConstants.SC_SERIALIZABLE; 
678 } 
     //该类实现了writeObject方法 
679 if (hasWriteObjectData) { 
680     flags |= ObjectStreamConstants.SC_WRITE_METHOD; 
681 } 
     //该类为枚举类型 
682 if (isEnum) { 
683     flags |= ObjectStreamConstants.SC_ENUM; 
684 } 
685 out.writeByte(flags);//写入流缓冲区标记位，步骤[8] 
686 
687 out.writeShort(fields.length);//写入域个数，步骤[9] 
688 for (int i = 0; i < fields.length; i++) { 
689     ObjectStreamField f = fields[i]; 
690     out.writeByte(f.getTypeCode());//写入该域类型编码，步骤[10] 
691     out.writeUTF(f.getName());//写入该域的名称长度域内容，步骤[11],[12] 
//判断该域类型是否是基本类型，如果该类型前面是以” L”开头的则代表是java类对象，、//如果以”[”开头则代表是数组，否则该域类型为java基本类型 
692     if (!f.isPrimitive()) { 
         //将java对象类型签名或者数组类型签名写入流中 
693    out.writeTypeString(f.getTypeString()); 
694     } 
695 } 
696} 
--------------------------------------------------------------------- 
第三部分 属性域的值部分（见颜色） 
//按照从父类到子类的顺序写入域的值 
[28].0x00 0x00 0x00 0x0A : 父类域weight的值为10 
[29].0x74 ：TC_STRING 一个新字符串 
[30].0x00 0x0D ：域值的长度，十进制为13 
[31].0x44 0x65 0x66 0x61 0x75 0x6C 0x74 0x20 0x41 0x70 0x70 0x6C 0x65 ： 域值DefaultApple。域值的写入由上述代码1340行的 writeSerialData函数写入，而该函数的核心在java.io.ObjcetOutputStream.defaultWriteFields中定义，代码如下： 
--------------------------------------------------------------------- 
1493 private void defaultWriteFields(Object obj, ObjectStreamClass desc) 
1494 throws IOException 
1495     { 
1496 // REMIND: perform conservative isInstance check here? 
1497 desc.checkDefaultSerialize(); 
1498 
1499 int primDataSize = desc.getPrimDataSize();//获取基本类型的域的个数 
      //创建存储基本类型域值的字节数组 
1500 if (primVals == null || primVals.length < primDataSize) { 
1501     primVals = new byte[primDataSize]; 
1502 } 
1503 desc.getPrimFieldValues(obj, primVals);//获取基本类型域的值 
1504 bout.write(primVals, 0, primDataSize, false);//将值写入流缓冲区中 
1505 
      //获取对象的所有域 
1506 ObjectStreamField[] fields = desc.getFields(false); 
      //创建存储Java对象类型的域数组 
1507 Object[] objVals = new Object[desc.getNumObjFields()]; 
      //序列化对象的基本类型域的个数 
1508 int numPrimFields = fields.length - objVals.length; 
      //获取序列化对象Java对象类型的域的值 
1509 desc.getObjFieldValues(obj, objVals); 
      //将Java对象类型的域写入到流缓冲区中 
1510 for (int i = 0; i < objVals.length; i++) { 
-中略- 
1517   try { 
        //将Java对象类型域递归写入序列化流缓冲区中，知道最后的域类型为java基本类型 
        //java.lang.String,枚举类型以及Class类型等 
1518 writeObject0(objVals[i], 
     fields[numPrimFields + i].isUnshared()); 
    } finally { 
-下略- 
--------------------------------------------------------------------- 
到此为止，我们对java序列化的原理有了一些基本的认识。通过源代码的阅读，我们总结java序列化算法的基本步骤： 
a) 输出序列化的头部信息，包括标识序列化协议的幻数以及协议的版本； 
b) 按照由子类到父类的顺序，递归的输出类的描述信息，直到不再有父类为止；类描述信息按照类元数据，类属性信息的顺序写入序列化流中； 
c) 按照由父类到子类的顺序，递归的输出对象域的实际数据值；而对象的属性信息是按照基本数据类型到java对象类型的顺序写入序列化流中；其中java对象类型的属性会从步骤a)重新开始递归的输出，直到不再存在java对象类型的属性。 
小结 
本文从JDK源代码的角度分析了java默认的序列化机制的基本原理，最后总结出了序列化的算法。但是这种序列化是不安全，因为序列化二进制格式完全编写在文档中或者在网络中传播，并且完全可逆。如果采用java默认序列化机制在网络上传输苹果的价格信息（商业机密），我们完全可以截获这些二进制数据按照上述规则获取苹果的价格。为了解决这一问题java提供了自定义的序列化的方法。下一篇中我们将介绍在序列化类中添加readObject和writeObject方法以及实现java.io.Externalizable接口实现自定义序列化的原理。 


-以上- 

2013年09月21日于南京 。