Sample code for the difference between Java serialization Serializable and 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();
        }
    }
}

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

相关文章：

Java序列化之Serializable

java 序列化对象 serializable 读写数据的实例

php—Serializable接口

The above is the detailed content of Sample code for the difference between Java serialization Serializable and Externalizable. For more information, please follow other related articles on the PHP Chinese website!