java序列化与反序列化

        本文将详细介绍java序列化与反序列化相关知识。文中大多概念知识来自网络，风尘在此对这些无私分享知识的网友表示感谢，同时若有侵犯版权问题请及时联系风尘，风尘将在第一时间进行处理。

本文主要从以下几个方面来介绍java序列化与反序列化：

1.      什么是序列化，序列化是干什么的？

2.      为什么要序列化即什么情况下要序列化？

3.      序列化的意义？

4.      如何进行序列化？

5.      序列化注意事项？

6.      通过一个对序列化不深入理解的例子进一步介绍序列化。

下面将按以上罗列顺序逐步介绍java序列化与反序列化知识。

1、序列化是干什么的？  

       简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保 存对象状态，但是Java给你提供一种应该比你自己好的保存对象状态的机制，那就是序列化。    

2、什么情况下需要序列化  

       简单来说序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化，流的概念这里不用多说（就是I/O），我们可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间（注：要想将对象传输于网络必须进行流化）！在对对象流进行读写操作时会引发一些问题，而序列化机制正是用来解决这些问题的！

       如上所述，读写对象会有什么问题呢？比如：我要将对象写入一个磁盘文件而后再将其读出来会有什么问题吗？别急，其中一个最大的问题就是对象引用！举个例子来说：假如我有两个类，分别是A和B，B类中含有一个指向A类对象的引用，现在我们对两个类进行实例化{ A a = new A（）； B b =new B（）；}，这时在内存中实际上分配了两个空间，一个存储对象a，一个存储对象b，接下来我们想将它们写入到磁盘的一个文件中去，就在写入文件时出现了问题！因为对象b包含对对象a的引用，所以系统会自动的将a的数据复制一份到b中，这样的话当我们从文件中恢复对象时（也就是重新加载到内存中）时，内存分配了三个空间，而对象a同时在内存中存在两份，想一想后果吧，如果我想修改对象a的数据的话，那不是还要搜索它的每一份拷贝来达到对象数据的一致性，这不是我们所希望的！以下序列化机制的解决方案：

1).保存到磁盘的所有对象都获得一个序列号（1， 2， 3等等）。

2).当要保存一个对象时，先检查该对象是否被保存了。

3).如果以前保存过，只需写入"与已经保存的具有序列号x的对象相同"的标记，否则，保存该对象。

通过以上的步骤序列化机制解决了对象引用的问题。

        总之，当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送，一般在以下场景中我们需要序列化：

a)  当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；

b)   当你想用套接字在网络上传送对象的时候； 

c)   当你想通过RMI传输对象的时候；   

3、序列化的意义  

        序列化的过程就是对象写入字节流和从字节流中读取对象。将对象状态转换成字节流之后，可以用java.io包中的各种字节流类将其保存到文件中，管道到另一 线程中或通过网络连接将对象数据发送到另一主机。对象序列化功能非常简单、强大，在RMI、Socket、JMS、EJB都有应用。对象序列化问题在网络编程中并不是最激动人心的课题，但却相当重要，具有许多实用意义。  

1)：对象序列化可以实现分布式对象。主要应用例如：RMI要利用对象序列化运行远程主机上的服务，就像在本地机上运行对象时一样。  

2)：java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。可以将整个对象层次写入字节流中，可以保存在文件中或在网络连接上传递。利用对象序列化可以进行对象的“深复制”，即复制对象本身及引用的对象本身。序列化一个对象可能得到整个对象序列。 

4、如何进行序列化

       java序列化比较简单，通常不需要编写保存和恢复对象状态的定制代码。实现java.io.Serializable接口的类对象可以转换成字节流或从字节流恢复，不需要在类中增加任何代码。只有极少数情况下才需要定制代码保存或恢复对象状态。这里要注意：不是每个类都可序列化，有些类是不能序列化的，例如涉及线程的类与特定JVM有非常复杂的关系。   

序列化机制：  

       序列化分为两大部分：序列化和反序列化。序列化是这 个过程的第一部分，将数据分解成字节流，以便存储在文件中或在网络上传输。反序列化就是打开字节流并重构对象。对象序列化不仅要将基本数据类型转换成字节表示，有时还要恢复数据。恢复数据要求有恢复数据的对象实例。ObjectOutputStream中的序列化过程与字节流连接，包括对象类型和版本信 息。反序列化时，JVM用头信息生成对象实例，然后将对象字节流中的数据复制到对象数据成员中。下面我们分两大部分来阐述：   

处理对象流：(序列化过程和反序列化过程)   

java.io包有两个序列化对象的类。ObjectOutputStream负责将对象写入字节流，ObjectInputStream从字节流重构对象。  

       我们先来了解ObjectOutputStream类：

