疯狂Java学习笔记（84）----------大约 Java 对象序列化，你不知道 5 事

几年前，。当一个软件团队一起用 Java 书面申请。我认识比一般程序猿多知道一点关于 Java 对象序列化的知识所带来的优点。

关于本系列

您认为自己懂 Java 编程？其实，大多数程序猿对于 Java 平台都是浅尝则止，仅仅学习了足以完毕手头上任务的知识而已。在本系列中，Ted Neward 深入挖掘 Java 平台的核心功能，揭示一些鲜为人知的事实，帮助您解决最棘手的编程挑战。

大约一年前，一个负责管理应用程序全部用户设置的开发者，决定将用户设置存储在一个 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

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 序列化后。非常easy将对象状态写到磁盘。然后又一次读出它，以下的 JUnit 4 单元測试对此做了演示。

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

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 中

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 final serialVersionUID 字段）。

因此。我们须要 serialVersionUID 字段，它是通过对原始（或 V1）版本号的 Person 类执行 JDK serialver命令计算出的。

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

2. 序列化并不安全

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

这对于安全性有着不良影响。

比如，当通过 RMI 进行远程方法调用时。通过连接发送的对象中的不论什么 private 字段差点儿都是以明文的方式出如今套接字流中，这显然easy招致哪怕最简单的安全问题。

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

模糊化序列化数据

如果 Person 类中的敏感数据是 age 字段。

毕竟，女士忌谈年龄。我们能够在序列化之前模糊化该数据，将数位循环左移一位。然后在反序列化之后复位。

（您能够开发更安全的算法，当前这个算法仅仅是作为一个样例。）

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

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

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;
}

假设须要查看被模糊化的数据，总是能够查看序列化数据流/文件。并且，因为该格式被全然文档化，即使不能訪问类本身，也仍能够读取序列化流中的内容。

3. 序列化的数据能够被签名和密封

上一个技巧如果您想模糊化序列化数据。而不是对其加密或者确保它不被改动。当然，通过使用 writeObject 和 readObject 能够实现password加密和签名管理。但事实上还有更好的方式。

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

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

4. 序列化同意将代理放在流中

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

假设首要问题是序列化，那么最好指定一个 flyweight 或代理放在流中。为原始 Person 提供一个 writeReplace 方法，能够序列化不同类型的对象来取代它。

类似地，假设反序列化期间发现一个 readResolve 方法，那么将调用该方法，将替代对象提供给调用者。

打包和解包代理

writeReplace 和 readResolve 方法使 Person 类能够将它的全部数据（或当中的核心数据）打包到一个 PersonProxy 中。将它放入到一个流中。然后在反序列化时再进行解包。

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

class PersonProxy
    implements java.io.Serializable
{
    public PersonProxy(Person orig)
    {
        data = orig.getFirstName() + "," + orig.getLastName() + "," + orig.getAge();
        if (orig.getSpouse() != null)
        {
            Person spouse = orig.getSpouse();
            data = data + "," + spouse.getFirstName() + "," + spouse.getLastName() + ","  
              + spouse.getAge();
        }
    }

    public String data;
    private Object readResolve()
        throws java.io.ObjectStreamException
    {
        String[] pieces = data.split(",");
        Person result = new Person(pieces[0], pieces[1], Integer.parseInt(pieces[2]));
        if (pieces.length > 3)
        {
            result.setSpouse(new Person(pieces[3], pieces[4], Integer.parseInt
              (pieces[5])));
            result.getSpouse().setSpouse(result);
        }
        return result;
    }
}

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; }

    private Object writeReplace()
        throws java.io.ObjectStreamException
    {
        return new PersonProxy(this);
    }

    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;
}

注意，PersonProxy 必须跟踪 Person 的全部数据。这通常意味着代理须要是 Person 的一个内部类，以便能訪问 private 字段。有时候，代理还须要追踪其它对象引用并手动序列化它们。比如 Person 的 spouse。

这样的技巧是少数几种不须要读/写平衡的技巧之中的一个。比如。一个类被重构成还有一种类型后的版本号能够提供一个 readResolve 方法，以便静默地将被序列化的对象转换成新类型。类似地。它能够採用 writeReplace 方法将旧类序列化成新版本号。

5. 信任。但要验证

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

对于序列化的对象。这意味着验证字段。以确保在反序列化之后它们仍具有正确的值，“以防万一”。

为此，能够实现 ObjectInputValidation接口，并覆盖 validateObject() 方法。假设调用该方法时发现某处有错误。则抛出一个 InvalidObjectException。

结束语

Java 对象序列化比大多数 Java 开发者想象的更灵活，这使我们有很多其它的机会解决棘手的情况。

幸运的是。像这种编程妙招在 JVM 中随处可见。关键是要知道它们，在遇到难题的时候能用上它们。

5 件事 系列下期预告：Java Collections。

在此之前。好好享受按自己的想法调整序列化吧！

参考这篇文章http://www.codeceo.com/article/5-java-serialization.html

posted @ 2015-06-21 14:49 hrhguanli 阅读(206) 评论(0) 编辑收藏举报

刷新页面返回顶部

hrhguanli