一文搞懂Java中的序列化與反序列化
序列化和反序列化的概念
當我們在Java中創建對象的時候,對象會一直存在,直到程序終止時。但有時候可能存在一種"持久化"場景:我們需要讓對象能夠在程序不運行的情況下,仍能存在並保存其信息。當程序再次運行時 還可以通過該對象的保存下來的信息 來重建該對象。序列化和反序列化 就應運而生瞭,序列化機制可以使對象可以脫離程序的運行而獨立存在。
- 序列化: 將對象轉換成二進制字節流的過程
- 反序列化:從二進制字節流中恢復對象的過程
應用場景
- 對象在進行網絡傳輸的時候,需要先被序列化,接收到序列化的對象之後需要再進行反序列化;比如遠程方法調用 RPC
- 將對象存儲到文件中的時候需要進行序列化,將對象從文件中讀取出來需要進行反序列化。
- 將對象存儲到內存中,需要進行序列化,將對象從內存中讀取出來需要進行反序列化。
- 將對象存儲到數據庫(如 Redis)時,需要用到序列化,將對象從緩存數據庫中讀取出來需要反序列化。
序列化實現的方式
如果使用Jdk自帶的序列化方式實現對象序列化的話,那麼這個類應該實現Serializable接口或者Externalizable接口
繼承Serializable接口,普通序列化
首先我們定義一個對象類User
public class User implements Serializable { //序列化ID private static final long serialVersionUID = 1L; private int age; private String name; public User(int age, String name) { this.age = age; this.name = name; } public static long getSerialVersionUID() { return serialVersionUID; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } }
然後我們編寫一下測試類:
public class serTest { public static void main(String[] args) throws Exception, IOException { SerializeUser(); DeSerializeUser(); } /** * 序列化方法 * @throws IOException */ private static void SerializeUser() throws IOException { User user = new User(11, "小張"); //序列化對象到指定的文件中 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\jun\\Desktop\\example")); oos.writeObject(user); oos.close(); System.out.println("序列化對象成功"); } /** * 反序列化方法 * @throws IOException * @throws ClassNotFoundException */ private static void DeSerializeUser() throws IOException, ClassNotFoundException { //讀取指定的文件 File file = new File("C:\\Users\\jun\\Desktop\\example"); ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file)); User newUser = (User)ois.readObject(); System.out.println("反序列化對象成功:"+ newUser.getName()+ ","+newUser.getAge()); } }
結果:
序列化對象成功
反序列化對象成功:小張,11
一個對象想要被序列化,那麼它的類就要繼承Serializable接口
或者它的子接口
繼承Serializable接口
類的所有屬性(包括private屬性、包括其引用的對象)都可以被序列化和反序列化來保存、傳遞。如果不想序列化的字段可以使用transient
關鍵字修飾
private int age; private String name; private transient password;//屬性:密碼,不想被序列化
我們需要註意的是:使用transient
關鍵字阻止序列化雖然簡單方便,但被它修飾的屬性被完全隔離在序列化機制之外,這必然會導致瞭在反序列化時無法獲取該屬性的值。
其實我們完全可以在通過在需要序列化的對象的Java類裡加入writeObject()方法
與readObject()方法
來控制如何序列化各屬性,某些屬性是否被序列化
如果User有一個屬性是引用類型的呢?比如User其中有一個屬性是類Person:
private Person person;
那如果要想User可以序列化,那Person類也必須得繼承Serializable接口
,不然程序會報錯
另外大傢應該註意到serialVersionUID
瞭吧,在日常開發的過程中,經常遇到,暫且放放,我們後文再詳細講解
繼承Externalizable接口,強制自定義序列化
對於Externalizable接口,我們需要知道以下幾點:
- Externalizable繼承自Serializable接口
- 需要我們重寫writeExternal()與readExternal()方法,這是強制性的
- 實現Externalizable接口的類必須要提供一個public的無參的構造器,因為反序列化的時候需要反射創建對象
- Externalizable接口實現序列化,性能稍微比繼承自Serializable接口好一點
首先我們定義一個對象類ExUser
public class ExUser implements Externalizable { private int age; private String name; //註意,必須加上pulic 無參構造器 public ExUser() { } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public void writeExternal(ObjectOutput out) throws IOException { out.writeObject(name); out.writeInt(age); } @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { this.name = (String)in.readObject(); this.age = in.readInt(); } }
我們接著編寫測試類:
public class serTest2 { public static void main(String[] args) throws Exception, IOException { SerializeUser(); DeSerializeUser(); } /** * 序列化方法 * @throws IOException */ private static void SerializeUser() throws IOException { ExUser user = new ExUser(); user.setAge(10); user.setName("小王"); //序列化對象到指定的文件中 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\jun\\Desktop\\example")); oos.writeObject(user); oos.close(); System.out.println("序列化對象成功"); } /** * 反序列化方法 * @throws IOException * @throws ClassNotFoundException */ private static void DeSerializeUser() throws IOException, ClassNotFoundException { File file = new File("C:\\Users\\jun\\Desktop\\example"); ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file)); ExUser newUser = (ExUser)ois.readObject(); System.out.println("反序列化對象成功:"+ newUser.getName()+ ","+newUser.getAge()); } }
結果:
序列化對象成功
反序列化對象成功:小王,10
因為序列化和反序列化方法需要自己實現,因此可以指定序列化哪些屬性,transient
關鍵字在這裡是無效的。
對Externalizable
對象反序列化時,會先調用類的無參構造方法,這是有別於默認反序列方式的。如果把類的不帶參數的構造方法刪除,或者把該構造方法的訪問權限設置為private
、默認或protected
級別,會拋出java.io.InvalidException: no valid constructor
異常,因此Externalizable
對象必須有默認構造函數,而且必需是public的。
serialVersionUID的作用
如果反序列化使用的serialVersionUID
與序列化時使用的serialVersionUID
不一致,會報InvalidCalssException
異常。這樣就保證瞭項目迭代升級前後的兼容性
serialVersionUID是序列化前後的唯一標識符,隻要版本號serialVersionUID相同,即使更改瞭序列化屬性,對象也可以正確被反序列化回來。
默認如果沒有人為顯式定義過serialVersionUID,那編譯器會為它自動聲明一個!
serialVersionUID有兩種顯式的生成方式:
- 默認的1L,比如:
private static final long serialVersionUID = 1L;
- 根據類名、接口名、成員方法及屬性等來生成一個64位的哈希字段,比如:
private static final long serialVersionUID = xxxxL;
靜態變量不會被序列化
凡是被static修飾的字段是不會被序列化的,我們來看一個例子:
//實體類 public class Student implements Serializable { private String name; public static Integer age;//靜態變量 public String getName() { return name; } public void setName(String name) { this.name = name; } public static Integer getAge() { return age; } public static void setAge(Integer age) { Student.age = age; } } //測試類 public class shallowCopyTest { public static void main(String[] args) throws Exception { Student student1 = new Student(); student1.age = 11; //序列化,將數據寫入指定的文件中 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\student1")); oos.writeObject(student1); oos.close(); Student student2 = new Student(); student2.age = 21; //序列化,將數據寫入指定的文件中 ObjectOutputStream oos2 = new ObjectOutputStream(new FileOutputStream("D:\\student2")); oos2.writeObject(student1); oos2.close(); //讀取指定的文件 File file = new File("D:\\student1"); ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file)); Student student1_new = (Student)ois.readObject(); System.out.println("反序列化對象,student1.age="+ student1_new.getAge()); //讀取指定的文件 File file2 = new File("D:\\student1"); ObjectInputStream ois2 = new ObjectInputStream(new FileInputStream(file2)); Student student2_new = (Student)ois2.readObject(); System.out.println("反序列化對象,student2.age="+ student2_new.getAge()); } }
結果:
反序列化對象,student1.age=21
反序列化對象,student2.age=21
為啥結果都是21
?
我們知道對象的序列化是操作的堆內存
中的數據,而靜態的變量又稱作類變量,其數據存放在方法區
裡,類一加載,就初始化瞭。
又因為靜態變量age
沒有被序列化,根本就沒寫入文件流中,所以我們打印的值其實一直都是當前Student類的靜態變量age
的值,而靜態變量又是所有的對象共享的一個變量,所以就都是21
使用序列化實現深拷貝
我們再來看一個例子:
//實體類 繼承Cloneable public class Person implements Serializable{ public String name;//姓名 public int height;//身高 public StringBuilder something; ...//省略 getter setter public Object deepClone() throws Exception{ // 序列化 ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bos); oos.writeObject(this); // 反序列化 ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); ObjectInputStream ois = new ObjectInputStream(bis); return ois.readObject(); } } //測試類,這邊類名筆者就不換瞭,在之前的基礎上改改 public class shallowCopyTest { public static void main(String[] args) throws Exception { Person p1 = new Person("小張", 180, new StringBuilder("今天天氣很好")); Person p2 = (Person)p1.deepClone(); System.out.println("對象是否相等:"+ (p1 == p2)); System.out.println("p1 屬性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething()); System.out.println("p2 屬性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething()); // change p1.setName("小王"); p1.setHeight(200); p1.getSomething().append(",適合出去玩"); System.out.println("...after p1 change...."); System.out.println("p1 屬性值=" + p1.getName()+ ","+ p1.getHeight() + ","+ p1.getSomething()); System.out.println("p2 屬性值=" + p2.getName()+ ","+ p2.getHeight() + ","+ p2.getSomething()); } }
結果:
對象是否相等:false
p1 屬性值=小張,180,今天天氣很好
p2 屬性值=小張,180,今天天氣很好
…after p1 change….
p1 屬性值=小王,200,今天天氣很好,適合出去玩
p2 屬性值=小張,180,今天天氣很好
詳見:Java中深拷貝,淺拷貝與引用拷貝的區別詳解
常見序列化協議對比
除瞭JDK 自帶的序列化方式,還有一些其他常見的序列化協議:
- 基於二進制: hessian、kyro、protostuff
- 文本類序列化方式: JSON 和 XML
采用哪種序列化方式,我們一般需要考慮序列化之後的數據大小,序列化的耗時,是否支持跨平臺、語言,或者公司團隊的技術積累。這邊就不展開講瞭,大傢感興趣自行去瞭解
小結
JDK自帶序列化方法一般有2種:繼承Serializable接口
和繼承Externalizable接口
static修飾的類變量、transient修飾的實例變量都不會被序列化。
序列化對象的引用類型成員變量,也必須是可序列化的
serialVersionUID 版本號是序列化和反序列化前後唯一標識,建議顯式定義
序列化和反序列化的過程其實是有漏洞的,因為從序列化到反序列化是有中間過程的,如果被別人拿到瞭中間字節流,然後加以偽造或者篡改,反序列化出來的對象會有一定風險。可以重寫readObject()方法,加以限制
除瞭JDK自帶序列化方法,還有hessian、kyro、protostuff、 JSON 和 XML等
到此這篇關於一文搞懂Java中的序列化與反序列化的文章就介紹到這瞭,更多相關Java序列化 反序列化內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet!