Java Serializable Interface [转]

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

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还要保存一些小量信息，比如类的类型等以便恢复原来的对 象。

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 代码

}

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

-------------------------------------------------------------------------------------------------------------

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

序列化:序列化是将对象转换为容易传输的格式的过程。例如，可以序列化一个对象，然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象。在另一端，反序列化将从该流重新构造对象。
是对象永久化的一种机制。

　　 确切的说应该是对象的序列化，一般程序在运行时，产生对象，这些对象随着程序的停止运行而消失，但如果我们想把某些对象（因为是对象，所以有各自不同的特性）保存下来，在程序终止运行后，这些对象仍然存在，可以在程序再次运行时读取这些对象的值，或者在其他程序中利用这些保存下来的对象。这种情况下就要用到对象的序列化。

　　 只有序列化的对象才可以存储在存储设备上。为了对象的序列化而需要继承的接口也只是一个象征性的接口而已，也就是说继承这个接口说明这个对象可以被序列化了，没有其他的目的。之所以需要对象序列化，是因为有时候对象需要在网络上传输，传输的时候需要这种序列化处理，从服务器硬盘上把序列化的对象取出，然后通过网络传到客户端，再由客户端把序列化的对象读入内存，执行相应的处理。

　　 对象序列化是java的一个特征，通过该特征可以将对象写作一组字节码，当在其他位置读到这些字节码时，可以依此创建一个新的对象，而且新对象的状态与原对象完全相同。为了实现对象序列化，要求必须能够访问类的私有变量，从而保证对象状态能够正确的得以保存和恢复。相应的，对象序列化API能够在对象重建时，将这些值还原给私有的数据成员。这是对java语言访问权限的挑战。通常用在服务器客户端的对象交换上面，另外就是在本机的存储。

　　 对象序列化的最主要的用处就是在传递,和保存对象(object)的时候,保证对象的完整性和可传递性。譬如通过网络传输,或者把一个对象保存成一个文件的时候,要实现序列化接口 。

 

-----------------------------------------------------------------------------------------------------------

对象能包含其它的对象，而这其它的对象又可以包含另外的对象。JAVA serialization能够自动的处理嵌套的对象。对于一个对象的简单的域，writeObject()直接将值写入流。而，当遇到一个对象域时，writeObject()被再次调用，如果这个对象内嵌另一个对象，那么，writeObject() 又被调用，直到对象能被直接写入流为止。程序员所需要做的是将对象传入ObjectOutputStream 的writeObject() 方法，剩下的将又系统自动完成。下面的例子创建了一个调用mine对象的PersonalData对象。代码实现的是将一个串和mine 对象输出到一个流，并存入一个文件：

public class PersonalData implements Serializable {
public int id
public int yearOfBirth;
public float yearlySalary;
}
PersonalData mine = new PersonalData(101, 1956, 46500.00);
FileOutputStream outstream = new FileOutputStream("PersonalData.ser");
ObjectOutputStream out = new ObjectOutputStream(outstream);
out.writeObject("My personal data"); //将一个串写入流
out.writeObject(mine); //将这个对象写入流
out.close(); // 清空并关闭流
...

　　一个FileOutputStream对象被创建且传到一个ObjectOutputStream。当out.writeObject() 被调用，这个串和mine 对象被objects are serializ顺序加入一个存入文件PersonalData.ser的字节对列。

　　您应该注意上述类是实现的java.io.Serializable接口。因为它并未指定要实现的方法，所以Serializable被称为"tagging interface" ，但是它仅仅"tags"它自己的对象是一个特殊的类型。任一个您希望serialize的对象都应该实现这个接口。这是必须的。否则，用到流技术时将根本不工作。例如，如果您试着去serialize 一个没有实现这个接口的对象，一个 NotSerializableException将产生。

 

类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。

　　Java的"对象序列化"能让你将一个实现了Serializable接口的对象转换成一组byte，这样日后要用这个对象时候，你就能把这些byte数据恢复出来，并据此重新构建那个对象了。

　　要想序列化对象，你必须先创建一个OutputStream，然后把它嵌进ObjectOutputStream。这时，你就能用writeObject( )方法把对象写入OutputStream了。

　　writeObject 方法负责写入特定类的对象的状态，以便相应的 readObject 方法可以还原它。通过调用 out.defaultWriteObject 可以调用保存 Object 的字段的默认机制。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。

　　读的时候，你得把InputStream嵌到ObjectInputStream里面，然后再调用readObject( )方法。不过这样读出来的，只是一个Object的reference，因此在用之前，还得先下传。readObject 方法负责从流中读取并还原类字段。它可以调用 in.defaultReadObject 来调用默认机制，以还原对象的非静态和非瞬态字段。

　　　defaultReadObject 方法使用流中的信息来分配流中通过当前对象中相应命名字段保存的对象的字段。这用于处理类发展后需要添加新字段的情形。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。

　　看一个列子：

 

import  java.io. * ; 