ObjectOutputStream类扩展DataOutput接口，writeObject() 方法是最重要的方法，用于对象序列化。如果对象包含其他对象的引用，则writeObject()方法递归序列化这些对象。每个 ObjectOutputStream维护序列化的对象引用表，防止发送同一对象的多个拷贝。（这点很重要）由于writeObject()可以序列化整组交叉引用的对象，因此同一ObjectOutputStream实例可能不小心被请求序列化同一对象。这时，进行反引用序列化，而不是再次写入对象字节流。  

下面，让我们从例子中来了解ObjectOutputStream这个类:

// 序列化 today’s date 到一个文件中.  

FileOutputStream f = new FileOutputStream(“tmp”);     //创建一个包含恢复对象(即对象进行反序列化信息)的”tmp”数件 

ObjectOutputStream s = new ObjectOutputStream(f); 

s.writeObject(“Today”);    //写入字符串对象;  

s.writeObject(new Date());    //写入瞬态对象;  

s.flush();   

        现在，让我们来了解ObjectInputStream这个类。它与ObjectOutputStream相似。它扩展DataInput接口。 ObjectInputStream中的方法镜像DataInputStream中读取Java基本数据类型的公开方法。readObject()方法从字节流中反序列化对象。每次调用readObject()方法都返回流中下一个Object。对象字节流并不传输类的字节码，而是包括类名及其签名。readObject()收到对象时，JVM装入头中指定的类。如果找不到这个类，则readObject()抛出 ClassNotFoundException,如果需要传输对象数据和字节码，则可以用RMI框架。ObjectInputStream的其余方法用于 定制反序列化过程。例子如下：  

//从文件中反序列化 string 对象和 date 对象  

FileInputStream in = new FileInputStream(“tmp”);  

ObjectInputStream s = new ObjectInputStream(in); 

String today = (String)s.readObject();   //恢复对象;  

Date date = (Date)s.readObject();   

定制序列化过程:   

        序列化通常可以自动完成，但有时可能要对这个过程进行控制。java可以将类声明为serializable，但仍可手工控制声明为static或transient的数据成员。例子：一个非常简单的序列化类。  

public class simpleSerializableClass implements Serializable{

String sToday=”Today:”;  

transient Date dtToday=new Date(); 

}   

        序列化时，类的所有数据成员应可序列化除了声明为transient或static的成员。将变量声明为transient告诉JVM我们会负责将变元序列化。将数据成员声明为transient后，序列化过程就无法将其加进对象字节流中，没有从transient数据成员发送的数据。后面数据反序列化时，要重建数据成员（因为它是类定义的一部分），但不包含任何数据，因为这个数据成员不向流中写入任何数据。记住，对象流不序列化static或 transient。我们的类要用writeObject()与readObject()方法以处理这些数据成员。使用writeObject()与 readObject()方法时，还要注意按写入的顺序读取这些数据成员。关于如何使用定制序列化的部分代码如下：  

//重写writeObject()方法以便处理transient的成员。  

public void writeObject(ObjectOutputStream outputStream) throws IOException{  

outputStream.defaultWriteObject();//使定制的writeObject()方法可以利用自动序列化中内置的逻辑。  

outputStream.writeObject(oSocket.getInetAddress()); 

outputStream.writeInt(oSocket.getPort()); 

}  

//重写readObject()方法以便接收transient的成员。  

private void readObject(ObjectInputStream inputStream) throws IOException,ClassNotFoundException{  

inputStream.defaultReadObject();//defaultReadObject()补充自动序列化 

InetAddress oAddress=(InetAddress)inputStream.readObject();  

int iPort =inputStream.readInt();  

oSocket = new Socket(oAddress,iPort); 

iID=getID();  

dtToday =new Date();  

}   

完全定制序列化过程:   

        如果一个类要完全负责自己的序列化，则实现Externalizable接口而不是Serializable接口。Externalizable接口定义包 括两个方法writeExternal()与readExternal()。利用这些方法可以控制对象数据成员如何写入字节流，类实现 Externalizable时，头写入对象流中，然后类完全负责序列化和恢复数据成员，除了头以外，根本没有自动序列化。这里要注意了。声明类实现 Externalizable接口会有重大的安全风险。writeExternal()与readExternal()方法声明为public，恶意类可以用这些方法读取和写入对象数据。如果对象包含敏感信息，则要格外小心。这包括使用安全套接或加密整个字节流。

5、序列化相关注意事项  

a). 序列化时，只对对象的状态进行保存，而不管对象的方法； 

b). 当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口；  

c). 当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化；  

d). 并非所有的对象都可以序列化，至于为什么不可以，有很多原因了,比如：

