Java序列化Serializable和Externalizable

纸上得来终觉浅，绝知此事要躬行
 --陆游       问渠那得清如许，为有源头活水来  --朱熹

什么是Java序列化？为什么出现Java序列化？如何实现Java序列化？

一、什么是Java序列化

Java序列化是指把Java对象转换为字节序列的过程；而Java反序列化是指把字节序列恢复为Java对象的过程。

二、为什么出现Java序列化

两个进程之间进行通信时，须要传输各种信息。比方文本，图像，声音等等，这些信息是通过二进制流的形式进行传输的。

那么进程之间是不是也能够传递对象数据呢？答案是能够的。Java的序列化和反序列化就是将Java对象转化为字节序列，并

在网络上进行传输。反序列化将获得的字节序列数据生成对象。

三、如何实现Java序列化

1）、对象的输入输出：ObjectInputStream，ObjectOutputStream。

2）、对象要实现Serializable或者Externalizable接口。否则会抛出异常。

注意：在Serializable中声明为static和transient类型的成员数据不能被序列化。

实现Serializable接口的序列化和反序列化演示样例程序：

public class Student implements Serializable
{
    private String name;
    private char sex;
    public Student()
    {

    }
    public Student(String name,char sex)
    {
        this.name = name;
        this.sex = sex;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public void setSex(char sex)
    {
        this.sex = sex;
    }

    public String getName()
    {
        return this.name;
    }

    public char getSex()
    {
        return this.sex;
    }

}

public class UseStudent
{
    public static void main(String[] args)
    {
        Student st = new Student("Tom",‘M‘);
        File file = new File("O:\\Java\\com\\jieke\\io\\student.txt");
        try
        {
            file.createNewFile();
        }
        catch(IOException e)
        {
            e.printStackTrace();
        }
        try
        {
            //Student对象序列化过程
            FileOutputStream fos = new FileOutputStream(file);
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(st);
            oos.flush();
            oos.close();
            fos.close();

            //Student对象反序列化过程
            FileInputStream fis = new FileInputStream(file);
            ObjectInputStream ois = new ObjectInputStream(fis);
            Student st1 = (Student) ois.readObject();
            System.out.println("name = " + st1.getName());
            System.out.println("sex = " + st1.getSex());
            ois.close();
            fis.close();
        }
        catch(ClassNotFoundException e)
        {
            e.printStackTrace();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

使用Externalizable接口进行序列化。必需要重写writeExternal（ObjectOutput
output）和readExternal（ObjectInput input）方法

使用该接口的序列化方法须要我们来实现。因此能够对static和transient数据进行序列化。

public class Person implements Externalizable {
    private static final long serialVersionUID = -842029427676826563L;
    public static String name;
    private int age;
    private transient int workDay = 5;
    private String fClub;
    public Person() {
        System.out.println("none-arg constructor");
    }
    public Person(int age, String fClub) {
        this.age = age;
        this.fClub = fClub;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getWorkDay() {
        return workDay;
    }
    public void setWorkDay(int workDay) {
        this.workDay = workDay;
    }
    public String getfClub() {
        return fClub;
    }
    public void setfClub(String fClub) {
        this.fClub = fClub;
    }
    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject();//运行默认的序列化机制
        out.writeInt(workDay);
        System.out.println("正在进行序列持久化");
    }
    private void readObject(ObjectInputStream in) throws IOException,
            ClassNotFoundException {
        in.defaultReadObject();
        workDay = in.readInt();
        System.out.println("读取持久化对象");
    }
    @Override
    public void readExternal(ObjectInput arg0) throws IOException,
            ClassNotFoundException {
        // TODO Auto-generated method stub
    }
    @Override
    public void writeExternal(ObjectOutput arg0) throws IOException {
        // TODO Auto-generated method stub
    }
}
public class Hello {
    public static void main(String[] args) {
        Person person = new Person(26, "Juventus");
        person.setWorkDay(7);
        try {
            FileOutputStream fs = new FileOutputStream("foo.ser");
            ObjectOutputStream os = new ObjectOutputStream(fs);
            os.writeObject(person);
            os.close();
            Person.name = "Alex";
            FileInputStream in = new FileInputStream("foo.ser");
            ObjectInputStream s = new ObjectInputStream(in);
            Person p = (Person) s.readObject();
            System.out.println("name==" + Person.name + " age==" + p.getAge()
                    + " workDay==" + p.getWorkDay() + " fClub==" + p.getfClub());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}  

当然还有非常多开源的序列化和反序列化的库。能够在实际的project中进行使用。