`
xifangyuhui
  • 浏览: 188973 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Java序列化机制和原理【转】

阅读更多

序列化的必要性

    Java中,一切都是对象,在分布式环境中经常需要将Object从这一端网络或设备传递到另一端。
    这就需要有一种可以在两端传输数据的协议。
    Java序列化机制就是为了解决这个问题而产生。

    如何序列化一个对象

    一个对象能够序列化的前提是实现Serializable接口,Serializable接口没有方法,更像是个标记。
    有了这个标记的
    Class就能被序列化机制处理。

  1. import java.io.Serializable;  
  2.  
  3. class TestSerial implements Serializable {  
  4.  
  5.        public byte version = 100;  
  6.  
  7.        public byte count = 0;  
  8.  

然后我们写个程序将对象序列化并输出。ObjectOutputStream能把Object输出成Byte流。
我们将
Byte流暂时存储到temp.out文件里。

  1. public static void main(String args[]) throws IOException {  
  2.  
  3.        FileOutputStream fos = new FileOutputStream("temp.out");  
  4.  
  5.        ObjectOutputStream oos = new ObjectOutputStream(fos);  
  6.  
  7.        TestSerial ts = new TestSerial();  
  8.  
  9.        oos.writeObject(ts);  
  10.  
  11.        oos.flush();  
  12.  
  13.        oos.close();  
  14.  
如果要从持久的文件中读取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型,理论上存储这两个域只需要2byte,但是实际上temp.out占据空间为51bytes
也就是说除了数据以外,还包括了对序列化对象的其他描述。

Java的序列化算法

序列化算法一般会按步骤做如下事情:

将对象实例相关的类元数据输出。

递归地输出类的超类描述直到不再有超类。

类元数据完了以后,开始从最顶层的超类开始输出对象实例的实际数据值。

从上至下递归输出实例的数据

我们用另一个更完整覆盖所有可能出现的情况的例子来说明:

  1. class parent implements Serializable {  
  2.  
  3.        int parentVersion = 10;  
  4.  
  5. }  
  6.  
  7.    
  8.  
  9. class contain implements Serializable{  
  10.  
  11.        int containVersion = 11;  
  12.  
  13. }  
  14.  
  15. public class SerialTest extends parent implements Serializable {  
  16.  
  17.        int version = 66;  
  18.  
  19.        contain con = new contain();  
  20.  
  21.    
  22.  
  23.        public int getVersion() {  
  24.  
  25.               return version;  
  26.  
  27.        }  
  28.  
  29.        public static void main(String args[]) throws IOException {  
  30.  
  31.               FileOutputStream fos = new FileOutputStream("temp.out");  
  32.  
  33.               ObjectOutputStream oos = new ObjectOutputStream(fos);  
  34.  
  35.               SerialTest st = new SerialTest();  
  36.  
  37.               oos.writeObject(st);  
  38.  
  39.               oos.flush();  
  40.  
  41.               oos.close();  
  42.  
  43.        }  
  44.  
  •  
    1. AC ED: STREAM_MAGIC. 声明使用了序列化协议.
    2. 00 05: STREAM_VERSION. 序列化协议版本.
    3. 0x73: TC_OBJECT. 声明这是一个新的对象.  
    1. 0x72: TC_CLASSDESC. 声明这里开始一个新Class
    2. 00 0A: Class名字的长度.
    3. 53 65 72 69 61 6c 54 65 73 74: SerialTest,Class类名.
    4. 05 52 81 5A AC 66 02 F6: SerialVersionUID, 序列化ID,如果没有指定,
      则会由算法随机生成一个
      8byteID.
    5. 0x02: 标记号. 该值声明该对象支持序列化。
    6. 00 02: 该类所包含的域个数。
    1. 0x49: 域类型. 49 代表"I", 也就是Int.
    2. 00 07: 域名字的长度.
    3. 76 65 72 73 69 6F 6E: version,域名字描述.
    1. 0x4C: 域的类型.
    2. 00 03: 域名字长度.
    3. 63 6F 6E: 域名字描述,con
    4. 0x74: TC_STRING. 代表一个new String.String来引用对象。
    5. 00 09: String长度.
    6. 4C 63 6F 6E 74 61 69 6E 3B: Lcontain;, JVM的标准对象签名表示法.
    7. 0x78: TC_ENDBLOCKDATA,对象数据块结束的标志
    1. 0x72: TC_CLASSDESC. 声明这个是个新类.
    2. 00 06: 类名长度.
    3. 70 61 72 65 6E 74: parent,类名描述。
    4. 0E DB D2 BD 85 EE 63 7A: SerialVersionUID, 序列化ID.
    5. 0x02: 标记号. 该值声明该对象支持序列化.
    6. 00 01: 类中域的个数.
    1. 0x49: 域类型. 49 代表"I", 也就是Int.
    2. 00 0D: 域名字长度.
    3. 70 61 72 65 6E 74 56 65 72 73 69 6F 6E: parentVersion,域名字描述。
    4. 0x78: TC_ENDBLOCKDATA,对象块结束的标志。
    5. 0x70: TC_NULL, 说明没有其他超类的标志。.
    1. 00 00 00 0A: 10, parentVersion域的值.
    1. 00 00 00 42: 66, version域的值.
    1. 0x73: TC_OBJECT, 声明这是一个新的对象.
    2. 0x72: TC_CLASSDESC声明这里开始一个新Class.
    3. 00 07: 类名的长度.
    4. 63 6F 6E 74 61 69 6E: contain,类名描述.
    5. FC BB E6 0E FB CB 60 C7: SerialVersionUID, 序列化ID.
    6. 0x02: Various flags. 标记号. 该值声明该对象支持序列化
    7. 00 01: 类内的域个数。
    1. 0x49: 域类型. 49 代表"I", 也就是Int..
    2. 00 0E: 域名字长度.
    3. 63 6F 6E 74 61 69 6E 56 65 72 73 69 6F 6E: containVersion, 域名字描述.
    4. 0x78: TC_ENDBLOCKDATA对象块结束的标志.
    1. 0x70:TC_NULL,没有超类了。
    1. 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序列化的机制和原理,希望能对同学们有所帮助。

分享到:
评论

相关推荐

    Java序列化的机制和原理

    让我们深入探讨一下Java序列化的机制和原理。 首先,Java序列化的主要目的是为了对象的持久化和在网络上的传输。为了使一个对象可以被序列化,该对象的类必须实现`java.io.Serializable`接口。这个接口没有任何方法...

    java序列化原理与算法

    首先,我们需要创建一个实现了`Serializable`接口的类`TestSerial`,这样Java序列化机制才能处理这个类的对象。 接下来,我们编写代码将对象序列化并输出为字节流,存储在一个临时文件`temp.out`中。 ```java ...

    Java序列化的机制和原理[归类].pdf

    以下是关于Java序列化机制和原理的详细解释: 1. **序列化接口**: Java中的序列化是通过实现`Serializable`接口来实现的。这个接口没有任何方法,它的存在仅仅是为了标记一个类可以被序列化。如以下示例所示: `...

    java序列化(Serializable)的作用和反序列化

    序列化机制是Java提供的强大工具之一,可以帮助开发者轻松地保存和恢复对象的状态。 #### 二、序列化的应用场景 1. **文件保存**:当需要将内存中的对象状态保存到文件中或数据库中时,序列化非常有用。 2. **网络...

    java序列化实现演示

    在给定的链接"Java序列化机制(2)- serialVersionUID 实验"中,博主通过一个实验详细解释了`serialVersionUID`的作用和重要性。实验可能包括以下步骤: 1. 创建一个实现`Serializable`接口的简单类,并运行序列化...

    java 序列化代码示例

    Java序列化是Java平台中的一种标准机制,它允许将对象的状态转换为字节流,以便存储、传输或恢复。在Java中,一个类如果要实现序列化,需要实现`Serializable`接口,这是一个标记接口,不包含任何方法。下面我们将...

    FST:快速Java序列化的替代品

    **FST:快速Java序列化的替代方案** 在Java开发中,序列化是一个常见的需求,它允许将对象的状态转换为字节流,以便于存储或网络传输。标准的Java序列化虽然方便,但在处理大量数据时,性能往往成为瓶颈。这时,FST...

    Java_序列化的高级认识

    序列化ID,即`serialVersionUID`,是Java序列化机制中一个关键的概念。它是一个类的唯一标识符,用于在序列化和反序列化过程中确定类的版本一致性。如果序列化对象和反序列化对象的`serialVersionUID`不匹配,将会抛...

    java序列化之protobuf

    总的来说,protobuf是Java序列化的一个强大工具,尤其在处理大量数据交换和跨平台通信时,它的效率和灵活性使它成为首选。学习和掌握protobuf不仅可以提升项目性能,还能提高代码的可维护性和扩展性。

    Java高级程序设计实战教程第五章-Java序列化机制.pptx

    Java序列化机制是Java平台提供的一种标准方法,用于将对象的状态转换为字节序列,以便在网络中传输或存储在磁盘、数据库等持久化介质中。这一机制在分布式环境、远程通信、持久化存储和数据交换等多个场景下具有广泛...

    java反序列化利用程序UI版Beta1.1.rar

    1. **Java序列化机制**:Java对象序列化是通过实现`Serializable`接口来标记一个类可被序列化。`ObjectOutputStream`用于将对象写入流,`ObjectInputStream`用于从流中读取并反序列化对象。 2. **易受攻击的库**:...

    Java对象序列化的秘密

    Java对象序列化是Java平台提供的一种机制,允许将对象的状态转换为字节流,以便存储在磁盘上、通过网络传输或在不同时间点恢复。这个过程涉及到将一个复杂的Java对象模型转换为简单的二进制表示,使得数据可以在不同...

    如何正确的使用Java序列化技术

    此外,还将深入讨论如何精准控制序列化机制,帮助读者在实际编程中正确运用Java序列化技术,避免常见误区,并掌握高效利用该技术的方法。 **关键词:** 序列化(Serialize)、反序列化(DeSerialize)、类加载...

    Hadoop序列化机制

    标签中的“源码”提示我们,了解这些序列化机制的内部工作原理,查看源代码可以帮助我们更深入地理解其优化点和可能的改进空间。“工具”则意味着除了理论知识,还有实际可用的库和工具可以帮助我们在项目中实施这些...

    Android-Android上的Java对象反序列化

    3. **Protobuf**: Google的协议缓冲区,提供高效的序列化机制,适用于网络通信和数据存储,具有较小的体积和更快的速度。 四、反序列化安全问题 1. **代码执行漏洞**: 不安全的反序列化可能导致远程代码执行。攻击...

    学生管理系统(序列化和反序列化)

    管理系统源码.zip、README.txt 在本项目中,“学生管理系统(序列化和反序列化)”是一个基于Java或类似编程语言实现的系统,其核心功能是...在开发类似的系统时,理解并掌握序列化和反序列化的核心原理是非常重要的。

    诠释Android中序列化的原理与机制

    接下来,我们讨论Parcelable,这是Android特有的序列化机制,主要用于内存中的对象传输,例如在Activity之间传递数据或者保存到Bundle中。相比于Serializable,Parcelable提供了更高的性能和更低的内存消耗。实现...

    JAVA序列化和反序列化的底层实现原理解析

    JAVA序列化和反序列化的底层实现原理解析 一、基本概念 JAVA序列化是指把Java对象转换为字节序列的过程,而Java反序列化是指把字节序列恢复为Java对象的过程。序列化是把对象转换成有序字节流,以便在网络上传输...

    java序列化深度探讨

    Java序列化不仅仅是对数据的简单编码,更重要的是它涉及到对象的生命周期和状态的保存。 要实现对象的序列化,Java对象必须实现`Serializable`接口。这是一个特殊的标识接口,不包含任何方法,它的作用仅仅是标记一...

Global site tag (gtag.js) - Google Analytics