Java序列化Serializable和Externalizable

Posted slgkaifa

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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中进行使用。









以上是关于Java序列化Serializable和Externalizable的主要内容,如果未能解决你的问题,请参考以下文章

Java序列化和反序列化为什么要实现Serializable接口

Java序列化和反序列化为什么要实现Serializable接口

对Java Serializable(序列化)的理解和总结

Java序列化Serializable和Externalizable

Java 序列化Serializable详解

Java序列化为什么必须实现 Serializable 接口???