序列化是什么：

序列化就是将一个对象的状态（各个属性量）保存起来，然后在适当的时候再获得。

序列化分为两大部分：序列化和反序列化。序列化是这个过程的第一部分，将数据分解成字节流，以便存储在文件中或在网络上传输。反序列化就是打开字节流并重构对象。对象序列化不仅要将基本数据类型转换成字节表示，有时还要恢复数据。

恢复数据要求有恢复数据的对象实例

序列化的什么特点：

如果某个类能够被序列化，其子类也可以被序列化。声明为static和transient类型的成员数据不能被序列化。因为static代表类的状态， transient代表对象的临时数据。

public interface Serializable (API5.0)

 

类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。 要允许不可序列化类的子类型序列化，可以假定该子类型负责保存和还原超类型的公用 (public)、受保护的 (protected) 和（如果可访问）包 (package) 字段的状态。仅在子类型扩展的类有一个可访问的无参数构造方法来初始化该类的状态时，才可以假定子类型有此责任。如果不是这种情况，则声明一个类为可序列化类是错误的。该错误将在运行时检测到。

在反序列化过程中，将使用该类的公用或受保护的无参数构造方法初始化不可序列化类的字段。可序列化的子类必须能够访问无参数的构造方法。可序列化子类的字段将从该流中还原。

当遍历一个图形时，可能会遇到不支持可序列化接口的对象。在此情况下，将抛出NotSerializableException，并将标识不可序列化对象的类。

在序列化和反序列化过程中需要特殊处理的类必须使用下列准确签名来实现特殊方法：

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

writeObject 方法负责写入特定类的对象的状态，以便相应的 readObject 方法可以还原它。通过调用 out.defaultWriteObject

可以调用保存 Object 的字段的默认机制。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。

readObject 方法负责从流中读取并还原类字段。它可以调用 in.defaultReadObject 来调用默认机制，以还原对象的

非静态和非瞬态字段。defaultReadObject 方法使用流中的信息来分配流中通过当前对象中相应命名字段保存的对象的字段。

这用于处理类发展后需要添加新字段的情形。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。

将对象写入流时需要指定要使用的替代对象的可序列化类，应使用准确的签名来实现此特殊方法：

ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;

此 writeReplace 方法将由序列化调用，前提是如果此方法存在，而且它可以通过被序列化对象的类中定义的一个方法访问。因此，该方法可以拥有私有 (private)、受保护的 (protected) 和包私有 (package-private) 访问。子类对此方法的访问遵循 java 访问规则。

在从流中读取类的一个实例时需要指定替代的类应使用的准确签名来实现此特殊方法。

ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;

此 readResolve 方法遵循与 writeReplace 相同的调用规则和访问规则。

序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同，则反序列化将会导致 InvalidClassException。可序列化类可以通过声明名为 "serialVersionUID"的字段（该字段必须是静态 (static)、最终 (final) 的 long型字段）显式声明其自己的 serialVersionUID：

ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;

如果可序列化类未显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值，如“Java(TM) 对象序列化规范”中所述。不过，强烈建议 所有可序列化类都显式声明 serialVersionUID 值，原因计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，这样在反序列化过程中可能会导致意外的 InvalidClassException。因此，为保证 serialVersionUID 值跨不同 java 编译器实现的一致性，序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private修改器显示声明 serialVersionUID（如果可能），原因是这种声明仅应用于立即声明类 -- serialVersionUID 字段作为继承成员没有用处

实用意义:

 一：对象序列化可以实现分布式对象。

主要应用例如：RMI要利用对象序列化运行远程主机上的服务，就像在本地机上运行对象时一样。

二：java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。可以将整个对象层次写入字节流中，可以保存在文件中或在网络

连接上传递。利用对象序列化可以进行对象的“深复制”，即复制对象本身及引用的对象本身。序列化一个对象可能得到整个对象序列。

EP:

import java.io.Serializable;

import java.io.FileOutputStream;

import java.io.ObjectOutputStream;

import java.io.FileInputStream;

import java.io.ObjectInputStream;

class MeTree implements Serializable {

 private static final long serialVersionUID = 42L;

 public MeTree left;

 public MeTree right;

 public int  id;

 public int level;

    private static int count  =   0 ; 

