Java序列化Serializable和Externalizable，

Java序列化Serializable和Externalizable，

转载自：http://blog.csdn.net/qq924862077/
纸上得来终觉浅，绝知此事要躬行 –陆游 问渠那得清如许，为有源头活水来 –朱熹

什么是Java序列化？为什么出现Java序列化？怎样实现Java序列化？
一、什么是Java序列化
Java序列化是指把Java对象转换为字节序列的过程；而Java反序列化是指把字节序列恢复为Java对象的过程。

二、为什么出现Java序列化
两个进程之间进行通信时，需要传输各种信息，比如文本，图像，声音等等，这些信息是通过二进制流的形式进行传输的。
那么进程之间是不是也可以传递对象数据呢？答案是可以的。Java的序列化和反序列化就是将Java对象转化为字节序列，并在网络上进行传输，反序列化将获得的字节序列数据生成对象。

三、怎样实现Java序列化

1）、对象的输入输出：ObjectInputStream，ObjectOutputStream。
2）、对象要实现Serializable或者Externalizable接口，否则会抛出异常。

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

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

import java.io.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;
    }
}

import java.io.*;

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数据进行序列化。

import java.io.*;

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
    }
}

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

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();
        }
    }
}

当然还有很多开源的序列化和反序列化的库，可以在实际的工程中进行使用。