偷偷摘套内射激情视频,久久精品99国产国产精,中文字幕无线乱码人妻,中文在线中文a,性爽19p

Java程序員必備：序列化全方位解析

作者：撿田螺的小男孩
開發(fā) 后端
相信大家日常開發(fā)中，經(jīng)?？吹絁ava對象“implements Serializable”。那么，它到底有什么用呢？本文從以下幾個角度來解析序列這一塊知識點(diǎn)~

前言

[[322813]]

相信大家日常開發(fā)中，經(jīng)?？吹絁ava對象“implements Serializable”。那么，它到底有什么用呢?本文從以下幾個角度來解析序列這一塊知識點(diǎn)~

  • 什么是Java序列化?
  • 為什么需要序列化?
  • 序列化用途
  • Java序列化常用API
  • 序列化的使用
  • 序列化底層
  • 日常開發(fā)序列化的注意點(diǎn)
  • 序列化常見面試題

一、什么是Java序列化?

  • 序列化：把Java對象轉(zhuǎn)換為字節(jié)序列的過程
  • 反序列：把字節(jié)序列恢復(fù)為Java對象的過程

二、為什么需要序列化?

Java對象是運(yùn)行在JVM的堆內(nèi)存中的，如果JVM停止后，它的生命也就戛然而止。

如果想在JVM停止后，把這些對象保存到磁盤或者通過網(wǎng)絡(luò)傳輸?shù)搅硪贿h(yuǎn)程機(jī)器，怎么辦呢?磁盤這些硬件可不認(rèn)識Java對象，它們只認(rèn)識二進(jìn)制這些機(jī)器語言，所以我們就要把這些對象轉(zhuǎn)化為字節(jié)數(shù)組，這個過程就是序列化啦~

打個比喻，作為大城市漂泊的碼農(nóng)，搬家是常態(tài)。當(dāng)我們搬書桌時，桌子太大了就通不過比較小的門，因此我們需要把它拆開再搬過去，這個拆桌子的過程就是序列化。而我們把書桌復(fù)原回來(安裝)的過程就是反序列化啦。

三、序列化用途

序列化使得對象可以脫離程序運(yùn)行而獨(dú)立存在，它主要有兩種用途：

（1）序列化機(jī)制可以讓對象地保存到硬盤上，減輕內(nèi)存壓力的同時，也起了持久化的作用;

比如 Web服務(wù)器中的Session對象，當(dāng)有 10+萬用戶并發(fā)訪問的，就有可能出現(xiàn)10萬個Session對象，內(nèi)存可能消化不良，于是Web容器就會把一些seesion先序列化到硬盤中，等要用了，再把保存在硬盤中的對象還原到內(nèi)存中。

（2）序列化機(jī)制讓Java對象在網(wǎng)絡(luò)傳輸不再是天方夜譚。

我們在使用Dubbo遠(yuǎn)程調(diào)用服務(wù)框架時，需要把傳輸?shù)腏ava對象實現(xiàn)Serializable接口，即讓Java對象序列化，因為這樣才能讓對象在網(wǎng)絡(luò)上傳輸。

四、Java序列化常用API

  1. java.io.ObjectOutputStream 
  2.  
  3. java.io.ObjectInputStream 
  4.  
  5. java.io.Serializable 
  6.  
  7. java.io.Externalizable 

Serializable 接口

Serializable接口是一個標(biāo)記接口，沒有方法或字段。一旦實現(xiàn)了此接口，就標(biāo)志該類的對象就是可序列化的。

  1. public interface Serializable { 
  2.  
  3. } 

Externalizable 接口

Externalizable繼承了Serializable接口，還定義了兩個抽象方法：writeExternal()和readExternal()，如果開發(fā)人員使用Externalizable來實現(xiàn)序列化和反序列化，需要重寫writeExternal()和readExternal()方法

  1.  public interface Externalizable extends java.io.Serializable { 
  2.     void writeExternal(ObjectOutput out) throws IOException; 
  3.     void readExternal(ObjectInput in) throws IOException, ClassNotFoundException; 
  4.  } 

