Java Serialization/序列化/反序列化 及 transient Java关键字详解

以前只知道序列化和反序列化的意思及怎么去使用，没有更深入的去了解，在学习之中遇到了这个transient关键字，以前并不知道在Java中 还有 transient 关键字，既然遇到了就花点时间把整理一下，查阅了一些资料看了一下，自己整理一份让方便更多的人去学习。
首先，Java提供了一个机制，称为一个对象可以被表示为字节序列，包括该对象的数据以及关于该对象的类型，并存储在对象数据的类型的信息的对象序列。
序列化的对象已经被写入到一个文件中，也可以从文件中读取和反序列化也就是，表示对象和它的数据可以用于重新创建在存储器中的对象的类型信息和字节。
整个过程是独立的JVM，这意味着一个对象可以被序列化在一个平台上，并反序列化一个完全不同的平台上。
ObjectInputStream 和 ObjectOutputStream 是包含了方法，序列化和反序列化对象的高层次的数据流。
ObjectOutputStream类包含许多write方法写入各种数据类型，但在特定的一个方法脱颖而出：
public final void writeObject(Object x) throws IOException
上述方法序列化一个对象，并将其发送到输出流。同样，ObjectInputStream的类包含用于反序列化对象的以下方法：

public final Object readObject() throws IOException,
ClassNotFoundException
此方法检索的下一个对象输出流和反序列化。返回值是Object，所以需要将它转换成其相应的数据类型。

为了演示序列化的运作方式在Java中，将使用在本教程中在前面讨论的Employee类。假设我们有以下的Employee类，它实现了Serializable接口：

public class Employee implements java.io.Serializable
{
public String name;
public String address;
public transient int SSN;
public int number;
public void mailCheck()
{
System.out.println(“Mailing a check to ” + name
+ ” ” + address);
}
}
请注意，一类被序列化成功，两个条件必须满足：

这个类必须实现java.io.Serializable接口。

所有在类中的字段必须是可序列化的。如果一个字段不是可序列化的，必须注明短暂的。

如果想知道，一个Java标准类是可序列化与否，请检查类的文档。测试很简单：如果一个类实现了java.io.Serializable，那么它是可序列化的，否则，它不是。

序列化一个对象：

ObjectOutputStream类用于序列化一个对象。下面SerializeDemo程序实例化一个Employee对象，并将其序列化到一个文件中。

当程序执行完毕，一个名为employee.ser被创建。程序不会产生任何输出，但研究代码，并尝试确定哪些程序正在做什么。

注：当序列化一个对象到一个文件中，在Java标准惯例给定的文件扩展名为 .ser 。

import java.io.*;

public class SerializeDemo
{
public static void main(String [] args)
{
Employee e = new Employee();
e.name = “Reyan Ali”;
e.address = “Phokka Kuan, Ambehta Peer”;
e.SSN = 11122333;
e.number = 101;
try
{
FileOutputStream fileOut =
new FileOutputStream(“/tmp/employee.ser”);
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(e);
out.close();
fileOut.close();
System.out.printf(“Serialized data is saved in /tmp/employee.ser”);
}catch(IOException i)
{
i.printStackTrace();
}
}
}
反序列化对象：

下面DeserializeDemo程序反序列化的SerializeDemo程序创建的Employee对象。研究程序，并尝试确定其输出：

import java.io.*;
public class DeserializeDemo
{
public static void main(String [] args)
{
Employee e = null;
try
{
FileInputStream fileIn = new FileInputStream(“/tmp/employee.ser”);
ObjectInputStream in = new ObjectInputStream(fileIn);
e = (Employee) in.readObject();
in.close();
fileIn.close();
}catch(IOException i)
{
i.printStackTrace();
return;
}catch(ClassNotFoundException c)
{
System.out.println(“Employee class not found”);
c.printStackTrace();
return;
}
System.out.println(“Deserialized Employee…”);
System.out.println(“Name: ” + e.name);
System.out.println(“Address: ” + e.address);
System.out.println(“SSN: ” + e.SSN);
System.out.println(“Number: ” + e.number);
}
}
这将产生以下结果：

