Java序列化的机制和原理

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

专注于为中小企业提供成都网站建设、成都网站设计服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业富川免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了上千家企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。

Java序列化算法透析

Serialization（序列化）是一种将对象以一连串的字节描述的过程；反序列化deserialization是一种将这些字节重建成一个对象的过程。Java序列化API提供一种处理对象序列化的标准机制。在这里你能学到如何序列化一个对象，什么时候需要序列化以及Java序列化的算法，我们用一个实例来示范序列化以后的字节是如何描述一个对象的信息的。

序列化的必要性

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

如何序列化一个对象

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

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

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

  
  
  
       
   
   
  1. public static void main(String args[]) throws IOException {  
    2.    
   
   
  2.  
    3.    
   
   
  3.        FileOutputStream fos = new FileOutputStream("temp.out");  
    4.    
   
   
  4.  
    5.    
   
   
  5.        ObjectOutputStream oos = new ObjectOutputStream(fos);  
    6.    
   
   
  6.  
    7.    
   
   
  7.        TestSerial ts = new TestSerial();  
    8.    
   
   
  8.  
    9.    
   
   
  9.        oos.writeObject(ts);  
    10.    
   
   
  10.  
    11.    
   
   
  11.        oos.flush();  
    12.    
   
   
  12.  
    13.    
   
   
  13.        oos.close();  
    14.    
   
   
  14.  
    15.    
   
   
  15. } 
    16.   
  

如果要从持久的文件中读取Bytes重建对象，我们可以使用ObjectInputStream。
  
  
  
       
   
   
  1. public static void main(String args[]) throws IOException {  
    2.    
   
   
  2.  
    3.    
   
   
  3.        FileInputStream fis = new FileInputStream("temp.out");  
    4.    
   
   
  4.  
    5.    
   
   
  5.        ObjectInputStream oin = new ObjectInputStream(fis);  
    6.    
   
   
  6.  
    7.    
   
   
  7.        TestSerial ts = (TestSerial) oin.readObject();  
    8.    
   
   
  8.  
    9.    
   
   
  9.        System.out.println("version="+ts.version);  
    10.    
   
   
  10.  
    11.    
   
   
  11. } 
    12.   
  

执行结果为
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的序列化算法
序列化算法一般会按步骤做如下事情：
◆将对象实例相关的类元数据输出。
◆递归地输出类的超类描述直到不再有超类。
◆类元数据完了以后，开始从最顶层的超类开始输出对象实例的实际数据值。
◆从上至下递归输出实例的数据
我们用另一个更完整覆盖所有可能出现的情况的例子来说明：
     
     
     
          
      
      
  1. class parent implements Serializable {  
    2.       
      
      
  2.  
    3.       
      
      
  3.        int parentVersion = 10;  
    4.       
      
      
  4.  
    5.       
      
      
  5. }  
    6.       
      
      
  6.  
    7.       
      
      
  7.    
    8.       
      
      
  8.  
    9.       
      
      
  9. class contain implements Serializable{  
    10.       
      
      
  10.  
    11.       
      
      
  11.        int containVersion = 11;  
    12.       
      
      
  12.  
    13.       
      
      
  13. }  
    14.       
      
      
  14.  
    15.       
      
      
  15. public class SerialTest extends parent implements Serializable {  
    16.       
      
      
  16.  
    17.       
      
      
  17.        int version = 66;  
    18.       
      
      
  18.  
    19.       
      
      
  19.        contain con = new contain();  
    20.       
      
      
  20.  
    21.       
      
      
  21.    
    22.       
      
      
  22.  
    23.       
      
      
  23.        public int getVersion() {  
    24.       
      
      
  24.  
    25.       
      
      
  25.               return version;  
    26.       
      
      
  26.  
    27.       
      
      
  27.        }  
    28.       
      
      
  28.  
    29.       
      
      
  29.        public static void main(String args[]) throws IOException {  
    30.       
      
      
  30.  
    31.       
      
      
  31.               FileOutputStream fos = new FileOutputStream("temp.out");  
    32.       
      
      
  32.  
    33.       
      
      
  33.               ObjectOutputStream oos = new ObjectOutputStream(fos);  
    34.       
      
      
  34.  
    35.       
      
      
  35.               SerialTest st = new SerialTest();  
    36.       
      
      
  36.  
    37.       
      
      
  37.               oos.writeObject(st);  
    38.       
      
      
  38.  
    39.       
      
      
  39.               oos.flush();  
    40.       
      
      
  40.  
    41.       
      
      
  41.               oos.close();  
    42.       
      
      
  42.  
    43.       
      
      
  43.        }  
    44.       
      
      
  44.  
    45.       
      
      
  45. } 
    46.      
     
   