    public  MeTree( int  depth)   {

          id  = count ++ ;

          level  =  depth;

         if  (depth  >   0 )   {

         

            left  =   new  MeTree(depth - 1 );

            right  =   new  MeTree(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( " MeTree.tmp " );

             /**/ /* 创建输出流 */ 

            ObjectOutputStream p  =   new  ObjectOutputStream(ostream);

             /**/ /* 创建一个二层的树。 */ 

            MeTree base  =   new  MeTree( 2 );

            p.writeObject(base);  // 将树写入流中。

             p.writeObject( " LiLy is 惠止南国 " );

            p.flush();

            ostream.close();     // 关闭文件。

 

              /**/ /* 打开文件并设置成从中读取对象。 */ 

            FileInputStream istream  =   new  FileInputStream( " MeTree.tmp " );

            ObjectInputStream q  =   new  ObjectInputStream(istream);

             /**/ /* 读取树对象，以及所有子树 */ 

            MeTree new_MeTree  =  (MeTree)q.readObject();

            new_MeTree.print( 2 );   // 打印出树形结构的最上面 ２级

             String name  =  (String)q.readObject();

            System.out.println( " /n " + name);

        }   catch  (Exception ex)   {

            ex.printStackTrace();

        } 

     }

}

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

在序列化时，有几点要注意的：

　    １：当一个对象被序列化时，只保存对象的非静态成员变量，不能保存任何的成员方法和静态的成员变量。

　　２：如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存。

　　３：如果一个可序列化的对象包含对某个不可序列化的对象的引用，那么整个序列化操作将会失败，并且会抛出一个NotSerializableException。我们可以将这个引用标记为transient，那么对象仍然可以序列化

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

可以通过指定关键transient使对象中的某个数据元素不被还原，这种方式常用于安全上的保护。比如对象中保存的密码。

//**

transient 只能用在类的成员变量上,不能用在方法里. 

transient 变量不能是final和static的

transient（临时）关键字

控制序列化过程时，可能有一个特定的子对象不愿让Java的序列化机制自动保存与恢复。一般地，若那个子对象包含了不想序列化的敏感信息（如密码），就会面临这种情况。即使那种信息在对象中具有“private”（私有）属性，但一旦经序列化处理，人们就可以通过读取一个文件，或者拦截网络传输得到它。

为防止对象的敏感部分被序列化，一个办法是将自己的类实现为Externalizable，就象前面展示的那样。这样一来，没有任何东西可以自动序列化，只能在writeExternal()明确序列化那些需要的部分。

然而，若操作的是一个Serializable对象，所有序列化操作都会自动进行。为解决这个问题，

可以用transient（临时）逐个字段地关闭序列化，它的意思是“不要麻烦你（指自动机制）保存或恢复它了——我会自己处理的”。

例如，假设一个Login对象包含了与一个特定的登录会话有关的信息。校验登录的合法性时，一般都想将数据保存下来，但不包括密码。

为做到这一点，最简单的办法是实现Serializable，并将password字段设为transient。

password被设为transient，

所以不会自动保存到磁盘；另外，自动序列化机制也不会作恢复它的尝试。

一旦对象恢复成原来的样子，password字段就会变成null。注意必须用toString()检查password是否为null，因为若用过载的“+”运算符来装配一个String对象，而且那个运算符遇到一个null句柄，就会造成一个名为NullPointerException的违例（新版Java可能会提供避免这个问题的代码）。

我们也发现date字段被保存到磁盘，并从磁盘恢复，没有重新生成。

由于Externalizable对象默认时不保存它的任何字段，所以transient关键字只能伴随Serializable使用。

**//　还有我们对某个对象进行序列化时候，往往对

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

1、实现Serializable会导致发布的API难以更改，并且使得package-private和private这两个本来封装的较好的咚咚也不能得到保障2、Serializable会为每个类生成一个序列号，生成依据是类名、类实现的接口名、public和protected方法，所以只要你一不小心改了一个已经publish的API，并且没有自己定义一个long类型的叫做serialVersionUID的field，哪怕只是添加一个getXX，就会让你读原来的序列化到文件中的东西读不出来（不知道为什么要把方法名算进去？）3、不用构造函数用Serializable就可以构造对象，看起来不大合理，这被称为extralinguistic mechanism，所以当实现Serializable时应该注意维持构造函数中所维持的那些不变状态4、增加了发布新版本的类时的测试负担5、1.4版本后，JavaBeans的持久化采用基于XML的机制，不再需要Serializable6、设计用来被继承的类时，尽量

不实现Serializable，用来被继承的interface也不要继承Serializable。但是如果父类不实现Serializable接口，子类很难实现它，特别是对于父类没有可以访问的不含参数的构造函数的时候。所以，一旦你决定不实现Serializable接口并且类被用来继承的时候记得提供一个无参数的构造函数7、内部类还是不要实现Serializable好了，除非是static的，(偶也觉得内部类不适合用来干这类活的)8、使用一个自定义的序列化方法

看看下面这个保存一个双向链表的例子：

publicclass StringList implementsSerializable

{

?privateint size = 0;

?private Entry head = null;

?

?privatestaticclass Entry implements Serializable

?{

? String data;

? Entry next;

? Entry previous;

?}

?...//Remainder ommitted

}

这样会导致链表的每个元素以及元素之间的关系（双向链表之间的连接）

都保存下来，更好的方法是提供一个自定义的序列化如下：//String List with a resonable custom serialized form

class StringList implementsSerializable

{

? privatetransientint size = 0;?????? //!transient

? privatetransient Entry head = null;? //!transient

?

? //no longer serializable!

? privatestaticclass Entry

? {

??? String data;

??? Entry next;

??? Entry previous;

? }

?

? //Appends the specified string to the list

? publicvoid add(String s) {/*...*/};

?

? /**

?? * Serialize this

StringList

instance

?? * @author yuchifang

?? * @serialData The size of the list (the number of strings

* it contains) is emitted(int), in the proper sequence

?? */

? privatevoid writeObject(ObjectOutputStream s)

throws IOException

? {

??? s.defaultWriteObject();

??? s.writeInt(size);

??? //Write out all elements in the proper order

??? for (Entry e = head; e != null; e = e.next)

????? s.writeObject(e.data);

? }

?

? privatevoid readObject(ObjectInputStream s)

throws IOException, ClassNotFoundException

? {

??? int numElements = s.readInt();

???

??? //Read in all elements andd insert them in list

??? for (int i = 0; i < numElements; i++)

????? add((String)s.readObject());

? }

? //...remainder omitted

}

9、不管你选择什么序列化形式，声明一个显式的UID：private static final long serialVersionUID = randomLongValue;

10、不需要序列化的东西使用transient注掉它吧，别什么都留着11、writeObject/readObject重载以完成更好的序列化BR>readResolve 与 writeReplace重载以完成更好的维护invariant controllers