Deserialized Employee…
Name: Reyan Ali
Address:Phokka Kuan, Ambehta Peer
SSN: 0
Number:101
这里有以下重要点要注意：

try/catch块试图捕获一个ClassNotFoundException，这是由readObject()方法声明。对于一个JVM能够反序列化对象时，它必须能够找到的字节码的类。如果JVM不能对象的反序列化过程中发现的一类，它抛出一个ClassNotFoundException。

请注意，调用readObject()返回值被强制转换为Employee 参考。

SSN字段的值是11122333当对象被序列化，但因为该字段是短暂的，这个值是不会被发送到输出流。反序列化的Employee对象的SSN字段为0。

---

1. transient的作用及使用方法

   我们都知道一个对象只要实现了Serilizable接口，这个对象就可以被序列化，java的这种序列化模式为开发者提供了很多便利，我们可以不必关系具体序列化的过程，只要这个类实现了Serilizable接口，这个类的所有属性和方法都会自动序列化。

   然而在实际开发过程中，我们常常会遇到这样的问题，这个类的有些属性需要序列化，而其他属性不需要被序列化，打个比方，如果一个用户有一些敏感信息（如密码，银行卡号等），为了安全起见，不希望在网络操作（主要涉及到序列化操作，本地序列化缓存也适用）中被传输，这些信息对应的变量就可以加上transient关键字。换句话说，这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。

   总之，java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

示例code如下：

View Code
输出为：

复制代码
read before Serializable:
username: Alexia
password: 123456

read after Serializable:
username: Alexia
password: null
复制代码
密码字段为null，说明反序列化时根本没有从文件中获取到信息。

1. transient使用小结

1）一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。

2）transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口。

3）被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。

第三点可能有些人很迷惑，因为发现在User类中的username字段前加上static关键字后，程序运行结果依然不变，即static类型的username也读出来为“Alexia”了，这不与第三点说的矛盾吗？实际上是这样的：第三点确实没错（一个静态变量不管是否被transient修饰，均不能被序列化），反序列化后类中static型变量username的值为当前JVM中对应static变量的值，这个值是JVM中的不是反序列化得出的，不相信？好吧，下面我来证明：

View Code
运行结果为：

复制代码
read before Serializable:
username: Alexia
password: 123456

read after Serializable:
username: jmwang
password: null
复制代码
这说明反序列化后类中static型变量username的值为当前JVM中对应static变量的值，为修改后jmwang，而不是序列化时的值Alexia。

1. transient使用细节——被transient关键字修饰的变量真的不能被序列化吗？

思考下面的例子：

复制代码
import java.io.Externalizable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

/**
* @descripiton Externalizable接口的使用
*
* @author Alexia
* @date 2013-10-15
*
*/
public class ExternalizableTest implements Externalizable {

private transient String content = "是的，我将会被序列化，不管我是否被transient关键字修饰";@Overridepublic void writeExternal(ObjectOutput out) throws IOException {    out.writeObject(content);}@Overridepublic void readExternal(ObjectInput in) throws IOException,        ClassNotFoundException {    content = (String) in.readObject();}public static void main(String[] args) throws Exception {    ExternalizableTest et = new ExternalizableTest();    ObjectOutput out = new ObjectOutputStream(new FileOutputStream(            new File("test")));    out.writeObject(et);    ObjectInput in = new ObjectInputStream(new FileInputStream(new File(            "test")));    et = (ExternalizableTest) in.readObject();    System.out.println(et.content);    out.close();    in.close();}

}

content变量会被序列化吗？好吧，我把答案都输出来了，是的，运行结果就是： 是的，我将会被序列化，不管我是否被transient关键字修饰 这是为什么呢，不是说类的变量被transient关键字修饰以后将不能序列化了吗？ 我们知道在Java中，对象的序列化可以通过实现两种接口来实现，若实现的是Serializable接口，则所有的 序列化将会自动进行，若实现的是Externalizable接口，则没有任何东西可以自动序列化，需要在writeExternal方法中进行手工指定所要序列化的变量，这与是否被transient修饰无关。因此第二个例子输出的是变量content初始化的内容，而不是null。