Java中使用外部化接口的反序列化

我正在学习Serializable和Externalizable接口，我看到，当重构一个Externalizable对象时，首先使用public no arg构造函数创建一个实例，然后调用readExternal方法。如果对象不支持Externalizable，则通过从ObjectInputStream读取可序列化对象来恢复这些对象

我不明白如果对象不是从那里读取的，为什么我们使用ObjectInputStream进行外部化？从ObjectInputStream读取的确切内容是什么？我想如果我们使用它，我们会从那里读到一些东西

我还发现了这个关于反序列化外部化或序列化接口的图表

在反序列化过程中，可序列化和可外部化之间有什么区别

我不明白为什么外部化对象不能像可序列化对象一样从ObjectInputStream读取来恢复

ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("employee.ser"))

我知道FileInputStream打开一个文件，根据文件中的数据创建一个字节序列。ObjectInputStream获取字节序列，并根据字节序列重新创建对象

这是一个代码

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class Employee implements Externalizable {

    private int id;
    private String name;
    private int age;

    public void Employee() {


    } 

    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 int getAge() {

        return age;
    }

    public void setAge(int age) {

        this.age = age;
    }

    public String toString() {

        return "Employee [id=" + id + ", name=" + name + ", age=" + age + "]";
    }

    public void writeExternal(ObjectOutput oo) throws IOException {

        System.out.println("Inside writeExternal method");
        oo.writeInt(id); 
        oo.writeObject(name); 
    }

    public void readExternal(ObjectInput oi) throws IOException, ClassNotFoundException {

        System.out.println("Inside readExternal method");
        id = oi.readInt();
        name = (String) oi.readObject();
    }
}

外化硼镁石

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class ExternalizableWrite {

    public static void main(String args[]) {

        ExternalizableWrite ew = new ExternalizableWrite();
        ew.writeEmployeeObject();
    }

    private void writeEmployeeObject() {

        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("employee.ser"))) {

            Employee employee = new Employee();
            employee.setId(101);
            employee.setName("Peter"); 
            employee.setAge(25); 

            System.out.println(employee);

            oos.writeObject(employee);  // write the specified object to the ObjectOutputStream

            System.out.println("Successfully written employee object to the file.\n");

        } catch (FileNotFoundException ex) {

            System.out.printf("ERROR: %s", ex); 

        } catch (IOException ex) {

            System.out.printf("ERROR: %s", ex); 
        }
    }
}

外化器磁头

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ExternalizableRead {

    public static void main(String args[]) {

        ExternalizableRead er = new ExternalizableRead();
        er.readEmployeeObject();
    }

    private void readEmployeeObject() {

        try (ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("employee.ser"))) {

            Employee employee = (Employee) ois.readObject();

            System.out.println(employee);

            System.out.println("Successfully read employee objecct to the file.\n");

        } catch (FileNotFoundException ex) {

            System.out.printf("ERROR: %s", ex);

        } catch (IOException | ClassNotFoundException ex) {

            System.out.printf("ERROR: %s", ex);
        } 
    }
}

在反序列化过程中，可序列化和可外部化之间有什么区别

根据

ObjectInputStream

的实现，

Externalizable

对象的处理方式与

Serializable

对象的处理方式不同，正如预期的那样：

if (desc.isExternalizable()) {
    readExternalData((Externalizable) obj, desc);
} else {
    readSerialData(obj, desc);
}

正如您所料，

readExternalData

方法为正在反序列化的对象调用

Externalizable#readExternal

，而

readSerialData

方法只是对序列化字段进行反序列化

我不明白如果对象不是从那里读取的，为什么我们使用ObjectInputStream进行外部化

我不确定你在问什么，但是

ObjectInputStream

确实处理

可外部化的对象，如上所示

我不明白为什么外部化对象不能像可序列化对象一样从ObjectInputStream读取来恢复

ObjectInputStream ois = new ObjectInputStream(
                new FileInputStream("employee.ser"))

因为
Externalizable
对象强制您手动序列化和反序列化它们，而
Serializable
尝试序列化所有非静态和非瞬态字段

我不明白如果对象不是从那里读取的，为什么我们使用ObjectInputStream进行外部化

Externalizable还使用
ObjectInputStream
。

ObjectInputStream
是传递给
readExternal
方法的参数。可以使用ObjectInputStream的
readInt
、
readFloat
等方法从序列化对象读取值

在反序列化过程中，可序列化和可外部化之间有什么区别

类（实现
Serializable
接口）可以使用以下方法自定义序列化对象写入的数据：


private void writeObject（java.io.ObjectOutputStream out）抛出IOException


private void readObject（java.io.ObjectInputStream-in）抛出IOException、ClassNotFoundException

假设有这样的类A和类B

  class A implement Serializable {
     writeObject(...){....}
     readObject(...){....}
  } 

  class B extends A implements Serializable{
     writeObject(...){....}
     readObject(...){....}
  }

当B的一个对象被序列化/反序列化时，父类/超类A的
writeObject
/
readObject
方法在B的方法之前被调用，从而允许父类“决定要序列化/反序列化的字段”。



但是，当涉及到可外部化的
时，这种情况不会发生。只调用子类的
readExternal
和
writeExternal
方法，覆盖父类的序列化/反序列化行为