java中的序列化和反序列化

一 简介

把对象转换为字节序列的过程称为对象的序列化
把字节序列恢复为对象的过程称为对象的反序列化
对象的序列化主要有两种用途：
1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；
2） 在网络上传送对象的字节序列。

在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有 10万用户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把一些seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中。

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

二 Java中的序列化API

java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中；java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回

只有实现了Serializable或Externalizable接口的类的对象才能被序列化。有些java教程里面讲过，Externalizable接口继承自 Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以 采用默认的序列化方式 。

对象序列化包括如下步骤：
1） 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；
2） 通过对象输出流的writeObject()方法写对象。

对象反序列化的步骤如下：
1） 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
2） 通过对象输入流的readObject()方法读取对象。

三 使用Serializable接口实现的实例

首先定义了一个实现了Serializable接口WebSite的实体类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

package  cn.zifangsky.serializable;   import  java.io.Serializable;   public  class  WebSite  implements  Serializable {      private  static  final  long  serialVersionUID = 1835573222135484360L;        private  String siteName;      private  String siteUrl;      private  String webMaster;        public  WebSite() {        }        public  WebSite(String siteName, String siteUrl, String webMaster) {          this .siteName = siteName;          this .siteUrl = siteUrl;          this .webMaster = webMaster;      }        public  String getSiteName() {          return  siteName;      }        public  void  setSiteName(String siteName) {          this .siteName = siteName;      }        public  String getSiteUrl() {          return  siteUrl;      }        public  void  setSiteUrl(String siteUrl) {          this .siteUrl = siteUrl;      }        public  String getWebMaster() {          return  webMaster;      }        public  void  setWebMaster(String webMaster) {          this .webMaster = webMaster;      }        public  String toString() {          return  "WebSite [siteName="  + siteName +  ", siteUrl="  + siteUrl +  ", webMaster="  + webMaster +  "]" ;      }   }

然后进行序列化和反序列化测试：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

package  cn.zifangsky.serializable;   import  java.io.File; import  java.io.FileInputStream; import  java.io.FileNotFoundException; import  java.io.FileOutputStream; import  java.io.IOException; import  java.io.ObjectInputStream; import  java.io.ObjectOutputStream;   public  class  TestSerialize {        public  static  void  main(String[] args)  throws  FileNotFoundException, IOException, ClassNotFoundException {          TestSerialize.serializeWebSite();          TestSerialize.deserializeWebSite();      }            /**       * 使用ObjectOutputStream 序列化WebSite       * @throws IOException        * @throws FileNotFoundException        *        * */      public  static  void  serializeWebSite()  throws  FileNotFoundException, IOException{          WebSite webSite =  new  WebSite();          webSite.setSiteName( "zifangsky的个人博客" );          webSite.setSiteUrl( "http://www.zifangsky.cn" );          webSite.setWebMaster( "zifangsky" );                    //序列化          ObjectOutputStream objectOutputStream =  new  ObjectOutputStream( new  FileOutputStream( new  File( "C:/Users/Administrator/Desktop/test.txt" )));          objectOutputStream.writeObject(webSite);          objectOutputStream.flush();          objectOutputStream.close();      }            /**       * 使用ObjectInputStream 反序列化WebSite       * @throws IOException        * @throws FileNotFoundException        * @throws ClassNotFoundException        *        * */      public  static  void  deserializeWebSite()  throws  FileNotFoundException, IOException, ClassNotFoundException{          ObjectInputStream objectInputStream =  new  ObjectInputStream( new  FileInputStream( new  File( "C:/Users/Administrator/Desktop/test.txt" )));          //反序列化          WebSite webSite = (WebSite) objectInputStream.readObject();          objectInputStream.close();            System.out.println(webSite);      }       }

输出：

1	WebSite [siteName=zifangsky的个人博客, siteUrl=http://www.zifangsky.cn, webMaster=zifangsky]

四 使用Externalizable接口实现的实例

实现了Externalizable接口的实体类：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

package  cn.zifangsky.serializable;   import  java.io.Externalizable; import  java.io.IOException; import  java.io.ObjectInput; import  java.io.ObjectOutput;   public  class  ExternalizableDemo  implements  Externalizable{      private  String name;      static  {          System.out.println( "调用静态代码块" );      }        public  ExternalizableDemo() {          System.out.println( "调用无参构造方法" );      }        public  ExternalizableDemo(String name) {          this .name = name;          System.out.println( "调用有参构造方法" );      }        public  String getName() {          return  name;      }        public  void  setName(String name) {          this .name = name;      }        public  String toString() {          return  "ExternalizableDemo [name="  + name +  "]" ;      }            /**       * ObjectOutputStream会调用writeExternal(ObjectOutput out))这个方法进行序列化       * */      public  void  writeExternal(ObjectOutput out)  throws  IOException {          out.writeObject(name);      }        /**       * ObjectInputStream会调用readExternal(ObjectInput in)这个方法进行反序列化       * */      public  void  readExternal(ObjectInput in)  throws  IOException, ClassNotFoundException {          name = (String) in.readObject();      }   }

然后进行序列化和反序列化测试：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

package  cn.zifangsky.serializable;   import  java.io.File; import  java.io.FileInputStream; import  java.io.FileNotFoundException; import  java.io.FileOutputStream; import  java.io.IOException; import  java.io.ObjectInputStream; import  java.io.ObjectOutputStream;   public  class  TestExternalizable {        public  static  void  main(String[] args)  throws  FileNotFoundException, IOException, ClassNotFoundException {          ExternalizableDemo demo =  new  ExternalizableDemo( "hello" );          // 序列化          ObjectOutputStream objectOutputStream =  new  ObjectOutputStream(                  new  FileOutputStream( new  File( "C:/Users/Administrator/Desktop/test2.txt" )));          objectOutputStream.writeObject(demo);          objectOutputStream.flush();          objectOutputStream.close();                    //反序列化          ObjectInputStream objectInputStream =  new  ObjectInputStream( new  FileInputStream( new  File( "C:/Users/Administrator/Desktop/test2.txt" )));          ExternalizableDemo demo2 = (ExternalizableDemo) objectInputStream.readObject();          objectInputStream.close();          System.out.println(demo2);           }   }

输出：

1 2 3 4

调用静态代码块 调用有参构造方法 调用无参构造方法 ExternalizableDemo [name=hello]

注：

（1）使用Externalizable进行序列化时，当读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中

（2）Externalizable接口继承自Serializable接口。两者的区别如下：

假设有一个Customer类的对象需要序列化，如果这个类仅仅实现了这个接口，那么序列化和反序列化的方式如下：ObjectOutputStream采用默认的序列化方式，对于这个类的非static，非transient的实例变量进行序列化，ObjectInputStream采用默认的反序列化方式，对于这个类的非static，非transient的实例变量进行反序列化。

如果这个类不仅实现了Serializable接口，而且定义了readObject（ObjectInputStream in）和 writeObject(ObjectOutputStream out)方法，那么将按照如下的方式进行序列化和反序列化：

ObjectOutputStream会调用这个类的writeObject方法进行序列化，

ObjectInputStream会调用相应的readObject方法进行反序列化。

实现Externalizable接口的类完全由自身来控制序列化的行为。而且必须实现writeExternal（ObjectOutput out）和readExternal（ObjectInput in）。那么将按照如下的方式进行序列化和反序列化：

ObjectOutputStream会调用这个类的writeExternal方法进行序列化，

ObjectInputStream会调用相应的readExternal方法进行反序列化