Java基礎知識系列—序列化

時間 2019-11-21

標籤 java 基礎知識系列序列欄目 Java 简体版

原文原文鏈接

序列化是將對象的狀態轉換爲字節流；反序列化偏偏相反。換言之，序列化是將Java對象轉換爲字節的靜態流（序列，而後能夠將其保存到數據庫或經過網絡傳輸。java

序列化和反序列化

序列化過程是獨立於實例的，即對象能夠在一個平臺上序列化並在另外一個平臺上反序列化。有資格序列化的類須要實現一個特殊的標記接口Serializable。數據庫

ObjectInputStream和ObjectOutputStream都是分別擴展java.io.InputStream和java.io.OutputStream的高級類。 ObjectOutputStream能夠將對象的基本類型和對象做爲字節流寫入OutputStream。隨後可使用ObjectInputStream讀取這些流。網絡

ObjectOutputStream提供了writeObject方法能夠將可序列化的對象轉換爲字節的序列（流），一樣地，ObjectInputStream提供了readObject方法能夠將字節流轉換爲Java對象。ide

請注意，靜態字段屬於類（與對象相對）並不會被序列化；另外，也可使用關鍵字transient忽略字段序列化。測試

用一個Person類來講明序列化，其源碼以下：this

public class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    static String country = "ITALY";
    private int age;
    private String name;
    transient int height;
 
    // getters and setters
}

@Test
public void whenSerializingAndDeserializing_ThenObjectIsTheSame() () throws IOException, ClassNotFoundException { 
    Person person = new Person();
    person.setAge(20);
    person.setName("Joe");
     
    FileOutputStream fileOutputStream
      = new FileOutputStream("yourfile.txt");
    ObjectOutputStream objectOutputStream 
      = new ObjectOutputStream(fileOutputStream);
    objectOutputStream.writeObject(person);
    objectOutputStream.flush();
    objectOutputStream.close();
     
    FileInputStream fileInputStream
      = new FileInputStream("yourfile.txt");
    ObjectInputStream objectInputStream
      = new ObjectInputStream(fileInputStream);
    Person p2 = (Person) objectInputStream.readObject();
    objectInputStream.close(); 
  
    assertTrue(p2.getAge() == p.getAge());
    assertTrue(p2.getName().equals(p.getName()));
}
複製代碼

序列化注意事項

繼承與構成

當一個類實現了java.io.Serializable接口時，它的全部子類也是可序列化的。相反，當一個對象具備對另外一個對象的引用時，這些對象必須單獨實現Serializable接口，不然會引起NotSerializableException異常。spa

public class Person implements Serializable {
    private int age;
    private String name;
    private Address country; // must be serializable too
}
複製代碼

Serial Version UID

JVM將版本號與每一個可序列化的類相關聯。它用於驗證保存和加載的對象具備相同的屬性，所以在序列化時兼容。code

若是可序列化的類沒有聲明serialVersionUID，則JVM將在運行時自動生成一個。可是，強烈建議每一個類聲明其serialVersionUID，由於生成的是依賴於編譯器的，所以可能會致使意外的InvalidClassExceptions。cdn

Java中的自定義序列化

Java指定了能夠序列化對象的默認方式。Java類能夠覆蓋此默認行爲。在嘗試序列化具備一些不可序列化屬性的對象時，自定義序列化特別有用。對象

一、在類中提供writeObject和readObject方法

能夠經過在類中提供兩個咱們想要序列化的方法來完成：

private void writeObject(ObjectOutputStream out) throws IOException;

private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException;
複製代碼

經過這些方法，咱們能夠將那些不可序列化的屬性序列化爲能夠序列化的其餘形式：

public class Employee implements Serializable {
    private static final long serialVersionUID = 1L;
    private transient Address address;
    private Person person;
 
    // setters and getters
 
    private void writeObject(ObjectOutputStream oos) throws IOException {
        oos.defaultWriteObject();
        oos.writeObject(address.getHouseNumber());
    }
 
    private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException {
        ois.defaultReadObject();
        Integer houseNumber = (Integer) ois.readObject();
        Address a = new Address();
        a.setHouseNumber(houseNumber);
        this.setAddress(a);
    }
}

public class Address {
    private int houseNumber;
 
    // setters and getters
}
複製代碼

測試自定義序列化：

@Test
public void whenCustomSerializingAndDeserializing_ThenObjectIsTheSame() throws IOException, ClassNotFoundException {
    Person p = new Person();
    p.setAge(20);
    p.setName("Joe");
 
    Address a = new Address();
    a.setHouseNumber(1);
 
    Employee e = new Employee();
    e.setPerson(p);
    e.setAddress(a);
 
    FileOutputStream fileOutputStream
      = new FileOutputStream("yourfile2.txt");
    ObjectOutputStream objectOutputStream 
      = new ObjectOutputStream(fileOutputStream);
    objectOutputStream.writeObject(e);
    objectOutputStream.flush();
    objectOutputStream.close();
 
    FileInputStream fileInputStream 
      = new FileInputStream("yourfile2.txt");
    ObjectInputStream objectInputStream 
      = new ObjectInputStream(fileInputStream);
    Employee e2 = (Employee) objectInputStream.readObject();
    objectInputStream.close();
 
    assertTrue(
      e2.getPerson().getAge() == e.getPerson().getAge());
    assertTrue(
      e2.getAddress().getHouseNumber() == e.getAddress().getHouseNumber());
}
複製代碼

二、實現Externalizable接口

除了Serializable 以外，java中還提供了另外一個序列化接口Externalizable。

Externalizable繼承了Serializable，該接口中定義了兩個抽象方法：writeExternal()與readExternal()。當使用Externalizable接口來進行序列化與反序列化的時候須要開發人員重寫writeExternal()與readExternal()方法。

public class Person implements Externalizable {

    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Address getCountry() {
        return country;
    }

    public void setCountry(Address country) {
        this.country = country;
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeInt(age);
        out.writeObject(name);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
       age =  in.readInt();
       name = (String) in.readObject();
    }
}
複製代碼

測試代碼以下:

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("yourfile2.txt"));
        Person person = new Person();
        person.setAge(10);
        person.setName("zhang san");
        oos.writeObject(person);

        //Read Obj from file
        File file = new File("yourfile2.txt");
        ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
        Person newInstance = (Person) ois.readObject();
複製代碼