  完全定制序列化过程:

如果一个类要完全负责自己的序列化，则实现Externalizable接口而不是Serializable接口。

Externalizable接口定义包括两个方法writeExternal()与readExternal()。利用这些方法可以控制对象数据成员

如何写入字节流.类实现Externalizable时，头写入对象流中，然后类完全负责序列化和恢复数据成员，.

除了头以外，根本没有自动序列化。这里要注意了。声明类实现Externalizable接口会有重大的安全风险。

writeExternal()与readExternal()方法声明为public，恶意类可以用这些方法读取和写入对象数据。如果对象包含敏感信息，则要格外小心。这包括使用安全套接或加密整个字节流。

到此为至，我们学习了序列化的基础部分知识。关于序

列化的高级教程，以后再述.

 1.Serializable

只有一个实现Serializable接口的对象可以被序列化工具存储和恢复。Serializable接口没有定义任何成员。它只用来表示一个类可以被序列化。如果一个类可以序列化，它的所有子类都可以序列化。

声明成transient的变量不被序列化工具存储。同样，static变量也不被存储。
private void serializeSessionObject(HttpSession session, File targetFile, User user) throws IOException {
    targetFile.deleteOnExit();
    FileOutputStream fos = new FileOutputStream(targetFile);
    ObjectOutputStream oos = new ObjectOutputStream(fos);
    oos.writeObject(user);
    oos.flush();
    oos.close();
    session.setAttribute(USER_OBJECT_KEY, user);
    session.setAttribute(USER_SERIALIZE_FILE_KEY, targetFile.getAbsolutePath());
  }
private void unserializeSessionObject(HttpSession session, File sourceFile) throws IOException {
    FileInputStream fis = new FileInputStream(sourceFile);
    ObjectInputStream ois = new ObjectInputStream(fis);
    User user = null;
    try{
      user = (User)ois.readObject();
    }
    catch(ClassNotFoundException ex){
      throw new RuntimeException("Deserialize user object occurs error.",ex);
    }
    ois.close();
    session.setAttribute(USER_OBJECT_KEY, user);
    session.setAttribute(USER_SERIALIZE_FILE_KEY, sourceFile.getAbsolutePath());
  }

2.transient 关键字有什么用途

java有个特点就是序列化，简单地来说就是可以将这个类存储在物理空间（当然还是以文件的形式存在），那么当你从本地还原这个文件时，你可以将它转换为它本身。这可以极大地方便网络上的一些操作，但同时，因为涉及到安全问题，所以并不希望把类里面所有的东西都能存储（因为那样，别人可以通过序列化知道类里面的内容），那么我们就可以用上transient这个关键字，它的意思是临时的，即不会随类一起序列化到本地，所以当还原后，这个关键字定义的变量也就不再存在。 通常,我们写的程序都要求特定信息能持久存在或保存到磁盘上,以供一个程序使用或用在同一个程序的另一次运行上.这种持久性可以通过几种方式来实现,包括写到数据库中或是利用JAVA为对象序列化提供的支持.不管我们选用什么方法,类实例的持久性都是通过保存类的域的状态来完成的,保存这些状态,以便以后可以对它们进行访问或使用它们来创建相同的实例.然而,有可能并不是所有的域都需要被保存起来.当一个实例被持久化时,其内部的一些域却不需要持久化,则可以用trainsient修饰符告诉编译器指定的域不需要被持久保存.