1). 安全方面的原因，比如一个对象拥有private，public等field，对于一个要传输的对象，比如写到文件，或者进行rmi传输等等，在序列化进行传输的过程中，这个对象的private等域是不受保护的。  

2). 资源分配方面的原因，比如socket，thread类，如果可以序列化，进行传输或者保存，也无法对他们进行重新的资源分配，而且，也是没有必要这样实现。   

6、通过一个对序列化不深入理解的例子进一步介绍序列化

下面引用一个网友在csdn上发的贴来进一步介绍序列化，原贴如下：

import java.io.*;

class Student implements Serializable

{

  private String name;

  private transient String password;

  private static int count=0;

 

  public Student(String name,String password)

  {

         System.out.println("调用Student的带参的构造方法");

         this.name=name;

         this.password=password;

         count++;

  }

  public String toString()

  {

        return "人数: "+count+" 姓名: "+name+"密码: "+password;

  }

}

public class ObjectSerTest1

{

public static void main(String args[])

{

try{

FileOutputStream fos=newFileOutputStream("test.obj");

ObjectOutputStream oos=newObjectOutputStream(fos);

 

Student s1=new Student("张三","12345");

Student s2=new Student("王五","54321");

 

oos.writeObject(s1);

oos.writeObject(s2);

oos.close();

 

FileInputStream fis=newFileInputStream("test.obj");

ObjectInputStream ois=newObjectInputStream(fis);

 

   Student s3=(Student)ois.readObject();

   Student s4=(Student)ois.readObject();

 

    System.out.println(s3);

   System.out.println(s4);

   

   ois.close();

}

catch(IOException e)

{

e.printStackTrace();

}

catch(ClassNotFoundException e1)

{

e1.printStackTrace();

}

}

}

count为Student的静态成员变量，书上说静态成员不能被序列化，那为什么此程序运行的结果：输出s3和s4时 count为2呢，按理说应该为0才对啊？还是我哪里理解错了，请高手指定，谢谢了！

一网友给出的回复：

静态成员属于类级别的，所以不能序列化

这里的不能序列化的意思，是序列化信息中不包含这个静态成员域

你这个测试成功，是因为你都在同一个机器（而且是同一个进程），因为你这个jvm已经把count加载进来了，所以你获取的是加载好的count，如果你是传到另一台机器或者你关掉程序重写写个程序读入test.obj，此时因为别的机器或新的进程是重新加载count的，所以count信息就是初始时的信息。

另一网友给出的回复：

静态变量不属于对象，属于类。不能被序列化。还有瞬态的变量也不能被序列化 。

test.obj ,你打开看看 ，里面是没有

private transient String password;

private static int count=0;

这两个属性的序列化信息的 ，输出2是因为在当前jvm实例中count = 2 ；

你可以这样测试，写两个类来测试，一个类写入序列化文件， 另外一个类读出序列化文件，代码如下：

public classStudent implementsSerializable {

    private static final long serialVersionUID= -7436177636873643044L;

    private Stringname;

    private transient String password;

    private static int count = 0;

    public Student(String name,String password) {

       this.name = name;

       this.password = password;

       count++;

    }

    public String toString() {

       return"人数: " +count+" 姓名: " +name + " 密码: " +password;

    }

}

public classReadStaticVar {

    public static void main(String args[]){

        try {

            FileInputStream fis = new FileInputStream("test.obj");

            ObjectInputStream ois = new ObjectInputStream(fis);

            Student s3 = (Student) ois.readObject();

            Student s4 = (Student)ois.readObject();

            System.out.println(s3);

            System.out.println(s4);

            ois.close();

        } catch (IOException e) {

            e.printStackTrace();

        } catch (ClassNotFoundException e1) {

            e1.printStackTrace();

        }

   }

}

上面程序运行后输出结果如下：

人数: 0 姓名: 张三 密码: null

人数: 0 姓名: 王五 密码: null

可以看到静态变量和transient修饰的变量没有被序列化。

       通过以上对java序列化的了解，可以简单总结一下：序列化的目的是将对象进行流化后，让对象可以保存在文件、磁盘或在网络中传输供其它进程去读取，要想在网络中进行数据之间的通信，必须要将对象序列化。而让一个类实现Serializable接口时，标识这个类是可以被序列化，在需要保存这个对象时我们就可以通过ObjectOutputStream.writeObject()方法去将对象进行流化，然后与其它进程进行通信时，其它通信对象就可以通过ObjectInputStream.readObject()方法来反序列化构造出对象。通过序列化也能够很方便的实现深度复制，在风尘前一篇文章中有介绍。

       至此java序列化的基础内容已介绍完毕。