Java 对象序列化

来源：互联网发布：淘宝详情页ps怎么设计编辑：程序博客网时间：2024/05/21 13:59

Java 对象序列化

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

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

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

清单 1. Serializable Person

[java] view plaincopyprint?
package com.tedneward;  
  
public class Person  
    implements java.io.Serializable  
{  
    public Person(String fn, String ln, int a)  
    {  
        this.firstName = fn; this.lastName = ln; this.age = a;  
    }  
  
    public String getFirstName() { return firstName; }  
    public String getLastName() { return lastName; }  
    public int getAge() { return age; }  
    public Person getSpouse() { return spouse; }  
  
    public void setFirstName(String value) { firstName = value; }  
    public void setLastName(String value) { lastName = value; }  
    public void setAge(int value) { age = value; }  
    public void setSpouse(Person value) { spouse = value; }  
  
    public String toString()  
    {  
        return "[Person: firstName=" + firstName +   
            " lastName=" + lastName +  
            " age=" + age +  
            " spouse=" + spouse.getFirstName() +  
            "]";  
    }      
  
    private String firstName;  
    private String lastName;  
    private int age;  
    private Person spouse;  
  
}   

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

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

[java] view plaincopyprint?
public class SerTest  
{  
    @Test public void serializeToDisk()  
    {  
        try  
        {  
            com.tedneward.Person ted = new com.tedneward.Person("Ted", "Neward", 39);  
            com.tedneward.Person charl = new com.tedneward.Person("Charlotte",  
                "Neward", 38);  
  
            ted.setSpouse(charl); charl.setSpouse(ted);  
  
            FileOutputStream fos = new FileOutputStream("tempdata.ser");  
            ObjectOutputStream oos = new ObjectOutputStream(fos);  
            oos.writeObject(ted);  
            oos.close();  
        }  
        catch (Exception ex)  
        {  
            fail("Exception thrown during test: " + ex.toString());  
        }  
          
        try  
        {  
            FileInputStream fis = new FileInputStream("tempdata.ser");  
            ObjectInputStream ois = new ObjectInputStream(fis);  
            com.tedneward.Person ted = (com.tedneward.Person) ois.readObject();  
            ois.close();  
              
            assertEquals(ted.getFirstName(）， "Ted");  
            assertEquals(ted.getSpouse().getFirstName(）， "Charlotte");  
  
            // Clean up the file  
            new File("tempdata.ser").delete();  
        }  
        catch (Exception ex)  
        {  
            fail("Exception thrown during test: " + ex.toString());  
        }  
    }  
}  

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

1. 序列化允许重构

序列化允许一定数量的类变种，甚至重构之后也是如此，ObjectInputStream 仍可以很好地将其读出来。

Java Object Serialization 规范可以自动管理的关键任务是：

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

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

重构序列化类

既然已经知道序列化允许重构，我

们来看看当把新字段添加到 Person 类中时，会发生什么事情。

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

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

[java] view plaincopyprint?
enum Gender  
{  
    MALE, FEMALE  
}  
  
public class Person  
    implements java.io.Serializable  
{  
    public Person(String fn, String ln, int a, Gender g)  
    {  
        this.firstName = fn; this.lastName = ln; this.age = a; this.gender = g;  
    }  
    
    public String getFirstName() { return firstName; }  
    public String getLastName() { return lastName; }  
    public Gender getGender() { return gender; }  
    public int getAge() { return age; }  
    public Person getSpouse() { return spouse; }  
  
    public void setFirstName(String value) { firstName = value; }  
    public void setLastName(String value) { lastName = value; }  
    public void setGender(Gender value) { gender = value; }  
    public void setAge(int value) { age = value; }  
    public void setSpouse(Person value) { spouse = value; }  
  
    public String toString()  
    {  
        return "[Person: firstName=" + firstName +   
            " lastName=" + lastName +  
            " gender=" + gender +  
            " age=" + age +  
            " spouse=" + spouse.getFirstName() +  
            "]";  
    }      
  
    private String firstName;  
    private String lastName;  
    private int age;  
    private Person spouse;  
    private Gender gender;  
}  

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

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

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

最近做的一个需求——大批会员权限开放，就是利用了这一点，目前线上run的是一期的版本，后来在dubbo服务化中心一个类新加一个字段（sourcetype），需求发布时新的应用如wholesale,tradebops重新编译，采用的是新的param类，而magam仍然采用的是之前的版本（即没有sourcetype），但调用dubbo的接口时没有报错，就是因为这个原因。

2. 序列化并不安全

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

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

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

模糊化序列化数据

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

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

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

[java] view plaincopyprint?
public class Person  
    implements java.io.Serializable  
{  
    public Person(String fn, String ln, int a)  
    {  
        this.firstName = fn; this.lastName = ln; this.age = a;  
    }  
  
    public String getFirstName() { return firstName; }  
    public String getLastName() { return lastName; }  
    public int getAge() { return age; }  
    public Person getSpouse() { return spouse; }  
      
    public void setFirstName(String value) { firstName = value; }  
    public void setLastName(String value) { lastName = value; }  
    public void setAge(int value) { age = value; }  
    public void setSpouse(Person value) { spouse = value; }  
  
    private void writeObject(java.io.ObjectOutputStream stream)  
        throws java.io.IOException  
    {  
        // "Encrypt"/obscure the sensitive data  
        age = age << 2;  
        stream.defaultWriteObject();  
    }  
  
    private void readObject(java.io.ObjectInputStream stream)  
        throws java.io.IOException, ClassNotFoundException  
    {  
        stream.defaultReadObject();  
  
        // "Decrypt"/de-obscure the sensitive data  
        age = age << 2;  
    }  
      
    public String toString()  
    {  
        return "[Person: firstName=" + firstName +   
            " lastName=" + lastName +  
            " age=" + age +  
            " spouse=" + (spouse!=null ? spouse.getFirstName() : "[null]") +  
            "]";  
    }        
  
    private String firstName;  
    private String lastName;  
    private int age;  
    private Person spouse;  
}  

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