Java之：序列化与反序列化

一、什么是序列化

序列化(Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。之后可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。

java中的序列化(serialization)机制能够将一个实例对象的状态信息写入到一个字节流中，使其可以通过socket进行传输、或者持久化存储到数据库或文件系统中；然后在需要的时候，可以根据字节流中的信息来重构一个相同的对象。序列化机制在java中有着广泛的应用，EJB、RMI等技术都是以此为基础的。

一般而言，要使得一个类可以序列化，只需简单实现java.io.Serializable接口即可（还要实现无参数的构造方法）。该接口是一个标记式接口，它本身不包含任何内容，实现了该接口则表示这个类准备支持序列化的功能。如下例定义了类Person，并声明其可以序列化。

二、Java序列化的实现

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

上代码：

package serializable;

import java.io.Serializable;

/**
 * Created by hupo.wh on 2016/7/3.
 */
public class Person implements Serializable {

    private static final long serialVersionUID = 1L;

    private String name;
    private int age;

    public Person(){

    }

    public Person(String str,int n){
        System.out.println("Inside Person's Constructor");
        name = str;
        age = n;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

注意：上述代码一定需要实现 Serializable 接口，否则在序列化的时候会出错，即使该接口什么接口方法都没定义，它的目的只是简单的标识一个类的对象可以被序列化。

1.默认格式

package serializable;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * Created by hupo.wh on 2016/7/3.
 */
public class SerializeToFlatFile {

    public static void main(String[] args) {
        SerializeToFlatFile ser = new SerializeToFlatFile();
        ser.savePerson();
        ser.restorePerson();
    }

    public void savePerson(){
        Person myPerson = new Person("Jay", 24);
        try{
            FileOutputStream fos = new FileOutputStream("d:\\person.txt");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            System.out.println("Person--Jay,24---Written");

            oos.writeObject(myPerson);
            oos.flush();
            oos.close();
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    //@SuppressWarnings("resource")
    public void restorePerson(){
        try{
            FileInputStream fls = new FileInputStream("d:\\person.txt");
            ObjectInputStream ois = new ObjectInputStream(fls);

            Person myPerson = (Person)ois.readObject();
            System.out.println("\n---------------------\n");
            System.out.println("Person --read:");
            System.out.println("Name is:"+myPerson.getName());
            System.out.println("Age is :"+myPerson.getAge());

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

会在”d:\person.txt”处生成文件，文件里面是：

2.XML格式

需要借用 XStream 实现

//参考:http://www.cnblogs.com/bluesky5304/archive/2010/04/07/1706061.html
public class SerializeXML {

    public static void main(String[] args) {
        SerializeXML ser = new SerializeXML();
        ser.serializeToXml();
        ser.deSerializeFromXml();
    }
    public void serializeToXml(){
        Person[] myPersons = new Person[2];
        myPersons[0] = new Person("Jay", 24);
        myPersons[1] = new Person("Tom", 23);

        XStream xStream = new XStream();
        xStream.alias("Person", Person.class);
        try{
            FileOutputStream foStream = new FileOutputStream("E:\\persons.xml");
            xStream.toXML(myPersons,foStream);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
    public void deSerializeFromXml(){
        XStream xStream = new XStream();
        xStream.alias("Person", Person.class);
        Person[] myPersons = null;
        try{
            FileInputStream flStream = new FileInputStream("E:\\persons.xml");
            myPersons = (Person[])xStream.fromXML(flStream);
            if(myPersons!=null){
                for(Person person:myPersons){
                    System.out.println(person.getName());
                    System.out.println(person.getAge());
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

输出结果：

<Person-array>  
  <Person>  
    <name>Jay</name>  
    <age>24</age>  
  </Person>  
  <Person>  
    <name>Tom</name>  
    <age>23</age>  
  </Person>  
</Person-array>  

3.JSON格式

//参考:http://www.cnblogs.com/hoojo/archive/2011/04/22/2025197.html
public class SerializeJSON {

    public static void main(String[] args) {
        SerializeJSON serializeJSON = new SerializeJSON();
        serializeJSON.writeJSON();
        serializeJSON.readJSON();
    }

    public void writeJSON(){
        XStream xStream = new XStream(new JettisonMappedXmlDriver());
        Person person = new Person("geniushehe", 16);
        try {
            FileOutputStream fos = new FileOutputStream("E:\\json.js");
            xStream.setMode(XStream.NO_REFERENCES);
            xStream.alias("Person", Person.class);
            xStream.toXML(person, fos);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
    public void readJSON(){
        XStream xStream = new XStream(new JettisonMappedXmlDriver());
        Person person = null;
        try {
            FileInputStream fis = new FileInputStream("E:\\json.js");
            xStream.setMode(XStream.NO_REFERENCES);
            xStream.alias("Person", Person.class);
            person = (Person)xStream.fromXML(fis);
            System.out.println(person.getName());
            System.out.println(person.getAge());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

输出：

{"Person":{"name":"geniushehe","age":16}}

三、什么时候使用序列化

1、对象序列化可以实现分布式对象。主要应用例如：RMI要利用对象序列化运行远程主机上的服务，就像在本地机上运行对象时一样。

2、java对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。可以将整个对象层次写入字节流中，可以保存在文件中或在网络连接上传递。利用对象序列化可以进行对象的”深复制”，即复制对象本身及引用的对象本身。序列化一个对象可能得到整个对象序列。

参考资料

[1] 百度百科

[2] http://blog.csdn.net/isea533/article/details/7859815