java序列化

Java 串行化技术可以使你将一个对象的状态写入一个Byte 流里，并且可以从其它地方把该Byte 流里的数据读出来，重新构造一个相同的对象。这种机制允许你将对象通过网络进行传播，并可以随时把对象持久化到数据库、文件等系统里。Java的串行化机制是RMI、EJB等技术的技术基础。用途：利用对象的串行化实现保存应用程序的当前工作状态，下次再启动的时候将自动地恢复到上次执行的状态。

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

序列化的实现：将需要被序列化的类实现Serializable接口，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

2、串行化的特点：

    （1）如果某个类能够被串行化，其子类也可以被串行化。如果该类有父类，则分两种情况来考虑，如果该父类已经实现了可串行化接口。则其父类的相应字段及属性的处理和该类相同；如果该类的父类没有实现可串行化接口，则该类的父类所有的字段属性将不会串行化。

  （2）声明为static和transient类型的成员数据不能被串行化。因为static代表类的状态， transient代表对象的临时数据；

  （3）相关的类和接口：在java.io包中提供的涉及对象的串行化的类与接口有ObjectOutput接口、ObjectOutputStream类、ObjectInput接口、ObjectInputStream类。

    （1）ObjectOutput接口：它继承DataOutput接口并且支持对象的串行化，其内的writeObject()方法实现存储一个对象。ObjectInput接口：它继承DataInput接口并且支持对象的串行化，其内的readObject()方法实现读取一个对象。

    （2）ObjectOutputStream类：它继承OutputStream类并且实现ObjectOutput接口。利用该类来实现将对象存储（调用ObjectOutput接口中的writeObject()方法）。ObjectInputStream类：它继承InputStream类并且实现ObjectInput接口。利用该类来实现读取一个对象（调用ObjectInput接口中的readObject()方法）。

  对于父类的处理，如果父类没有实现串行化接口，则其必须有默认的构造函数（即没有参数的构造函数）。否则编译的时候就会报错。在反串行化的时候，默认构造函数会被调用。但是若把父类标记为可以串行化，则在反串行化的时候，其默认构造函数不会被调用。这是为什么呢？这是因为Java 对串行化的对象进行反串行化的时候，直接从流里获取其对象数据来生成一个对象实例，而不是通过其构造函数来完成。

import java.io.*;

public class Cat implements Serializable {

        private String name;

        public Cat () {

                this.name = "new cat";

        }

        public String getName() {

                return this.name;

        }

        public void setName(String name) {

                this.name = name;

        }

        public static void main(String[] args) {         

                Cat cat = new Cat();

                try {

                        FileOutputStream fos = new FileOutputStream("catDemo.out");

                        ObjectOutputStream oos = new ObjectOutputStream(fos);

                        System.out.println(" 1> " + cat.getName());

                        cat.setName("My Cat");                       

                        oos.writeObject(cat);

                        oos.close();                       

                } catch (Exception ex) {  ex.printStackTrace();   }

                try {

                        FileInputStream fis = new FileInputStream("catDemo.out");

                        ObjectInputStream ois = new ObjectInputStream(fis);

                        cat = (Cat) ois.readObject();

                        System.out.println(" 2> " + cat.getName());

                        ois.close();

                } catch (Exception ex) {

                        ex.printStackTrace();

                }

        }

}//writeObject和readObject本身就是线程安全的，传输过程中是不允许被并发访问的。所以对象能一个一个接连不断的传过来

有关Java对象的序列化和反序列化也算是Java基础的一部分，下面对Java序列化的机制和原理进行一些介绍。

Java序列化算法透析

Serialization（序列化）是一种将对象以一连串的字节描述的过程；反序列化deserialization是一种将这些字节重建成一个对象的过程。Java序列化API提供一种处理对象序列化的标准机制。在这里你能学到如何序列化一个对象，什么时候需要序列化以及Java序列化的算法，我们用一个实例来示范序列化以后的字节是如何描述一个对象的信息的。

序列化的必要性

Java中，一切都是对象，在分布式环境中经常需要将Object从这一端网络或设备传递到另一端。这就需要有一种可以在两端传输数据的协议。Java序列化机制就是为了解决这个问题而产生。

如何序列化一个对象

