java对象序列化



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

       当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。

　　只能将支持 java.io.Serializable 接口的对象写入流中。每个 serializable 对象的类都被编码，编码内容包括类名和类签名、对象的字段值和数组值，以及从初始对象中引用的其他所有对象的闭包。


2、什么情况下需要序列化  
    a）当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
    b）当你想用套接字在网络上传送对象的时候；
    c）当你想通过RMI传输对象的时候；

3、当对一个对象实现序列化时，究竟发生了什么？
    在没有序列化前，每个保存在堆（Heap）中的对象都有相应的状态（state），即实例变量（instance ariable）比如：
   
java 代码
Foo  myFoo = new Foo();  
myFoo .setWidth(37);  
myFoo.setHeight(70);  
     
       当通过下面的代码序列化之后，MyFoo对象中的width和Height实例变量的值（37，70）都被保存到foo.ser文件中，这样以后又可以把它从文件中读出来，重新在堆中创建原来的对象。当然保存时候不仅仅是保存对象的实例变量的值，JVM还要保存一些小量信息，比如类的类型等以便恢复原来的对象。

序列化的API

java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。只有实现了Serializable和Externalizable接口的类的对象才能被序列化。

java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。

java 代码
FileOutputStream fs = new FileOutputStream("foo.ser");  
ObjectOutputStream os = new ObjectOutputStream(fs);  
os.writeObject(myFoo);  

4、实现序列化（保存到一个文件）的步骤
       a）Make a FileOutputStream            
java 代码
FileOutputStream fs = new FileOutputStream("foo.ser");    
       b）Make a ObjectOutputStream           

java 代码
ObjectOutputStream os =  new ObjectOutputStream(fs);   
       c）write the object

java 代码
os.writeObject(myObject1);  
os.writeObject(myObject2);  
os.writeObject(myObject3);  
    d) close the ObjectOutputStream

java 代码
os.close();  

5、举例说明

Java代码

1. package com.hotye.dchaoxiong.serializabletest;   
2.   
3. import java.io.FileInputStream;   
4. import java.io.FileOutputStream;   
5. import java.io.ObjectInputStream;   
6. import java.io.ObjectOutputStream;   
7. import java.io.Serializable;   
8.   
9. public class Box implements Serializable {   
10.       
11.     private static final long serialVersionUID = 1L;   
12.     private int width;   
13.     private int height;   
14.     private String name;   
15.   
16.     public static void main(String[] args) {   
17.   
18.         try {   
19.             Box myBox = new Box();   
20.             myBox.setWidth(50);   
21.             myBox.setHeight(30);   
22.             myBox.setName("芒果");   
23.                
24.             FileOutputStream fs = new FileOutputStream("serializableObject.txt");   
25.             ObjectOutputStream os = new ObjectOutputStream(fs);   
26.             os.writeObject(myBox);   
27.             os.close();   
28.             fs.close();   
29.         } catch (Exception ex) {   
30.             ex.printStackTrace();   
31.         }   
32.   
33.         try {   
34.             FileInputStream fis = new FileInputStream("serializableObject.txt");   
35.             ObjectInputStream ois = new ObjectInputStream(fis);   
36.             Box box = (Box) ois.readObject();   
37.             System.out.println(box.getWidth());   
38.             System.out.println(box.getHeight());   
39.             System.out.println(box.getName());   
40.             ois.close();   
41.             fis.close();   
42.         } catch (Exception e) {   
43.             e.printStackTrace();   
44.         }   
45.     }   
46.   
47.     public void setHeight(int height) {   
48.         this.height = height;   
49.     }   
50.   
51.     public int getHeight() {   
52.         return height;   
53.     }   
54.   
55.     public void setWidth(int width) {   
56.         this.width = width;   
57.     }   
58.   
59.     public int getWidth() {   
60.         return width;   
61.     }   
62.   
63.     public void setName(String name) {   
64.         this.name = name;   
65.     }   
66.   
67.     public String getName() {   
68.         return name;   
69.     }   
70.   
71. }  

　读取对象的顺序与写入时的顺序要一致。

6、相关注意事项
    a）序列化时，只对对象的状态进行保存，而不管对象的方法；
    b）当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口；
    c）当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化；
    d）并非所有的对象都可以序列化，,至于为什么不可以，有很多原因了,比如：
        1.安全方面的原因，比如一个对象拥有private，public等field，对于一个要传输的对象，比如写到文件，或者进行rmi传输  等等，在序列化进行传输的过程中，这个对象的private等域是不受保护的。
       2. 资源分配方面的原因，比如socket，thread类，如果可以序列化，进行传输或者保存，也无法对他们进行重新的资源分  配，而且，也是没有必要这样实现。