疯狂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

时间： 2024-10-05 02:48:39

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

疯狂Java学习笔记（56）------------对象序列化

所谓对象序列化就是将对象的状态转换成字节流,以后可以通过这些值再生成相同状态的对象! 对象序列化是对象持久化的一种实现方法,它是将一个对象的属性和方法转化为一种序列化的格式以用于存储和传输,反序列化就是根据这些保存的信息重建对象的过程. java对象序列化机制一般来讲有两种用途: 1.需要将对象的状态保存到文件中(存储),而后能够通过读入对象状态来重新构造对象,恢复程序状态 2.使用套接字在网络上传送对象的程序来说,是很有用的(传输). 我们通过让类实现java.io.Serializable

JAVA学习笔记一（JAVA输出环境变量）

package mytest; import java.util.*;; public class mymain { public static void main(String[] args) { // TODO Auto-generated method stub System.out.print(new Date()); Properties p=System.getProperties(); p.list(System.out); Runtime rt=Runtime.getRuntim

Java学习笔记心得——初识Java

初识Java 拿到这本厚厚的<Java学习笔记>,翻开目录:Java平台概论.从JDK到TDE.认识对象.封装.继承与多态...看着这些似懂非懂的术语名词,心里怀着些好奇与担忧,就这样我开始走进Java的世界.  Java产生的历史 Java来自于Sun公司的一个叫Green Project中撰写的程序语言,全球信息网(World Wide Web)兴起,Java Applet成为网页互动技术的代表,特别适合于Internet应用程序开发. Java语言的特点 1.面向对象 这是Java最重要

Java学习笔记-3.类与对象

一.面向对象程序设计 1.概念:   OOA:面向对象的分析,将现实世界进行抽象的分析 OOD:面向对象的设计 OOP:面向对象的程序 2.面向对象的特点: (1)封装性:一是把对象的全部状态和行为结合在一起,形成一个不可分割的整体,对象的私有属性只能由对象的行为来修改和读取 二是尽可能隐藏对象的内部细节,与外界的联系只能够通过外部接口来实现 (2)继承性:特殊类的对象拥有其一般类的属性和行为 (3)多态性:指同一个实体同时具有多种形式,体现在不同的对象可以根据相同的消息产生各自不同的动作 二.

Java学习笔记之：Java简介

一.引言 Java是由Sun Microsystems公司于1995年5月推出的Java面向对象程序设计语言和Java平台的总称.由James Gosling和同事们共同研发,并在1995年正式推出. 主要特性 Java语言是简单的: Java语言的语法与C语言和C++语言很接近,使得大多数程序员很容易学习和使用.另一方面,Java丢弃了C++中很少使用的.很难理解的.令人迷惑的那些特性,如操作符重载.多继承.自动的强制类型转换.特别地,Java语言不使用指针,而是引用.并提供了自动的废料收集,

java学习笔记（Core java）7 断言与异常

1.错误的原因: 输入错误 设备错误 物理限制 代码错误2.异常分类总:Throwable->Error ->Exception->IOException ->RuntimeException: 继承RuntimeException异常的异常包括: 错误的类型转换; 空指针 访问越界 不继承RuntimeException异常的异常包括: 试图打开一个不存在的文件 试图在文件尾部读取数据 试图根据给定的字符串查找CLASS对象,但这个对象并不存在 C++中两种异常:logic_er

java学习笔记（Core Java）5 继承

第五章 继承 1. 类 超类 子类继承:extends (所有继承嗾使公有继承,没有私有继承和保护继承) c+++: 用: 2.使用super(c#使用Base)调用基类的方法 子类构造器会默认调用基类的无参构造来初始化基类的私有域 如果基类没有无参构造,则会报错 3.this :1.引用隐式传参 2.调用类其他构造器 super:1.调用超类的方法 2.调用超类的构造器 c++使用初始化列表来调用基类的构造函数 4.java中,不需要将方法声明为虚拟方法方法,基类指针指向不同对象时,虚拟指针知

Java学习笔记—多线程（java.util.concurrent并发包概括，转载）

一.描述线程的类:Runable和Thread都属于java.lang包 二.内置锁synchronized属于jvm关键字,内置条件队列操作接口Object.wait()/notify()/notifyAll()属于java.lang包 二.提供内存可见性和防止指令重排的volatile属于jvm关键字 四.而java.util.concurrent包(J.U.C)中包含的是java并发编程中有用的一些工具类,包括几个部分: 1.locks部分:包含在java.util.concurrent.

Java学习笔记1——类和对象

面向对象 对象:万物皆对象 面向对象 类:模子,属性+方法,类是对象的类型,是具有相同属性和方法的一组对象的集合 对象属性:对象拥有的各种特征,"对象有什么" 对象方法:对象执行的操作,"对象能干什么" 类与对象的关系/区别:类是抽象的,仅仅是模版:对象是看得到,摸得着的具体实体.例如:'手机'类,对象为iPhone6,Lumia920 Java中的类 定义类:Java程序都以类class为组织单元 创建一个对象 //1.定义一个类 public class Tel

java学习笔记（Core Java）4 对象与类

第四章 对象与类oop三个特征:对象的行为.状态.标识类之间关系:依赖,聚合,继承依赖:一个类的方法操纵另一个类的对象.(尽量减少这种耦合情况)聚合(has-a)一个类作为另一个类的变量而存在继承(is-a) 如果只声明一个类变量,而没有在堆空间中开辟没存,那么这个变量就不能调用类中的方法因为这个变量没有引用对象 !!一个对象的变量并没有实际包含一个对象,而仅仅引用了一个对象 Data data;等同于:Data *data; //它只代表一个指针,而不拥有对象数据 get/set 访问器 一个