一个对象能够序列化的前提是实现Serializable接口，Serializable接口没有方法，更像是个标记。有了这个标记的Class就能被序列化机制处理。

import java.io.Serializable;  
 
class TestSerial implements Serializable {  
 
       public byte version = 100;  
 
       public byte count = 0;  
 
} 

然后我们写个程序将对象序列化并输出。ObjectOutputStream能把Object输出成Byte流。我们将Byte流暂时存储到temp.out文件里。

public static void main(String args[]) throws IOException {  
 
       FileOutputStream fos = new FileOutputStream("temp.out");  
 
       ObjectOutputStream oos = new ObjectOutputStream(fos);  
 
       TestSerial ts = new TestSerial();  
 
       oos.writeObject(ts);  
 
       oos.flush();  
 
       oos.close();  
 
} 

如果要从持久的文件中读取Bytes重建对象，我们可以使用ObjectInputStream。  

public static void main(String args[]) throws IOException {  
 
       FileInputStream fis = new FileInputStream("temp.out");  
 
       ObjectInputStream oin = new ObjectInputStream(fis);  
 
       TestSerial ts = (TestSerial) oin.readObject();  
 
       System.out.println("version="+ts.version);  
 
} 

执行结果为

100.

对象的序列化格式

将一个对象序列化后是什么样子呢？打开刚才我们将对象序列化输出的temp.out文件，以16进制方式显示。内容应该如下：

AC ED 00 05 73 72 00 0A 53 65 72 69 61 6C 54 6573 74 A0 0C 34 00 FE B1 DD F9 02 00 02 42 00 0563 6F 75 6E 74 42 00 07 76 65 72 73 69 6F 6E 7870 00 64

这一坨字节就是用来描述序列化以后的

TestSerial对象的，我们注意到TestSerial类中只有两个域：

public byte version = 100;

public byte count = 0;

且都是byte型，理论上存储这两个域只需要2个byte，但是实际上temp.out占据空间为51bytes，也就是说除了数据以外，还包括了对序列化对象的其他描述。

Java的序列化算法

序列化算法一般会按步骤做如下事情：

◆将对象实例相关的类元数据输出。

◆递归地输出类的超类描述直到不再有超类。

◆类元数据完了以后，开始从最顶层的超类开始输出对象实例的实际数据值。

◆从上至下递归输出实例的数据

我们用另一个更完整覆盖所有可能出现的情况的例子来说明：

class parent implements Serializable {  
 
       int parentVersion = 10;  
 
}  
 
   
 
class contain implements Serializable{  
 
       int containVersion = 11;  
 
}  
 
public class SerialTest extends parent implements Serializable {  
 
       int version = 66;  
 
       contain con = new contain();  
 
   
 
       public int getVersion() {  
 
              return version;  
 
       }  
 
       public static void main(String args[]) throws IOException {  
 
              FileOutputStream fos = new FileOutputStream("temp.out");  
 
              ObjectOutputStream oos = new ObjectOutputStream(fos);  
 
              SerialTest st = new SerialTest();  
 
              oos.writeObject(st);  
 
              oos.flush();  
 
              oos.close();  
 
       }  
 
} 

这个例子是相当的直白啦。SerialTest类实现了Parent超类，内部还持有一个Container对象。

序列化后的格式如下：

AC ED 00 05 73 72 00 0A 53 65 72 69 61 6C 54 65

73 74 05 52 81 5A AC 66 02 F6 02 00 02 49 00 07

76 65 72 73 69 6F 6E 4C 00 03 63 6F 6E 74 00 09

4C 63 6F 6E 74 61 69 6E 3B 78 72 00 06 70 61 72

65 6E 74 0E DB D2 BD 85 EE 63 7A 02 00 01 49 00

0D 70 61 72 65 6E 74 56 65 72 73 69 6F 6E 78 70

00 00 00 0A 00 00 00 42 73 72 00 07 63 6F 6E 74

61 69 6E FC BB E6 0E FB CB 60 C7 02 00 01 49 00

0E 63 6F 6E 74 61 69 6E 56 65 72 73 69 6F 6E 78

70 00 00 00 0B

我们来仔细看看这些字节都代表了啥。开头部分，见颜色：

