當前位置：首頁 > 编程语言 > java >内容正文

java

java自定义外部接口_如何使用可外部化的接口在Java中自定义序列化

發布時間：2023/12/3 java 47 豆豆

生活随笔收集整理的這篇文章主要介紹了 java自定义外部接口_如何使用可外部化的接口在Java中自定义序列化小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

java自定義外部接口

在上一篇文章“用示例介紹的有關Java序列化的一切”中，我解釋了如何使用以下方法序列化/反序列化一個對象
Serializable接口，還說明了如何使用writeObject和readObject方法自定義序列化過程。

Java序列化過程的缺點

但是這些自定義是不夠的，因為JVM可以完全控制序列化過程，而這些自定義邏輯只是默認序列化過程的補充。我們仍然必須通過從writeObject和ObjectInputStream.defaultReadObject()調用ObjectOutputStream.defaultWriteObject()和ObjectInputStream.defaultReadObject()來使用默認的序列化邏輯。
readObject方法。而且，如果不調用這些默認方法，我們的對象將不會被序列化/反序列化。

默認的序列化過程是完全遞歸的。因此，每當我們嘗試序列化一個對象時，序列化過程就會嘗試使用我們的類（ static和static除外）對所有字段（原始和引用）進行序列化。
transient場）。這使得序列化過程非常緩慢。

現在，假設我們有一個對象，其中包含許多字段，由于某些原因，我們不想序列化這些字段（這些字段將始終分配有默認值）。使用默認的序列化過程，我們將必須使所有這些字段都是瞬態的，但是它仍然不會高效，因為將進行大量檢查以查看這些字段是否為瞬態的。

因此，如我們所見，使用默認序列化過程有很多弊端，例如：

序列化的定制是不夠的，因為JVM可以完全控制序列化過程，而我們的定制邏輯只是默認序列化過程的補充。

默認序列化過程是完全遞歸且緩慢的。

為了不對字段進行序列化，我們必須將其聲明為瞬態，大量瞬態字段將再次使過程變慢。

我們無法控制如何對字段進行序列化和反序列化。

默認序列化過程在創建對象時不會調用構造函數，因此它無法調用構造函數提供的初始化邏輯。

什么是外部化和外部化接口

正如我們在上面看到的那樣，默認的Java序列化效率不高。我們可以通過使用Externalizable接口而不是
Serializable接口。

我們可以通過實現
可外部化的接口并覆蓋它的方法writeExternal()和
readExternal() 。但是使用這種方法，我們將無法從JVM獲得任何類型的默認序列化邏輯，而是由我們來提供完整的序列化和反序列化邏輯。

因此，非常仔細地對測試這些方法進行編碼非常必要，因為這可能會破壞序列化過程。但是，如果正確實現，與默認序列化過程相比，外部化過程非常快。

我們將以下面的Employee類對象為例進行說明：

// Using Externalizable, complete serialization/deserialization logic becomes our responsibility, // We need to tell what to serialize using writeExternal() method and what to deserialize using readExternal(), // We can even serialize/deserialize static and transient variables, // With implementation of writeExternal() and readExternal(), methods writeObject() and readObject() becomes redundant and they do not get called. Employee class implements Externalizable { // This serialVersionUID field is necessary for Serializable as well as Externalizable to provide version control, // Compiler will provide this field if we do not provide it which might change if we modify class structure of our class, and we will get InvalidClassException, // If we provide a value to this field and do not change it, serialization-deserialization will not fail if we change our class structure. private static final long serialVersionUID = 2L; private String firstName; private transient String lastName; // Using Externalizable, we can even serialize/deserialize transient variables, so declaring fields transient becomes unnecessary. private int age; private static String department; // Using Externalizable, we can even serialize/deserialize static variables according to our need. // Mandatory to have to make our class Externalizable // When an Externalizable object is reconstructed, the object is created using public no-arg constructor before the readExternal method is called. // If a public no-arg constructor is not present then a InvalidClassException is thrown at runtime. public Employee() { } // All-arg constructor to create objects manually public Employee(String firstName, String lastName, int age, String department) { this .firstName = firstName; this .lastName = lastName; this .age = age; Employee.department = department; validateAge(); } private void validateAge() { System.out.println( "Validating age." ); if (age < 18 || age > 70 ) { throw new IllegalArgumentException( "Not a valid age to create an employee" ); } } @Override // We need to tell what to serialize in writeExternal() method public void writeExternal(ObjectOutput out) throws IOException { System.out.println( "Custom externalizable serialization logic invoked." ); out.writeUTF(firstName); out.writeUTF(lastName); out.writeInt(age); out.writeUTF(department); } @Override // We need to tell what to deserialize in readExternal() method // The readExternal method must read the values in the same sequence and with the same types as were written by writeExternal public void readExternal(ObjectInput in) throws IOException { System.out.println( "Custom externalizable serialization logic invoked." ); firstName = in.readUTF(); lastName = in.readUTF(); age = in.readInt(); department = in.readUTF(); validateAge(); } @Override public String toString() { return String.format( "Employee {firstName='%s', lastName='%s', age='%s', department='%s'}" , firstName, lastName, age, department); } // Custom serialization logic, It will be called only if we have implemented Serializable instead of Externalizable. private void writeObject(ObjectOutputStream oos) throws IOException { System.out.println( "Custom serialization logic invoked." ); } // Custom deserialization logic, It will be called only if we have implemented Serializable instead of Externalizable. private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException { System.out.println( "Custom deserialization logic invoked." ); } }

