关于Java对象序列化您不知道的5件事

数年前，当和一个软件团队一起用 Java 语言编写一个应用程序时，我体会到比一般程序员多知道一点关于 Java 对象序列化的知识所带来的好处。

创新互联建站专注为客户提供全方位的互联网综合服务，包含不限于网站设计、网站建设、克山网络推广、微信小程序开发、克山网络营销、克山企业策划、克山品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等，从售前售中售后，我们都将竭诚为您服务，您的肯定，是我们最大的嘉奖；创新互联建站为所有大学生创业者提供克山建站搭建服务，24小时服务热线：18982081108，官方网址：www.cdcxhl.com

大约一年前，一个负责管理应用程序所有用户设置的开发人员，决定将用户设置存储在一个 Hashtable 中，然后将这个 Hashtable 序列化到磁盘，以便持久化。当用户更改设置时，便重新将 Hashtable 写到磁盘。

这是一个优雅的、开放式的设置系统，但是，当团队决定从 Hashtable 迁移到 Java Collections 库中的 HashMap 时，这个系统便面临崩溃。

Hashtable 和 HashMap 在磁盘上的格式是不相同、不兼容的。除非对每个持久化的用户设置运行某种类型的数据转换实用程序(极其庞大的任务)，否则以后似乎只能一直用 Hashtable 作为应用程序的存储格式。

团队感到陷入僵局，但这只是因为他们不知道关于 Java 序列化的一个重要事实：Java 序列化允许随着时间的推移而改变类型。当我向他们展示如何自动进行序列化替换后，他们终于按计划完成了向 HashMap 的转变。

本文是本系列的第一篇文章，这个系列专门揭示关于 Java 平台的一些有用的小知识 — 这些小知识不易理解，但对于解决 Java 编程挑战迟早有用。

将 Java 对象序列化 API 作为开端是一个不错的选择，因为它从一开始就存在于 JDK 1.1 中。本文介绍的关于序列化的 5 件事情将说服您重新审视那些标准 Java API。

Java 序列化简介

Java 对象序列化是 JDK 1.1 中引入的一组开创性特性之一，用于作为一种将 Java 对象的状态转换为字节数组，以便存储或传输的机制，以后，仍可以将字节数组转换回 Java 对象原有的状态。

实际上，序列化的思想是 “冻结” 对象状态，传输对象状态(写到磁盘、通过网络传输等等)，然后 “解冻” 状态，重新获得可用的 Java 对象。所有这些事情的发生有点像是魔术，这要归功于 ObjectInputStream/ObjectOutputStream 类、完全保真的元数据以及程序员愿意用 Serializable 标识接口标记他们的类，从而 “参与” 这个过程。

清单 1 显示一个实现 Serializable 的 Person 类。