java.io.ObjectOutputStream類

表示對象輸出流，它的writeObject(Object obj)方法可以對指定obj對象參數(shù)進(jìn)行序列化，再把得到的字節(jié)序列寫到一個目標(biāo)輸出流中。

java.io.ObjectInputStream

表示對象輸入流，它的readObject()方法，從輸入流中讀取到字節(jié)序列，反序列化成為一個對象，最后將其返回。

五、序列化的使用

序列化如何使用?來看一下，序列化的使用的幾個關(guān)鍵點(diǎn)吧：

  • 聲明一個實體類，實現(xiàn)Serializable接口
  • 使用ObjectOutputStream類的writeObject方法，實現(xiàn)序列化
  • 使用ObjectInputStream類的readObject方法，實現(xiàn)反序列化

聲明一個Student類，實現(xiàn)Serializable

  1.   public class Student implements Serializable { 
  2.    
  3.       private Integer age; 
  4.       private String name; 
  5.    
  6.      public Integer getAge() { 
  7.           return age; 
  8.       } 
  9.       public void setAge(Integer age) { 
  10.          this.age = age; 
  11.      } 
  12.      public String getName() { 
  13.          return name; 
  14.      } 
  15.      public void setName(String name) { 
  16.          this.name = name; 
  17.      } 
  18.  } 

使用ObjectOutputStream類的writeObject方法，對Student對象實現(xiàn)序列化

把Student對象設(shè)置值后，寫入一個文件，即序列化，哈哈

  1. ObjectOutputStream objectOutputStream = new ObjectOutputStream( new FileOutputStream("D:\\text.out")); 
  2. Student student = new Student(); 
  3. student.setAge(25); 
  4. student.setName("jayWei"); 
  5. objectOutputStream.writeObject(student); 
  6.  
  7. objectOutputStream.flush(); 
  8. objectOutputStream.close(); 

看看序列化的可愛模樣吧，test.out文件內(nèi)容如下(使用UltraEdit打開)：

使用ObjectInputStream類的readObject方法，實現(xiàn)反序列化，重新生成student對象

再把test.out文件讀取出來，反序列化為Student對象

  1. ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("D:\\text.out")); 
  2. Student student = (Student) objectInputStream.readObject(); 
  3. System.out.println("name="+student.getName()); 

六、序列化底層

Serializable底層

Serializable接口，只是一個空的接口，沒有方法或字段，為什么這么神奇，實現(xiàn)了它就可以讓對象序列化了?

  1. public interface Serializable { 
  2.  
  3. } 

為了驗證Serializable的作用，把以上demo的Student對象，去掉實現(xiàn)Serializable接口，看序列化過程怎樣吧。

序列化過程中拋出異常啦，堆棧信息如下：

  1. Exception in thread "main" java.io.NotSerializableException: com.example.demo.Student 
  2.     at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184) 
  3.     at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348) 
  4.     at com.example.demo.Test.main(Test.java:13) 

順著堆棧信息看一下，原來有重大發(fā)現(xiàn)，如下：

原來底層是這樣：ObjectOutputStream 在序列化的時候，會判斷被序列化的Object是哪一種類型，String?array?enum?還是 Serializable，如果都不是的話，拋出 NotSerializableException異常。所以呀，Serializable真的只是一個標(biāo)志，一個序列化標(biāo)志。

writeObject(Object)

序列化的方法就是writeObject，基于以上的demo，我們來分析一波它的核心方法調(diào)用鏈吧~(建議大家也去debug看一下這個方法，感興趣的話)

writeObject直接調(diào)用的就是writeObject0()方法，

  1. public final void writeObject(Object obj) throws IOException { 
  2.     ...... 
  3.     writeObject0(obj, false); 
  4.     ...... 
  5. } 

writeObject0 主要實現(xiàn)是對象的不同類型，調(diào)用不同的方法寫入序列化數(shù)據(jù)，這里面如果對象實現(xiàn)了Serializable接口，就調(diào)用writeOrdinaryObject()方法。

  1. private void writeObject0(Object obj, boolean unshared) 
  2.         throws IOException 
  3.     { 
  4.     ...... 
  5.    //String類型 
  6.     if (obj instanceof String) { 
  7.         writeString((String) obj, unshared); 
  8.    //數(shù)組類型 
  9.     } else if (cl.isArray()) { 
  10.         writeArray(obj, desc, unshared); 
  11.    //枚舉類型 
  12.     } else if (obj instanceof Enum) { 
  13.         writeEnum((Enum<?>) obj, desc, unshared); 
  14.    //Serializable實現(xiàn)序列化接口 
  15.     } else if (obj instanceof Serializable) { 
  16.         writeOrdinaryObject(obj, desc, unshared); 
  17.     } else{ 
  18.         //其他情況會拋異常~ 
  19.         if (extendedDebugInfo) { 
  20.             throw new NotSerializableException( 
  21.                 cl.getName() + "\n" + debugInfoStack.toString()); 
  22.         } else { 
  23.             throw new NotSerializableException(cl.getName()); 
  24.         } 
  25.     } 
  26.     ...... 

writeOrdinaryObject()會先調(diào)用writeClassDesc(desc)，寫入該類的生成信息，然后調(diào)用writeSerialData方法，寫入序列化數(shù)據(jù)。

  1. private void writeSerialData(Object obj, ObjectStreamClass desc) 
  2.         throws IOException 
  3.     { 
  4.         for (int i = 0; i < slots.length; i++) { 
  5.             if (slotDesc.hasWriteObjectMethod()) { 
  6.                    //如果被序列化的對象自定義實現(xiàn)了writeObject()方法，則執(zhí)行這個代碼塊 
  7.                     slotDesc.invokeWriteObject(obj, this); 
  8.             } else { 
  9.                 // 調(diào)用默認(rèn)的方法寫入實例數(shù)據(jù) 
  10.                 defaultWriteFields(obj, slotDesc); 
  11.             } 
  12.         } 
  13.     } 

writeSerialData()實現(xiàn)的就是寫入被序列化對象的字段數(shù)據(jù)，它會調(diào)用defaultWriteFields方法。

  1. private void writeSerialData(Object obj, ObjectStreamClass desc) 
  2.         throws IOException 
  3.     { 
  4.         for (int i = 0; i < slots.length; i++) { 
  5.             if (slotDesc.hasWriteObjectMethod()) { 
  6.                    //如果被序列化的對象自定義實現(xiàn)了writeObject()方法，則執(zhí)行這個代碼塊 
  7.                     slotDesc.invokeWriteObject(obj, this); 
  8.             } else { 
  9.                 // 調(diào)用默認(rèn)的方法寫入實例數(shù)據(jù) 
  10.                 defaultWriteFields(obj, slotDesc); 
  11.              } 
  12.         } 
  13.     } 

defaultWriteFields()方法，獲取類的基本數(shù)據(jù)類型數(shù)據(jù)，直接寫入底層字節(jié)容器;獲取類的obj類型數(shù)據(jù)，循環(huán)遞歸調(diào)用writeObject0()方法，寫入數(shù)據(jù)。

  1.     private void defaultWriteFields(Object obj, ObjectStreamClass desc) 
  2.             throws IOException 
  3.         {    
  4.             // 獲取類的基本數(shù)據(jù)類型數(shù)據(jù)，保存到primVals字節(jié)數(shù)組 
  5.             desc.getPrimFieldValues(obj, primVals); 
  6.             //primVals的基本類型數(shù)據(jù)寫到底層字節(jié)容器 
  7.             bout.write(primVals, 0, primDataSize, false); 
  8.      
  9.             // 獲取對應(yīng)類的所有字段對象 
  10.             ObjectStreamField[] fields = desc.getFields(false); 
  11.             Object[] objVals = new Object[desc.getNumObjFields()]; 
  12.             int numPrimFields = fields.length - objVals.length; 
  13.             // 獲取類的obj類型數(shù)據(jù)，保存到objVals字節(jié)數(shù)組 
  14.             desc.getObjFieldValues(obj, objVals); 
  15.             //對所有Object類型的字段,循環(huán) 
  16.             for (int i = 0; i < objVals.length; i++) { 
  17.                 ...... 
  18.                   //遞歸調(diào)用writeObject0()方法，寫入對應(yīng)的數(shù)據(jù) 
  19.                 writeObject0(objVals[i], 
  20.                                  fields[numPrimFields + i].isUnshared()); 
  21.                 ...... 
  22.             } 
  23.         } 

七、日常開發(fā)序列化的一些注意點(diǎn)

  • static靜態(tài)變量和transient 修飾的字段是不會被序列化的
  • serialVersionUID問題
  • 如果某個序列化類的成員變量是對象類型，則該對象類型的類必須實現(xiàn)序列化
  • 子類實現(xiàn)了序列化，父類沒有實現(xiàn)序列化，父類中的字段會丟失~

static靜態(tài)變量和transient 修飾的字段是不會被序列化的

static靜態(tài)變量和transient 修飾的字段是不會被序列化的,我們來看例子分析一波~ Student類加了一個類變量gender和一個transient修飾的字段specialty

  1. public class Student implements Serializable { 
  2.  
  3.     private Integer age; 
  4.     private String name; 
  5.  
  6.     public static String gender = "男"; 
  7.     transient  String specialty = "計算機(jī)專業(yè)"; 
  8.  
  9.     public String getSpecialty() { 
  10.         return specialty; 
  11.     } 
  12.  
  13.     public void setSpecialty(String specialty) { 
  14.         this.specialty = specialty; 
  15.     } 
  16.  
  17.     @Override 
  18.     public String toString() { 
  19.         return "Student{" +"age=" + age + ", name='" + name + '\'' + ", gender='" + gender + '\'' + ", specialty='" + specialty + '\'' + 
  20.                 '}'; 
  21.     } 
  22.     ...... 

打印學(xué)生對象，序列化到文件，接著修改靜態(tài)變量的值，再反序列化，輸出反序列化后的對象~

運(yùn)行結(jié)果：

  1. 序列化前Student{age=25, name='jayWei', gender='男', specialty='計算機(jī)專業(yè)'}  
  2. 序列化后Student{age=25, name='jayWei', gender='女', specialty='null'} 

 

對比結(jié)果可以發(fā)現(xiàn)：

（1）序列化前的靜態(tài)變量性別明明是‘男’，序列化后再在程序中修改，反序列化后卻變成‘女’了，what?顯然這個靜態(tài)屬性并沒有進(jìn)行序列化。其實，靜態(tài)(static)成員變量是屬于類級別的，而序列化是針對對象的~所以不能序列化哦。

（2）經(jīng)過序列化和反序列化過程后，specialty字段變量值由'計算機(jī)專業(yè)'變?yōu)榭樟?，為什么?其實是因為transient關(guān)鍵字，它可以阻止修飾的字段被序列化到文件中，在被反序列化后，transient 字段的值被設(shè)為初始值，比如int型的值會被設(shè)置為 0，對象型初始值會被設(shè)置為null。

serialVersionUID問題

serialVersionUID 表面意思就是序列化版本號ID，其實每一個實現(xiàn)Serializable接口的類，都有一個表示序列化版本標(biāo)識符的靜態(tài)變量，或者默認(rèn)等于1L，或者等于對象的哈希碼。

  1. private static final long serialVersionUID = -6384871967268653799L; 

serialVersionUID有什么用?

JAVA序列化的機(jī)制是通過判斷類的serialVersionUID來驗證版本是否一致的。在進(jìn)行反序列化時，JVM會把傳來的字節(jié)流中的serialVersionUID和本地相應(yīng)實體類的serialVersionUID進(jìn)行比較，如果相同，反序列化成功，如果不相同，就拋出InvalidClassException異常。

接下來，我們來驗證一下吧，修改一下Student類，再反序列化操作：

  1.   Exception in thread "main" java.io.InvalidClassException: com.example.demo.Student; 
  2.   local class incompatible: stream classdesc serialVersionUID = 3096644667492403394, 
  3.   local class serialVersionUID = 4429793331949928814 
  4.       at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:687) 
  5.       at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1876) 
  6.       at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1745) 
  7.       at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2033) 
  8.       at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1567) 
  9.       at java.io.ObjectInputStream.readObject(ObjectInputStream.java:427) 
  10.      at com.example.demo.Test.main(Test.java:20) 