这个例子是相当的直白啦。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
我们来仔细看看这些字节都代表了啥。开头部分，见颜色：
  1.  AC ED: STREAM_MAGIC. 声明使用了序列化协议.
  2.  00 05: STREAM_VERSION. 序列化协议版本.
  3.  0x73: TC_OBJECT. 声明这是一个新的对象.  


序列化算法的第一步就是输出对象相关类的描述。例子所示对象为SerialTest类实例，因此接下来输出SerialTest类的描述。见颜色：
  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，如果没有指定，则会由算法随机生成一个8byte的ID.
  5.  0x02: 标记号. 该值声明该对象支持序列化。
  6.  00 02: 该类所包含的域个数。


接下来，算法输出其中的一个域，int version=66；见颜色：
  1.  0x49: 域类型. 49 代表"I", 也就是Int.
  2.  00 07: 域名字的长度.
  3.  76 65 72 73 69 6F 6E: version,域名字描述.


然后，算法输出下一个域，contain con = new contain();这个有点特殊，是个对象。描述对象类型引用时需要使用JVM的标准对象签名表示法，见颜色：
  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,对象数据块结束的标志


.接下来算法就会输出超类也就是Parent类描述了，见颜色：
  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: 类中域的个数.


下一步，输出parent类的域描述，int parentVersion=100;同见颜色：
  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, 说明没有其他超类的标志。.


到此为止，算法已经对所有的类的描述都做了输出。下一步就是把实例对象的实际值输出了。这时候是从parent Class的域开始的，见颜色：
  1.  00 00 00 0A: 10, parentVersion域的值.


还有SerialTest类的域：
  1.  00 00 00 42: 66, version域的值.


再往后的bytes比较有意思，算法需要描述contain类的信息，要记住，现在还没有对contain类进行过描述，见颜色：
  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: 类内的域个数。


.输出contain的唯一的域描述，int containVersion=11；
  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对象块结束的标志.


这时，序列化算法会检查contain是否有超类，如果有的话会接着输出。
  1.  0x70:TC_NULL，没有超类了。


最后，将contain类实际域值输出。
  1.  00 00 00 0B: 11, containVersion的值.


OK,我们讨论了java序列化的机制和原理，希望能对同学们有所帮助。
本文来自longdick的博客：《Java序列化算法透析》
【编辑推荐】
  1. Java对象的序列化和反序列化实践
  2. Java程序性能优化之找出内存溢出元凶
  3. 2009年十大Java技术解决方案
  4. 有关Java线程机制的浅析
  5. 如何优化JavaScript脚本的性能
            

                网站栏目：Java序列化的机制和原理
                

                文章位置：http://www.shufengxianlan.com/qtweb/news31/405731.html
            

            

                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                

            

                广告
                
            

            

                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联

猜你还喜欢下面的内容

网站制作知识

同城分类信息

成都网站制作　　 　成都创新互联　　 　成都保温材料　　 　混凝土密封固化剂　　 　四川门窗　　 　犀浦防纹窗　　 　成都联通服务器托管　　 　做手机网站　　 　买友情链接　　 　路面机械及配件　　 　成都企业网站设计　　 　工业净化空调　　 　成都网站设计　　 　定制网站建设多少钱　　 　腾讯免备案空间　　 　成都电商网站建设方案　　 　网站制作公司　　 　重庆服务器托管　　 　app开发公司　　 　成都铺面装修