java序列化的实现

一. 自动序列化

  1. java中要序列化对象要时，只要实现Serilizable接口即可，默认对象的所有属性都会被序列化，但是静态变量(static)不能被序列化。

实例代码如下：

public class Student implements Serializable {

    private static final long serialVersionUID = -2378603120577464262L;

    public Student(int id, String name, LocalDate birth) {
        this.id = id;
        this.name = name;
        this.birth = birth;
    }

    private int id;
    private String name;
    private LocalDate birth;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public LocalDate getBirth() {
        return birth;
    }

    public void setBirth(LocalDate birth) {
        this.birth = birth;
    }

    @Override
    public String toString() {
        return "id=" + this.id + ";name=" + this.name + ";birth=" + this.birth;
    }
}

序列化代码实现如下：

public class TestClass {

    public static void main(String[] args) throws IOException {
        try {
            serialize();
        } catch (Exception e) {
            System.err.println(e);
        }

        try {
            deserialize();
        } catch (Exception e) {
            System.err.println(e);
        }
    }

    private final static String FILENAME = "D:\\workfolder\\abc.txt";

    public static void serialize() throws IOException {
        Student student = new Student(10, "张三", LocalDate.of(2005, 10, 10));
        System.out.println(student);
        ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(FILENAME));
        os.writeObject(student);
        os.flush();
        os.close();
    }

    public static void deserialize() throws IOException, ClassNotFoundException {
        ObjectInputStream stream = new ObjectInputStream(new FileInputStream(FILENAME));
        Student student = (Student) stream.readObject();
        stream.close();
        System.out.println(student);
    }

}

结果显示：

id=10;name=张三;birth=2005-10-10
id=10;name=张三;birth=2005-10-10

 

有时候对象的某些属性不需要进行序列化，比方密码等敏感数据，可以在这些变量上加上 transient 关键字来修饰，用transient来修饰的属性则不会被序列化。

比如，将Student的birth属性改为如下：

private transient LocalDate birth;

重新执行序列化和反序列化，则如下结果：

id=10;name=张三;birth=2005-10-10
id=10;name=张三;birth=null

 

2.transient关键字只能修饰变量，而不能修饰方法和类。变量如果是用户自定义类变量，则该类需要实现Serializable接口。

二. 自定以序列化

 1: JDK中提供了另一个序列化接口--Externalizable，使用该接口之后，之前基于Serializable接口的序列化机制就将失效。Externalizable继承于Serializable，当使用该接口时，序列化的细节需要由程序员去完成。

实例代码如下：

public class TestClass {

    public static void main(String[] args) {
        try {
            serialize();
        } catch (Exception e) {
            System.err.println(e);
        }

        try {
            deserialize();
        } catch (Exception e) {
            System.err.println(e);
        }
    }

    private final static String FILENAME = "D:\\workfolder\\abc.txt";

    public static void serialize() throws IOException {
         Address address =  new Address("广东省", "广州市", "天河区");
        ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream(FILENAME));
        os.writeObject(address);
        os.flush();
        os.close();
    }

    public static void deserialize() throws IOException, ClassNotFoundException {
        ObjectInputStream stream = new ObjectInputStream(new FileInputStream(FILENAME));
        Address address = (Address) stream.readObject();
        stream.close();
        System.out.println(address);
     }
}

public class Address implements Externalizable {
 
    private String sheng;
    private String shi;
    private String qu;
 
    public Address() {
　　　　　　　　System.out.println("init...");
     }

    public Address(String sheng, String shi, String qu) {
        super();
        this.sheng = sheng;
        this.shi = shi;
        this.qu = qu;
    }

    public String getSheng() {
        return sheng;
    }

    public void setSheng(String sheng) {
        this.sheng = sheng;
    }

    public String getShi() {
        return shi;
    }

    public void setShi(String shi) {
        this.shi = shi;
    }

    public String getQu() {
        return qu;
    }

    public void setQu(String qu) {
        this.qu = qu;
    }

    @Override
    public String toString() {
        return "sheng=" + this.sheng + ";shi=" + this.shi + ";qu=" + this.qu;
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {

        out.writeUTF(sheng);
        out.writeUTF(shi);
        out.writeUTF(qu);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        sheng = in.readUTF();
        shi = in.readUTF();
        qu = in.readUTF();
    }
}

输出结果如下：
init...
sheng=广东省;shi=广州市;qu=天河区

使用Externalizable进行序列化，对象必须有一个无参的构造函数，且访问权限为public，当读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。

2: 实现Serializable , 添加下列两个方法，

private void writeObject(java.io.ObjectOutputStream s) throws IOException {
 ...
}

private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {
  ...
}

具体实现略