從日志堆棧異常信息可以看到，文件流中的class和當(dāng)前類路徑中的class不同了，它們的serialVersionUID不相同，所以反序列化拋出InvalidClassException異常。那么，如果確實需要修改Student類，又想反序列化成功，怎么辦呢?可以手動指定serialVersionUID的值，一般可以設(shè)置為1L，或者讓我們的編輯器IDE生成。

  1. private static final long serialVersionUID = -6564022808907262054L; 

實際上，阿里開發(fā)手冊，強(qiáng)制要求序列化類新增屬性時，不能修改serialVersionUID字段。

如果某個序列化類的成員變量是對象類型，則該對象類型的類必須實現(xiàn)序列化。

給Student類添加一個Teacher類型的成員變量，其中Teacher是沒有實現(xiàn)序列化接口的。

  1.   public class Student implements Serializable { 
  2.    
  3.       private Integer age; 
  4.       private String name; 
  5.       private Teacher teacher; 
  6.       ... 
  7.  } 
  8.   //Teacher 沒有實現(xiàn) 
  9.   public class Teacher  { 
  10.  ...... 
  11.  } 

序列化運(yùn)行，就報NotSerializableException異常啦。

  1.   Exception in thread "main" java.io.NotSerializableException: com.example.demo.Teacher 
  2.       at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184) 
  3.       at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1548) 
  4.       at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1509) 
  5.       at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1432) 
  6.       at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1178) 
  7.       at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348) 
  8.       at com.example.demo.Test.main(Test.java:16) 