清单 1. Serializable Person

 
 
 
    
  
  
  
  1. package com.tedneward;  
    2.   
  
  
  2. public class Person  
    3.   
  
  
  3. implements java.io.Serializable  
    4.   
  
  
  4. {  
    5.   
  
  
  5. public Person(String fn, String ln, int a)  
    6.   
  
  
  6. {  
    7.   
  
  
  7. this.firstName = fn; this.lastName = ln; this.age = a;  
    8.   
  
  
  8. }  
    9.   
  
  
  9. public String getFirstName() { return firstName; }  
    10.   
  
  
  10. public String getLastName() { return lastName; }  
    11.   
  
  
  11. public int getAge() { return age; }  
    12.   
  
  
  12. public Person getSpouse() { return spouse; }  
    13.   
  
  
  13. public void setFirstName(String value) { firstName = value; }  
    14.   
  
  
  14. public void setLastName(String value) { lastName = value; }  
    15.   
  
  
  15. public void setAge(int value) { age = value; }  
    16.   
  
  
  16. public void setSpouse(Person value) { spouse = value; }  
    17.   
  
  
  17. public String toString()  
    18.   
  
  
  18. {  
    19.   
  
  
  19. return "[Person: firstName=" + firstName +  
    20.   
  
  
  20. " lastName=" + lastName +  
    21.   
  
  
  21. " age=" + age +  
    22.   
  
  
  22. " spouse=" + spouse.getFirstName() +  
    23.   
  
  
  23. "]";  
    24.   
  
  
  24. }  
    25.   
  
  
  25. private String firstName;  
    26.   
  
  
  26. private String lastName;  
    27.   
  
  
  27. private int age;  
    28.   
  
  
  28. private Person spouse;  
    29.   
  
  
  29. ｝ 
    30.

将 Person 序列化后，很容易将对象状态写到磁盘，然后重新读出它，下面的 JUnit 4 单元测试对此做了演示。

清单 2. 对 Person 进行反序列化

 
 
 
    
  
  
  
  1. public class SerTest  
    2.   
  
  
  2. {  
    3.   
  
  
  3. @Test public void serializeToDisk()  
    4.   
  
  
  4. {  
    5.   
  
  
  5. try 
    6.   
  
  
  6. {  
    7.   
  
  
  7. com.tedneward.Person ted = new com.tedneward.Person("Ted", "Neward", 39);  
    8.   
  
  
  8. com.tedneward.Person charl = new com.tedneward.Person("Charlotte",  
    9.   
  
  
  9. "Neward", 38);  
    10.   
  
  
  10. ted.setSpouse(charl); charl.setSpouse(ted);  
    11.   
  
  
  11. FileOutputStream fos = new FileOutputStream("tempdata.ser");  
    12.   
  
  
  12. ObjectOutputStream oos = new ObjectOutputStream(fos);  
    13.   
  
  
  13. oos.writeObject(ted);  
    14.   
  
  
  14. oos.close();  
    15.   
  
  
  15. }  
    16.   
  
  
  16. catch (Exception ex)  
    17.   
  
  
  17. {  
    18.   
  
  
  18. fail("Exception thrown during test: " + ex.toString());  
    19.   
  
  
  19. }  
    20.   
  
  
  20. try 
    21.   
  
  
  21. {  
    22.   
  
  
  22. FileInputStream fis = new FileInputStream("tempdata.ser");  
    23.   
  
  
  23. ObjectInputStream ois = new ObjectInputStream(fis);  
    24.   
  
  
  24. com.tedneward.Person ted = (com.tedneward.Person) ois.readObject();  
    25.   
  
  
  25. ois.close();  
    26.   
  
  
  26. assertEquals(ted.getFirstName(）， "Ted");  
    27.   
  
  
  27. assertEquals(ted.getSpouse().getFirstName(）， "Charlotte");  
    28.   
  
  
  28. // Clean up the file  
    29.   
  
  
  29. new File("tempdata.ser").delete();  
    30.   
  
  
  30. }  
    31.   
  
  
  31. catch (Exception ex)  
    32.   
  
  
  32. {  
    33.   
  
  
  33. fail("Exception thrown during test: " + ex.toString());  
    34.   
  
  
  34. }  
    35.   
  
  
  35. }  
    36.   
  
  
  36. } 
    37.

#p#

到现在为止，还没有看到什么新鲜的或令人兴奋的事情，但是这是一个很好的出发点。我们将使用 Person 来发现您可能不 知道的关于 Java 对象序列化 的 5 件事。

1. 序列化允许重构

序列化允许一定数量的类变种，甚至重构之后也是如此，ObjectInputStream 仍可以很好地将其读出来。Java Object Serialization 规范可以自动管理的关键任务是：

  • 将新字段添加到类中
  • 将字段从 static 改为非 static
  • 将字段从 transient 改为非 transient

取决于所需的向后兼容程度，转换字段形式(从非 static 转换为 static 或从非 transient 转换为 transient)或者删除字段需要额外的消息传递。

重构序列化类

既然已经知道序列化允许重构，我们来看看当把新字段添加到 Person 类中时，会发生什么事情。

如清单 3 所示，PersonV2 在原先 Person 类的基础上引入一个表示性别的新字段。

清单 3. 将新字段添加到序列化的 Person 中

 
 
 
    
  
  
  
  1. enum Gender  
    2.   
  
  
  2. {  
    3.   
  
  
  3. MALE, FEMALE  
    4.   
  
  
  4. }  
    5.   
  
  
  5. public class Person  
    6.   
  
  
  6. implements java.io.Serializable  
    7.   
  
  
  7. {  
    8.   
  
  
  8. public Person(String fn, String ln, int a, Gender g)  
    9.   
  
  
  9. {  
    10.   
  
  
  10. this.firstName = fn; this.lastName = ln; this.age = a; this.gender = g;  
    11.   
  
  
  11. }  
    12.   
  
  
  12. public String getFirstName() { return firstName; }  
    13.   
  
  
  13. public String getLastName() { return lastName; }  
    14.   
  
  
  14. public Gender getGender() { return gender; }  
    15.   
  
  
  15. public int getAge() { return age; }  
    16.   
  
  
  16. public Person getSpouse() { return spouse; }  
    17.   
  
  
  17. public void setFirstName(String value) { firstName = value; }  
    18.   
  
  
  18. public void setLastName(String value) { lastName = value; }  
    19.   
  
  
  19. public void setGender(Gender value) { gender = value; }  
    20.   
  
  
  20. public void setAge(int value) { age = value; }  
    21.   
  
  
  21. public void setSpouse(Person value) { spouse = value; }  
    22.   
  
  
  22. public String toString()  
    23.   
  
  
  23. {  
    24.   
  
  
  24. return "[Person: firstName=" + firstName +  
    25.   
  
  
  25. " lastName=" + lastName +  
    26.   
  
  
  26. " gender=" + gender +  
    27.   
  
  
  27. " age=" + age +  
    28.   
  
  
  28. " spouse=" + spouse.getFirstName() +  
    29.   
  
  
  29. "]";  
    30.   
  
  
  30. }  
    31.   
  
  
  31. private String firstName;  
    32.   
  
  
  32. private String lastName;  
    33.   
  
  
  33. private int age;  
    34.   
  
  
  34. private Person spouse;  
    35.   
  
  
  35. private Gender gender;  
    36.   
  
  
  36. } 
    37.

序列化使用一个 hash，该 hash 是根据给定源文件中几乎所有东西 — 方法名称、字段名称、字段类型、访问修改方法等 — 计算出来的，序列化将该 hash 值与序列化流中的 hash 值相比较。

为了使 Java 运行时相信两种类型实际上是一样的，第二版和随后版本的 Person 必须与第一版有相同的序列化版本 hash(存储为 private static final serialVersionUID 字段)。因此，我们需要 serialVersionUID 字段，它是通过对原始(或 V1)版本的 Person 类运行 JDK serialver 命令计算出的。

一旦有了 Person 的 serialVersionUID，不仅可以从原始对象 Person 的序列化数据创建 PersonV2 对象(当出现新字段时，新字段被设为缺省值，最常见的是“null”)，还可以反过来做：即从 PersonV2 的数据通过反序列化得到 Person，这毫不奇怪。

2. 序列化并不安全

让 Java 开发人员诧异并感到不快的是，序列化二进制格式完全编写在文档中，并且完全可逆。实际上，只需将二进制序列化流的内容转储到控制台，就足以看清类是什么样子，以及它包含什么内容。

这对于安全性有着不良影响。例如，当通过 RMI 进行远程方法调用时，通过连接发送的对象中的任何 private 字段几乎都是以明文的方式出现在套接字流中，这显然容易招致哪怕最简单的安全问题。

幸运的是，序列化允许 “hook” 序列化过程，并在序列化之前和反序列化之后保护(或模糊化)字段数据。可以通过在 Serializable 对象上提供一个 writeObject 方法来做到这一点。

模糊化序列化数据

假设 Person 类中的敏感数据是 age 字段。毕竟，女士忌谈年龄。我们可以在序列化之前模糊化该数据，将数位循环左移一位，然后在反序列化之后复位。(您可以开发更安全的算法，当前这个算法只是作为一个例子。)

为了 “hook” 序列化过程，我们将在 Person 上实现一个 writeObject 方法;为了 “hook” 反序列化过程，我们将在同一个类上实现一个 readObject 方法。重要的是这两个方法的细节要正确 — 如果访问修改方法、参数或名称不同于清单 4 中的内容，那么代码将不被察觉地失败，Person 的 age 将暴露。

清单 4. 模糊化序列化数据

 
 
 
    
  
  
  
  1. public class Person  
    2.   
  
  
  2. implements java.io.Serializable  
    3.   
  
  
  3. {  
    4.   
  
  
  4. public Person(String fn, String ln, int a)  
    5.   
  
  
  5. {  
    6.   
  
  
  6. this.firstName = fn; this.lastName = ln; this.age = a;  
    7.   
  
  
  7. }  
    8.   
  
  
  8. public String getFirstName() { return firstName; }  
    9.   
  
  
  9. public String getLastName() { return lastName; }  
    10.   
  
  
  10. public int getAge() { return age; }  
    11.   
  
  
  11. public Person getSpouse() { return spouse; }  
    12.   
  
  
  12. public void setFirstName(String value) { firstName = value; }  
    13.   
  
  
  13. public void setLastName(String value) { lastName = value; }  
    14.   
  
  
  14. public void setAge(int value) { age = value; }  
    15.   
  
  
  15. public void setSpouse(Person value) { spouse = value; }  
    16.   
  
  
  16. private void writeObject(java.io.ObjectOutputStream stream)  
    17.   
  
  
  17. throws java.io.IOException  
    18.   
  
  
  18. {  
    19.   
  
  
  19. // "Encrypt"/obscure the sensitive data  
    20.   
  
  
  20. age = age << 2;  
    21.   
  
  
  21. stream.defaultWriteObject();  
    22.   
  
  
  22. }  
    23.   
  
  
  23. private void readObject(java.io.ObjectInputStream stream)  
    24.   
  
  
  24. throws java.io.IOException, ClassNotFoundException  
    25.   
  
  
  25. {  
    26.   
  
  
  26. stream.defaultReadObject();  
    27.   
  
  
  27. // "Decrypt"/de-obscure the sensitive data  
    28.   
  
  
  28. age = age << 2;  
    29.   
  
  
  29. }  
    30.   
  
  
  30. public String toString()  
    31.   
  
  
  31. {  
    32.   
  
  
  32. return "[Person: firstName=" + firstName +  
    33.   
  
  
  33. " lastName=" + lastName +  
    34.   
  
  
  34. " age=" + age +  
    35.   
  
  
  35. " spouse=" + (spouse!=null ? spouse.getFirstName() : "[null]") +  
    36.   
  
  
  36. "]";  
    37.   
  
  
  37. }  
    38.   
  
  
  38. private String firstName;  
    39.   
  
  
  39. private String lastName;  
    40.   
  
  
  40. private int age;  
    41.   
  
  
  41. private Person spouse;  
    42.   
  
  
  42. } 
    43.

如果需要查看被模糊化的数据，总是可以查看序列化数据流/文件。而且，由于该格式被完全文档化，即使不能访问类本身，也仍可以读取序列化流中的内容。

#p#

3、序列化的数据可以被签名和密封上一个技巧假设您想模糊化序列化数据，而不是对其加密或者确保它不被修改。当然，通过使用 writeObject 和 readObject 可以实现密码加密和签名管理，但其实还有更好的方式。

如果需要对整个对象进行加密和签名，最简单的是将它放在一个 javax.crypto.SealedObject 和/或 java.security.SignedObject 包装器中。两者都是可序列化的，所以将对象包装在 SealedObject 中可以围绕原对象创建一种 “包装盒”。必须有对称密钥才能解密，而且密钥必须单独管理。同样，也可以将 SignedObject 用于数据验证，并且对称密钥也必须单独管理。

结合使用这两种对象，便可以轻松地对序列化数据进行密封和签名，而不必强调关于数字签名验证或加密的细节。很简洁，是吧?

4. 序列化允许将代理放在流中

很多情况下，类中包含一个核心数据元素，通过它可以派生或找到类中的其他字段。在此情况下，没有必要序列化整个对象。可以将字段标记为 transient，但是每当有方法访问一个字段时，类仍然必须显式地产生代码来检查它是否被初始化。

如果首要问题是序列化，那么最好指定一个 flyweight 或代理放在流中。为原始 Person 提供一个 writeReplace 方法，可以序列化不同类型的对象来代替它。类似地，如果反序列化期间发现一个 readResolve 方法，那么将调用该方法，将替代对象提供给调用者。

打包和解包代理

writeReplace 和 readResolve 方法使 Person 类可以将它的所有数据(或其中的核心数据)打包到一个 PersonProxy 中，将它放入到一个流中，然后在反序列化时再进行解包。

清单 5. 你完整了我，我代替了你

 
 
 
    
  
  
  
  1. class PersonProxy  
    2.   
  
  
  2. implements java.io.Serializable  
    3.   
  
  
  3. {  
    4.   
  
  
  4. public PersonProxy(Person orig)  
    5.   
  
  
  5. {  
    6.   
  
  
  6. data = orig.getFirstName() + "," + orig.getLastName()+ "," + orig.getAge();  
    7.   
  
  
  7. if (orig.getSpouse() != null)  
    8.   
  
  
  8. {  
    9.   
  
  
  9. Person spouse = orig.getSpouse();  
    10.   
  
  
  10. data = data + "," + spouse.getFirstName() + "," + spouse.getLastName() + ","+ spouse.getAge();  
    11.   
  
  
  11. }  
    12.   
  
  
  12. }  
    13.   
  
  
  13. public String data;  
    14.   
  
  
  14. private Object readResolve()  
    15.   
  
  
  15. throws java.io.ObjectStreamException  
    16.   
  
  
  16. {  
    17.   
  
  
  17. String[] pieces = data.split(",");  
    18.   
  
  
  18. Person result = new Person(pieces[0], pieces[1], Integer.parseInt(pieces[2]));  
    19.   
  
  
  19. if (pieces.length > 3)  
    20.   
  
  
  20. {  
    21.   
  
  
  21. result.setSpouse(new Person(pieces[3], pieces[4], Integer.parseInt  
    22.   
  
  
  22. (pieces[5])));  
    23.   
  
  
  23. result.getSpouse().setSpouse(result);  
    24.   
  
  
  24. }  
    25.   
  
  
  25. return result;  
    26.   
  
  
  26. }  
    27.   
  
  
  27. }  
    28.   
  
  
  28. public class Person  
    29.   
  
  
  29. implements java.io.Serializable  
    30.   
  
  
  30. {  
    31.   
  
  
  31. public Person(String fn, String ln, int a){  
    32.   
  
  
  32. this.firstName = fn; this.lastName = ln; this.age = a;  
    33.   
  
  
  33. }  
    34.   
  
  
  34. public String getFirstName() { return firstName; }  
    35.   
  
  
  35. public String getLastName() { return lastName; }  
    36.   
  
  
  36. public int getAge() { return age; }  
    37.   
  
  
  37. public Person getSpouse() { return spouse; }  
    38.   
  
  
  38. private Object writeReplace()  
    39.   
  
  
  39. throws java.io.ObjectStreamException  
    40.   
  
  
  40. {  
    41.   
  
  
  41. return new PersonProxy(this);  
    42.   
  
  
  42. }  
    43.   
  
  
  43. public void setFirstName(String value) { firstName = value; }  
    44.   
  
  
  44. public void setLastName(String value) { lastName = value; }  
    45.   
  
  
  45. public void setAge(int value) { age = value; }  
    46.   
  
  
  46. public void setSpouse(Person value) { spouse = value; }  
    47.   
  
  
  47. public String toString()  
    48.   
  
  
  48. {  
    49.   
  
  
  49. return "[Person: firstName=" + firstName +  
    50.   
  
  
  50. " lastName=" + lastName +  
    51.   
  
  
  51. " age=" + age +  
    52.   
  
  
  52. " spouse=" + spouse.getFirstName() +  
    53.   
  
  
  53. "]";  
    54.   
  
  
  54. }  
    55.   
  
  
  55. private String firstName;  
    56.   
  
  
  56. private String lastName;  
    57.   
  
  
  57. private int age;  
    58.   
  
  
  58. private Person spouse;  
    59.   
  
  
  59. } 
    60.

5. 信任，但要验证

认为序列化流中的数据总是与最初写到流中的数据一致，这没有问题。但是，正如一位美国前总统所说的，“信任，但要验证”。

对于序列化的对象，这意味着验证字段，以确保在反序列化之后它们仍具有正确的值，“以防万一”。为此，可以实现 ObjectInputValidation 接口，并覆盖 validateObject() 方法。如果调用该方法时发现某处有错误，则抛出一个 InvalidObjectException。

网站栏目：关于Java对象序列化您不知道的5件事
URL链接：http://www.shufengxianlan.com/qtweb/news23/146823.html

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

广告

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

猜你还喜欢下面的内容

做网站知识

各行业网站

名片印刷厂　　 　成都免费做网站　　 　平武做网站　　 　成都广告设计　　 　成都微信开发　　 　成都网站运营维护　　 　网站定制　　 　资阳服务器托管　　 　成都网站制作　　 　成都网站建设公司　　 　成都西云机房　　 　黔盛装饰　　 　成都网站改版　　 　成都企业网站改版　　 　成都名片印刷厂　　 　Android开发　　 　网站改版　　 　广汉锦华建材　　 　和正源建设　　 　成都服务器租用