Java序列化机制和原理
Java序列化算法透析
Serialization(序列化)是一种将对象以一连串的字节描述的过程;反序列化deserialization是一种将这些字节重建成一个对象的过程。Java序列化API提供一种处理对象序列化的标准机制。在这里你能学到如何序列化一个对象,什么时候需要序列化以及Java序列化的算法,我们用一个实例来示范序列化以后的字节是如何描述一个对象的信息的。
序列化的必要性
Java中,一切都是对象,在分布式环境中经常需要将Object从这一端网络或设备传递到另一端。
这就需要有一种可以在两端传输数据的协议。Java序列化机制就是为了解决这个问题而产生。
如何序列化一个对象
一个对象能够序列化的前提是实现Serializable接口,Serializable接口没有方法,更像是个标记。
有了这个标记的Class就能被序列化机制处理。
import java.io.Serializable;
class TestSerial implements Serializable {
public byte version = 100;
public byte count = 0;
}
然后我们写个程序将对象序列化并输出。ObjectOutputStream能把Object输出成Byte流。
我们将Byte流暂时存储到temp.out文件里。
public static void main(String args[]) throws IOException {
FileOutputStream fos = new FileOutputStream("temp.out");
ObjectOutputStream oos = new ObjectOutputStream(fos);
TestSerial ts = new TestSerial();
oos.writeObject(ts);
oos.flush();
oos.close();
}
如果要从持久的文件中读取Bytes重建对象,我们可以使用ObjectInputStream。
public static void main(String args[]) throws IOException {
FileInputStream fis = new FileInputStream("temp.out");
ObjectInputStream oin = new ObjectInputStream(fis);
TestSerial ts = (TestSerial) oin.readObject();
System.out.println("version="+ts.version);
}
执行结果为 100.
对象的序列化格式
将一个对象序列化后是什么样子呢?打开刚才我们将对象序列化输出的temp.out文件
以16进制方式显示。内容应该如下:
AC ED 00 05 73 72 00 0A 53 65 72 69 61 6C 54 65 73 74 A0 0C 34 00 FE B1 DD F9 02 00 02 42 00 05 63 6F 75 6E 74 42 00 07 76 65 72 73 69 6F 6E 78 70 00 64
这一坨字节就是用来描述序列化以后的TestSerial对象的,我们注意到TestSerial类中只有两个域:
public byte version = 100;
public byte count = 0;
且都是byte型,理论上存储这两个域只需要2个byte,但是实际上temp.out占据空间为51bytes,也就是说除了数据以外,还包括了对序列化对象的其他描述
Java的序列化算法
序列化算法一般会按步骤做如下事情:
◆将对象实例相关的类元数据输出。
◆递归地输出类的超类描述直到不再有超类。
◆类元数据完了以后,开始从最顶层的超类开始输出对象实例的实际数据值。
◆从上至下递归输出实例的数据
我们用另一个更完整覆盖所有可能出现的情况的例子来说明:
class parent implements Serializable {
int parentVersion = 10;
}
class contain implements Serializable{
Int containVersion = 11;
}
public class SerialTest extends parent implements Serializable {
int version = 66;
contain con = new contain();
public int getVersion() {
return version;
}
public static void main(String args[]) throws IOException {
FileOutputStream fos = new FileOutputStream("temp.out");
ObjectOutputStream oos = new ObjectOutputStream(fos);
SerialTest st = new SerialTest();
oos.writeObject(st);
oos.flush();
oos.close();
}
}-
-
AC ED: STREAM_MAGIC. 声明使用了序列化协议 .
-
00 05: STREAM_VERSION. 序列化协议版本 .
-
0x73: TC_OBJECT. 声明这是一个新的对象 .
-
0x72: TC_CLASSDESC. 声明这里开始一个新 Class 。
-
00 0A: Class 名字的长度 .
-
53 65 72 69 61 6c 54 65 73 74: SerialTest,Class 类名 .
-
05 52 81 5A AC 66 02 F6: SerialVersionUID, 序列化 ID ,如果没有指定,
则会由算法随机生成一个 8byte 的 ID. -
0x02: 标记号 . 该值声明该对象支持序列化。
-
00 02: 该类所包含的域个数。
-
0x49: 域类型 . 49 代表 "I", 也就是 Int.
-
00 07: 域名字的长度 .
-
76 65 72 73 69 6F 6E: version, 域名字描述 .
-
0x4C: 域的类型 .
-
00 03: 域名字长度 .
-
63 6F 6E: 域名字描述, con
-
0x74: TC_STRING. 代表一个 new String. 用 String 来引用对象。
-
00 09: 该 String 长度 .
-
4C 63 6F 6E 74 61 69 6E 3B: Lcontain;, JVM 的标准对象签名表示法 .
-
0x78: TC_ENDBLOCKDATA, 对象数据块结束的标志
-
0x72: TC_CLASSDESC. 声明这个是个新类 .
-
00 06: 类名长度 .
-
70 61 72 65 6E 74: parent, 类名描述。
-
0E DB D2 BD 85 EE 63 7A: SerialVersionUID, 序列化 ID.
-
0x02: 标记号 . 该值声明该对象支持序列化 .
-
00 01: 类中域的个数 .
-
0x49: 域类型 . 49 代表 "I", 也就是 Int.
-
00 0D: 域名字长度 .
-
70 61 72 65 6E 74 56 65 72 73 69 6F 6E: parentVersion ,域名字描述。
-
0x78: TC_ENDBLOCKDATA, 对象块结束的标志。
-
0x70: TC_NULL, 说明没有其他超类的标志。 .
-
00 00 00 0A: 10, parentVersion 域的值 .
-
00 00 00 42: 66, version 域的值 .
-
0x73: TC_OBJECT, 声明这是一个新的对象 .
-
0x72: TC_CLASSDESC 声明这里开始一个新 Class.
-
00 07: 类名的长度 .
-
63 6F 6E 74 61 69 6E: contain, 类名描述 .
-
FC BB E6 0E FB CB 60 C7: SerialVersionUID, 序列化 ID.
-
0x02: Various flags. 标记号 . 该值声明该对象支持序列化
-
00 01: 类内的域个数。
-
0x49: 域类型 . 49 代表 "I", 也就是 Int..
-
00 0E: 域名字长度 .
-
63 6F 6E 74 61 69 6E 56 65 72 73 69 6F 6E: containVersion, 域名字描述 .
-
0x78: TC_ENDBLOCKDATA 对象块结束的标志 .
-
0x70:TC_NULL ,没有超类了。
-
00 00 00 0B: 11, containVersion 的值 .
这个例子是相当的直白啦。SerialTest类实现了Parent超类,内部还持有一个Container对象。
序列化后的格式如下:
AC ED 00 05 73 72 00 0A 53 65 72 69 61 6C 54 65
73 74 05 52 81 5A AC 66 02 F6 02 00 02 49 00 07
76 65 72 73 69 6F 6E 4C 00 03 63 6F 6E 74 00 09
4C 63 6F 6E 74 61 69 6E 3B 78 72 00 06 70 61 72
65 6E 74 0E DB D2 BD 85 EE 63 7A 02 00 01 49 00
0D 70 61 72 65 6E 74 56 65 72 73 69 6F 6E 78 70
00 00 00 0A 00 00 00 42 73 72 00 07 63 6F 6E 74
61 69 6E FC BB E6 0E FB CB 60 C7 02 00 01 49 00
0E 63 6F 6E 74 61 69 6E 56 65 72 73 69 6F 6E 78
70 00 00 00 0B
我们来仔细看看这些字节都代表了啥。开头部分,见颜色:
序列化算法的第一步就是输出对象相关类的描述。例子所示对象为SerialTest类实例,
因此接下来输出SerialTest类的描述。见颜色:接下来,算法输出其中的一个域,int version=66;见颜色:
然后,算法输出下一个域,contain con = new contain();这个有点特殊,是个对象。
描述对象类型引用时需要使用JVM的标准对象签名表示法,见颜色:.接下来算法就会输出超类也就是Parent类描述了,见颜色:
下一步,输出parent类的域描述,int parentVersion=100;同见颜色:
到此为止,算法已经对所有的类的描述都做了输出。下一步就是把实例对象的实际值输出了。这时候是从parent Class的域开始的,见颜色:
还有SerialTest类的域:
再往后的bytes比较有意思,算法需要描述contain类的信息,要记住,
现在还没有对contain类进行过描述,见颜色:.输出contain的唯一的域描述,int containVersion=11;
这时,序列化算法会检查contain是否有超类,如果有的话会接着输出。
最后,将contain类实际域值输出。
OK,我们讨论了java序列化的机制和原理,希望能对同学们有所帮助。
-
SerialTest st = new SerialTest();
oos.writeObject((parent)st);
对象序列化包括如下步骤:
1) 创建一个对象输出流,它可以包装一个其他类型的目标输出流,如文件输出流;
2) 通过对象输出流的writeObject()方法写对象。
对象反序列化的步骤如下:
1) 创建一个对象输入流,它可以包装一个其他类型的源输入流,如文件输入流;
2) 通过对象输入流的readObject()方法读取对象。
对象序列化和反序列范例:
定义一个Person类,实现Serializable接口
1 import java.io.Serializable;
10 public class Person implements Serializable {
11
12 /**
13 * 序列化ID
14 */
15 private static final long serialVersionUID = -5809782578272943999L;
16 private int age;
17 private String name;
18 private String sex;
19
20 public int getAge() {
21 return age;
22 }
23
24 public String getName() {
25 return name;
26 }
27
28 public String getSex() {
29 return sex;
30 }
31
32 public void setAge(int age) {
33 this.age = age;
34 }
35
36 public void setName(String name) {
37 this.name = name;
38 }
39
40 public void setSex(String sex) {
41 this.sex = sex;
42 }
43 }
序列化和反序列化Person类对象
1 import java.io.File;
2 import java.io.FileInputStream;
3 import java.io.FileNotFoundException;
4 import java.io.FileOutputStream;
5 import java.io.IOException;
6 import java.io.ObjectInputStream;
7 import java.io.ObjectOutputStream;
8 import java.text.MessageFormat;
9
10 /**
11 * <p>ClassName: TestObjSerializeAndDeserialize<p>
12 * <p>Description: 测试对象的序列化和反序列<p>
13 * @author xudp
14 * @version 1.0 V
15 * @createTime 2014-6-9 下午03:17:25
16 */
17 public class TestObjSerializeAndDeserialize {
18
19 public static void main(String[] args) throws Exception {
20 SerializePerson();//序列化Person对象
21 Person p = DeserializePerson();//反序列Perons对象
22 System.out.println(MessageFormat.format("name={0},age={1},sex={2}",
23 p.getName(), p.getAge(), p.getSex()));
24 }
25
26 /**
27 * MethodName: SerializePerson
28 * Description: 序列化Person对象
29 * @author xudp
30 * @throws FileNotFoundException
31 * @throws IOException
32 */
33 private static void SerializePerson() throws FileNotFoundException,
34 IOException {
35 Person person = new Person();
36 person.setName("gacl");
37 person.setAge(25);
38 person.setSex("男");
39 // ObjectOutputStream 对象输出流,将Person对象存储到E盘的Person.txt文件中,完成对Person对象的序列化操作
40 ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(
41 new File("E:/Person.txt")));
42 oo.writeObject(person);
43 System.out.println("Person对象序列化成功!");
44 oo.close();
45 }
46
47 /**
48 * MethodName: DeserializePerson
49 * Description: 反序列Perons对象
50 * @author xudp
51 * @return
52 * @throws Exception
53 * @throws IOException
54 */
55 private static Person DeserializePerson() throws Exception, IOException {
56 ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
57 new File("E:/Person.txt")));
58 Person person = (Person) ois.readObject();
59 System.out.println("Person对象反序列化成功!");
60 return person;
61 }
62
63 }
指定序列化id的姿势
class Customer implements Serializable {
2 /**
3 * Customer类中定义的serialVersionUID(序列化版本号)
4 */
5 private static final long serialVersionUID = -5182532647273106745L;
6 private String name;
7 private int age;