其實這個可以在上小節(jié)的底層源碼分析找到答案，一個對象序列化過程，會循環(huán)調(diào)用它的Object類型字段，遞歸調(diào)用序列化的，也就是說，序列化Student類的時候，會對Teacher類進(jìn)行序列化，但是對Teacher沒有實現(xiàn)序列化接口，因此拋出NotSerializableException異常。所以如果某個序列化類的成員變量是對象類型，則該對象類型的類必須實現(xiàn)序列化。

子類實現(xiàn)了Serializable，父類沒有實現(xiàn)Serializable接口的話，父類不會被序列化。

子類Student實現(xiàn)了Serializable接口，父類User沒有實現(xiàn)Serializable接口。

  1.   //父類實現(xiàn)了Serializable接口 
  2.   public class Student  extends User implements Serializable { 
  3.    
  4.       private Integer age; 
  5.       private String name; 
  6.   } 
  7.   //父類沒有實現(xiàn)Serializable接口 
  8.   public class User { 
  9.       String userId; 
  10.  } 
  11.   
  12.  Student student = new Student(); 
  13.  student.setAge(25); 
  14.  student.setName("jayWei"); 
  15.  student.setUserId("1"); 
  16.   
  17.  ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:\\text.out")); 
  18.  objectOutputStream.writeObject(student); 
  19.  
  20.  objectOutputStream.flush(); 
  21.  objectOutputStream.close(); 
  22.   
  23.  //反序列化結(jié)果 
  24.  ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("D:\\text.out")); 
  25.  Student student1 = (Student) objectInputStream.readObject(); 
  26.  System.out.println(student1.getUserId()); 
  27.  //output 
  28.  /** 
  29.   * null 
  30.   */ 

從反序列化結(jié)果，可以發(fā)現(xiàn)，父類屬性值丟失了。因此子類實現(xiàn)了Serializable接口，父類沒有實現(xiàn)Serializable接口的話，父類不會被序列化。

八、序列化常見面試題

  • 序列化的底層是怎么實現(xiàn)的?
  • 序列化時，如何讓某些成員不要序列化?
  • 在 Java 中,Serializable 和 Externalizable 有什么區(qū)別
  • serialVersionUID有什么用?
  • 是否可以自定義序列化過程, 或者是否可以覆蓋 Java 中的默認(rèn)序列化過程?
  • 在 Java 序列化期間,哪些變量未序列化?