序列化如何與可外部化接口一起使用

如上面在示例Employee類中所看到的，我們可以通過實現Externalizable接口并覆蓋其方法writeExternal()和readExternal()來編寫自己的序列化邏輯。

通過調用DataOutput的原始值對象或調用ObjectOutput的writeObject方法對象，字符串和數組，對象可以實現writeExternal方法來保存其內容。

該對象可以實現readExternal方法來恢復其內容，方法是為原始類型調用DataInput的方法，為對象，字符串和數組調用readObject的方法。 readExternal方法必須按與writeExternal相同的順序和相同的類型讀取值。

// We need to tell what fields to serialize in writeExternal() method public void writeExternal(ObjectOutput out) throws IOException { System.out.println( "Custom externalizable serialization logic invoked." ); out.writeUTF(firstName); out.writeUTF(lastName); out.writeInt(age); out.writeUTF(department); } // We need to tell what fields to deserialize in readExternal() method // The readExternal method must read the values in the same sequence and with the same types as were written by writeExternal public void readExternal(ObjectInput in) throws IOException { System.out.println( "Custom externalizable serialization logic invoked." ); firstName = in.readUTF(); lastName = in.readUTF(); age = in.readInt(); department = in.readUTF(); validateAge(); }

要將對象序列化和反序列化為文件，我們需要遵循與Serializable示例相同的過程，這意味著調用
如以下代碼所示，完成ObjectOutputStream.writeObject()和ObjectInputStream.readObject() ：

public class ExternalizableExample { public static void main(String[] args) throws IOException, ClassNotFoundException { Employee empObj = new Employee( "Shanti" , "Sharma" , 25 , "IT" ); System.out.println( "Object before serialization => " + empObj.toString()); // Serialization serialize(empObj); // Deserialization Employee deserializedEmpObj = deserialize(); System.out.println( "Object after deserialization => " + deserializedEmpObj.toString()); } // Serialization code static void serialize(Employee empObj) throws IOException { try (FileOutputStream fos = new FileOutputStream( "data.obj" ); ObjectOutputStream oos = new ObjectOutputStream(fos)) { oos.writeObject(empObj); } } // Deserialization code static Employee deserialize() throws IOException, ClassNotFoundException { try (FileInputStream fis = new FileInputStream( "data.obj" ); ObjectInputStream ois = new ObjectInputStream(fis)) { return (Employee) ois.readObject(); } } }

Externalizable接口是Serializable的子接口，即
Externalizable extends Serializable 。因此，如果我們實現Externalizable接口并覆蓋其writeExternal()和
然后，將使用readExternal()方法優先于這些方法，而不是由JVM提供的默認序列化機制。這些方法取代了writeObject和readObject方法的自定義實現，因此，如果我們還提供writeObject()和readObject() ，則將忽略它們。

在序列化過程中，將針對要序列化的每個對象的Externalizable接口進行測試。如果對象支持Externalizable，則調用writeExternal方法。如果對象不支持Externalizable并且實現了Serializable，則使用ObjectOutputStream保存該對象。

重建Externalizable對象時，將使用公共的無參數構造函數創建一個實例，然后調用readExternal方法。可序列化的對象通過從ObjectInputStream讀取來恢復。

重建Externizable對象時，在調用readExternal方法之前，使用公共的無參數構造函數創建對象。如果不存在公共的無參數構造函數，則在運行時引發InvalidClassException。

使用Externalizable，我們甚至可以序列化/反序列化瞬態變量，因此無需聲明瞬態字段。

使用Externalizable，我們甚至可以根據需要對靜態變量進行序列化/反序列化。

Externalizable實例可以通過Serializable接口中記錄的writeReplace和readResolve方法指定替換對象。

Java 序列化還可以用于深度克隆對象。 Java克隆是Java社區中最有爭議的話題，它的確有其缺點，但是在對象完全滿足Java克隆的強制條件之前，它仍然是創建對象副本的最流行和最簡單的方法。我在長達3篇文章的Java克隆系列中詳細介紹了克隆，其中包括Java克隆和克隆類型（淺和深）等文章，并帶有示例， Java克隆–復制構造器與克隆， Java克隆–甚至復制構造器都不一樣如果您想了解更多有關克隆的知識，請充分閱讀它們。

可外部化與可序列化之間的差異

讓我們列出Java中Externalizable接口和Serializable接口之間的主要區別。

您可以在此找到本文的完整源代碼。
Github存儲庫，請隨時提供寶貴的反饋。

翻譯自: https://www.javacodegeeks.com/2019/08/customize-serialization-java-using-externalizable-interface.html