java 序列化的机制和原理

最新推荐文章于 2022-06-13 13:16:34 发布

Coding-lover

最新推荐文章于 2022-06-13 13:16:34 发布

阅读量615

点赞数

分类专栏： javaSE

javaSE 专栏收录该内容

165 篇文章

订阅专栏

本文深入介绍了Java序列化机制，包括序列化的必要性、序列化对象的步骤及其实现方法，并通过具体实例展示了序列化后的字节流如何描述对象信息。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

有关Java对象的序列化和反序列化也算是Java基础的一部分，下面对Java序列化的机制和原理进行一些介绍。

在纯的java环境下，java序列化能够很好的工作，但是在多语言环境下，用java序列化存储后，很难用其他语言还原出结果。在这种情况下，还是要尽量存储通用的数据结构，如JSON或者XML结构数据。

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();  
 
       }  
 
}

这个例子是相当的直白啦。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

我们来仔细看看这些字节都代表了啥。开头部分，见颜色：