class  tree  implements  java.io.Serializable  { 
     public  tree left; 
     public  tree right; 
     public   int  id; 
     public   int  level; 

     private   static   int  count  =   0 ; 

     public  tree( int  depth)  { 
        id  =  count ++ ; 
        level  =  depth; 
         if  (depth  >   0 )  { 
            left  =   new  tree(depth - 1 ); 
            right  =   new  tree(depth - 1 ); 
        }  
    }  

     public   void  print( int  levels)  { 
         for  ( int  i  =   0 ; i  <  level; i ++ ) 
            System.out.print( "    " ); 
        System.out.println( " node  "   +  id); 

         if  (level  <=  levels  &&  left  !=   null ) 
            left.print(levels); 

         if  (level  <=  levels  &&  right  !=   null ) 
            right.print(levels); 
    }  


     public   static   void  main (String argv[])  { 

         try   { 
             /**/ /*  创建一个文件写入序列化树。  */  
            FileOutputStream ostream  =   new  FileOutputStream( " tree.tmp " ); 
             /**/ /*  创建输出流  */  
            ObjectOutputStream p  =   new  ObjectOutputStream(ostream); 

             /**/ /*  创建一个二层的树。  */  
            tree base  =   new  tree( 2 ); 

            p.writeObject(base);  //  将树写入流中。 
            p.writeObject( " LiLy is 惠止南国 " );
            p.flush(); 
            ostream.close();     //  关闭文件。 

             /**/ /*  打开文件并设置成从中读取对象。  */  
            FileInputStream istream  =   new  FileInputStream( " tree.tmp " ); 
            ObjectInputStream q  =   new  ObjectInputStream(istream); 

             /**/ /*  读取树对象，以及所有子树  */  
            tree new_tree  =  (tree)q.readObject(); 

            new_tree.print( 2 );   //  打印出树形结构的最上面 ２级 
            String name  =  (String)q.readObject();
            System.out.println( " \n " + name);
        }   catch  (Exception ex)  { 
            ex.printStackTrace(); 
        }  
    }  
}  

 

 

　　最后结果如下：

    node 0
  node 1
node 2
node 3
  node 4
node 5
node 6

LiLy is 惠止南国

　　可以看到，在序列化的时候，writeObject与readObject之间的先后顺序。readObject将最先write的object read出来。用数据结构的术语来讲就姑且称之为先进先出吧！

　　在序列化时，有几点要注意的：
　　１：当一个对象被序列化时，只保存对象的非静态成员变量，不能保存任何的成员方法和静态的成员变量。
　　２：如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存。
　　３：如果一个可序列化的对象包含对某个不可序列化的对象的引用，那么整个序列化操作将会失败，并且会抛出一个NotSerializableException。我们可以将这个引用标记为transient，那么对象仍然可以序列化

　　还有我们对某个对象进行序列化时候，往往对整个对象全部序列化了，比如说类里有些数据比较敏感，不希望序列化，一个方法可以用transient来标识，另一个方法我们可以在类里重写

 

private   void  readObject(java.io.ObjectInputStream stream)
      throws  IOException, ClassNotFoundException;
  private   void  writeObject(java.io.ObjectOutputStream stream)
      throws  IOException

 

　　这二个方法！
　　示例：

 

import  java.io. * ;

class  ObjectSerialTest
{
     public   static   void  main(String[] args)  throws  Exception
     {
        Employee e1 = new  Employee( " zhangsan " , 25 , 3000.50 );
        Employee e2 = new  Employee( " lisi " , 24 , 3200.40 );
        Employee e3 = new  Employee( " wangwu " , 27 , 3800.55 );
        
        FileOutputStream fos = new  FileOutputStream( " employee.txt " );
        ObjectOutputStream oos = new  ObjectOutputStream(fos);
        oos.writeObject(e1);
        oos.writeObject(e2);
        oos.writeObject(e3);
        oos.close();
        
        FileInputStream fis = new  FileInputStream( " employee.txt " );
        ObjectInputStream ois = new  ObjectInputStream(fis);
        Employee e;
         for ( int  i = 0 ;i < 3 ;i ++ )
         {
            e = (Employee)ois.readObject();
            System.out.println(e.name + " : " + e.age + " : " + e.salary);
        }
        ois.close();
    }
}

class  Employee  implements  Serializable
{
    String name;
     int  age;
     double  salary;
     transient  Thread t = new  Thread();
     public  Employee(String name, int  age, double  salary)
     {
         this .name = name;
         this .age = age;
         this .salary = salary;
    }
     private   void  writeObject(java.io.ObjectOutputStream oos)  throws  IOException
     {
        oos.writeInt(age);
        oos.writeUTF(name);
        System.out.println( " Write Object " );
    }
     private   void  readObject(java.io.ObjectInputStream ois)  throws  IOException
     {
        age = ois.readInt();
        name = ois.readUTF();
        System.out.println( " Read Object " );
    }

}