1. AC ED: STREAM_MAGIC. 声明使用了序列化协议.
2. 00 05: STREAM_VERSION. 序列化协议版本.
3. 0x73: TC_OBJECT. 声明这是一个新的对象.  

序列化算法的第一步就是输出对象相关类的描述。例子所示对象为SerialTest类实例，因此接下来输出SerialTest类的描述。见颜色：

1. 0x72: TC_CLASSDESC. 声明这里开始一个新Class。
2. 00 0A: Class名字的长度.
3. 53 65 72 69 61 6c 54 65 73 74: SerialTest,Class类名.
4. 05 52 81 5A AC 66 02 F6: SerialVersionUID, 序列化ID，如果没有指定，则会由算法随机生成一个8byte的ID.
5. 0x02: 标记号. 该值声明该对象支持序列化。
6. 00 02: 该类所包含的域个数。

接下来，算法输出其中的一个域，int version=66；见颜色：

1. 0x49: 域类型. 49 代表"I", 也就是Int.
2. 00 07: 域名字的长度.
3. 76 65 72 73 69 6F 6E: version,域名字描述.

然后，算法输出下一个域，contain con = new contain();这个有点特殊，是个对象。描述对象类型引用时需要使用JVM的标准对象签名表示法，见颜色：

1. 0x4C: 域的类型.
2. 00 03: 域名字长度.
3. 63 6F 6E: 域名字描述，con
4. 0x74: TC_STRING. 代表一个new String.用String来引用对象。
5. 00 09: 该String长度.
6. 4C 63 6F 6E 74 61 69 6E 3B: Lcontain;, JVM的标准对象签名表示法.
7. 0x78: TC_ENDBLOCKDATA,对象数据块结束的标志

.接下来算法就会输出超类也就是Parent类描述了，见颜色：

1. 0x72: TC_CLASSDESC. 声明这个是个新类.
2. 00 06: 类名长度.
3. 70 61 72 65 6E 74: parent,类名描述。
4. 0E DB D2 BD 85 EE 63 7A: SerialVersionUID, 序列化ID.
5. 0x02: 标记号. 该值声明该对象支持序列化.
6. 00 01: 类中域的个数.

下一步，输出parent类的域描述，int parentVersion=100;同见颜色：

1. 0x49: 域类型. 49 代表"I", 也就是Int.
2. 00 0D: 域名字长度.
3. 70 61 72 65 6E 74 56 65 72 73 69 6F 6E: parentVersion，域名字描述。
4. 0x78: TC_ENDBLOCKDATA,对象块结束的标志。
5. 0x70: TC_NULL, 说明没有其他超类的标志。.

到此为止，算法已经对所有的类的描述都做了输出。下一步就是把实例对象的实际值输出了。这时候是从parent Class的域开始的，见颜色：

1. 00 00 00 0A: 10, parentVersion域的值.

还有SerialTest类的域：

1. 00 00 00 42: 66, version域的值.

再往后的bytes比较有意思，算法需要描述contain类的信息，要记住，现在还没有对contain类进行过描述，见颜色：

1. 0x73: TC_OBJECT, 声明这是一个新的对象.
2. 0x72: TC_CLASSDESC声明这里开始一个新Class.
3. 00 07: 类名的长度.
4. 63 6F 6E 74 61 69 6E: contain,类名描述.
5. FC BB E6 0E FB CB 60 C7: SerialVersionUID, 序列化ID.
6. 0x02: Various flags. 标记号. 该值声明该对象支持序列化
7. 00 01: 类内的域个数。

.输出contain的唯一的域描述，int containVersion=11；

1. 0x49: 域类型. 49 代表"I", 也就是Int..
2. 00 0E: 域名字长度.
3. 63 6F 6E 74 61 69 6E 56 65 72 73 69 6F 6E: containVersion, 域名字描述.
4. 0x78: TC_ENDBLOCKDATA对象块结束的标志.

这时，序列化算法会检查contain是否有超类，如果有的话会接着输出。

1. 0x70:TC_NULL，没有超类了。

最后，将contain类实际域值输出。

1. 00 00 00 0B: 11, containVersion的值.

OK,我们讨论了java序列化的机制和原理，希望能对同学们有所帮助。

本文来自longdick的博客：《Java序列化算法透析》