1.序列化的底層是怎么實現(xiàn)的?

本文第六小節(jié)可以回答這個問題，如回答Serializable關(guān)鍵字作用，序列化標(biāo)志啦，源碼中，它的作用啦~還有，可以回答writeObject幾個核心方法，如直接寫入基本類型，獲取obj類型數(shù)據(jù)，循環(huán)遞歸寫入，哈哈~

2.序列化時，如何讓某些成員不要序列化?

可以用transient關(guān)鍵字修飾，它可以阻止修飾的字段被序列化到文件中，在被反序列化后，transient 字段的值被設(shè)為初始值，比如int型的值會被設(shè)置為 0，對象型初始值會被設(shè)置為null。

3.在Java中,Serializable 和 Externalizable 有什么區(qū)別

Externalizable繼承了Serializable，給我們提供 writeExternal() 和 readExternal() 方法, 讓我們可以控制 Java的序列化機(jī)制, 不依賴于Java的默認(rèn)序列化。正確實現(xiàn) Externalizable 接口可以顯著提高應(yīng)用程序的性能。

4.serialVersionUID有什么用?

可以看回本文第七小節(jié)哈，JAVA序列化的機(jī)制是通過判斷類的serialVersionUID來驗證版本是否一致的。在進(jìn)行反序列化時，JVM會把傳來的字節(jié)流中的serialVersionUID和本地相應(yīng)實體類的serialVersionUID進(jìn)行比較，如果相同，反序列化成功，如果不相同，就拋出InvalidClassException異常。

5.是否可以自定義序列化過程, 或者是否可以覆蓋 Java 中的默認(rèn)序列化過程?

可以的。我們都知道,對于序列化一個對象需調(diào)用 ObjectOutputStream.writeObject(saveThisObject), 并用 ObjectInputStream.readObject() 讀取對象, 但 Java 虛擬機(jī)為你提供的還有一件事, 是定義這兩個方法。如果在類中定義這兩種方法, 則 JVM 將調(diào)用這兩種方法, 而不是應(yīng)用默認(rèn)序列化機(jī)制。同時，可以聲明這些方法為私有方法，以避免被繼承、重寫或重載。

6.在Java序列化期間，哪些變量未序列化?

static靜態(tài)變量和transient 修飾的字段是不會被序列化的。靜態(tài)(static)成員變量是屬于類級別的，而序列化是針對對象的。transient關(guān)鍵字修飾字段，可以阻止該字段被序列化到文件中。

 

責(zé)任編輯：華軒 來源： 撿田螺的小男孩
Java開發(fā)序列化
相關(guān)推薦

2020-08-11 07:31:39

JavaVolatile模型

2009-12-21 15:48:29

WCF應(yīng)用程序

2016-12-14 14:43:11

ButterknifeAndroid

2020-01-12 19:10:30

Java程序員數(shù)據(jù)

2009-06-25 09:33:43

Java API程序員

2009-08-24 10:39:12

思科認(rèn)證CCNA思科認(rèn)證CCNA

2009-09-17 09:01:10

CCNA學(xué)習(xí)指南CCNA

2011-06-15 14:33:13

2011-04-27 10:31:38

Java

2018-03-19 10:20:23

Java序列化反序列化

2020-05-09 11:20:02

Java結(jié)構(gòu)圖虛擬機(jī)

2019-09-25 11:39:07

程序員編程技術(shù)

2022-10-24 09:00:47

畫圖工具程序員XMind

2022-08-06 08:41:18

序列化反序列化Hessian

2014-08-15 14:25:48

Android程序員資源

2014-08-20 10:28:29

Android

2011-06-11 20:59:12

程序員

2020-05-06 15:59:07

JavaScript程序員技術(shù)

2013-03-11 13:55:03

JavaJSON

2009-09-09 16:30:59

C# BinaryFo
點(diǎn)贊
收藏

51CTO技術(shù)棧公眾號