序列化Externalizable 和Serializable 的理解

蔚落 2022-05-28 08:58 208阅读 0赞

1.  ***Serializable Interface基于递归算法，***即在序列化期间，除了字段之外，它将序列化通过其实例变量可以到达的**所有对象，即可以从该对象到达的**所有**对象**（假设所有类必须实现Serializable接口） ）。这包括对象的超类，直到它到达“Object”类，并且与实例变量的超类相同，直到它到达那些变量的“Object”类。基本上它可以读取的所有对象。当我们想要与类相比只保存少量变量或小数据时，这会导致很多开销
    
     *  **例如 -**如果您有一个名为Mercedes的类，并且您只想存储汽车系列及其汽车识别号，那么您不能仅仅停留在此并且必须存储该类及其超类的所有字段（如果存在并实现可序列化的接口）等等。
2.  **Serializable是一个标记接口**，因此无需覆盖任何方法，只要在实体或bean类中有任何更改，您只需要重新编译您的程序，无论是在**Externalizable**接口的情况下，您必须实现**`writeExternal()`和`readExternal()`**包含逻辑的方法存储和检索数据以及您可能需要在代码逻辑中进行更改的更改。
3.  Serializable为您提供了两个选项，即您可以自己处理该过程，也可以将其保留为以默认方式完成的过程，但在Externalizable中，您必须提供过程的逻辑并完全控制序列化和反序列化处理。
4.  **Serializable涉及用于恢复对象的反射机制**。这还添加了元数据，即进程中所有可序列化类的类描述，可变信息等，这会将大量数据和元数据添加到流中并**消耗带宽和性能问题**。
5.  **使用Externalizable**接口时**需要公共的无参数构造函数，**但在Serializable中它从中读取所需的信息[`ObjectInputStream` ][ObjectInputStream]，这就是它使用反射机制的原因。
6.  **在Serializable的情况下，**您需要**定义serialVersionUID，**如果没有明确定义，它将自动生成，它基于类的所有字段，方法等，并且每次在类中进行更改时它都会更改。如果当前ID与生成的ID不匹配，您将无法恢复以前存储的数据。由于每次生成ID都需要相当长的时间，而外部化界面并非如此。
7.  与其他**接口**相比，Externalizable **接口快速且消耗更少的内存**

1.  **readObject(ObjectInputStream ois)**：如果这个方法存在，ObjectInputStream readObject()方法**会调用该方法从流中读取对象**。
2.  **writeObject(ObjectOutputStream oos)**：如果这个方法存在，ObjectOutputStream writeObject()方法**会调用该方法从流中写入对象**。**一种普遍的用法是隐藏对象的值来保证完整性。**
3.  **Object writeReplace()**：如果这个方法存在，那么**在序列化处理之后**，该方法会被调用并**将返回的对象序列化到流中**。
4.  **Object readResolve()**：如果这个方法存在，那么**在序列化处理之后**，该方法会被调用并**返回一个最终的对象**给调用程序（keyijinxing）。一种使用方法是在序列化类中实现单例模式，你可以从[序列化和单例][Link 1]中读到更多知识。此方法返回的对象，会被作为readOjbect的返回值（即使readObject方法定义并没有返回任何对象）

import java.io.*;
    
    /**
     * Created by wanbf on 2018/4/2.
     */
    public class ExternalizableTest implements Externalizable {
    
        private transient String content = "是的，我将会被序列化，不管我是否被transient关键字修饰";
    
        @Override
        public void writeExternal(ObjectOutput out) throws IOException {
            System.out.println("writeExternal");
            out.writeObject(content);
        }
    
        @Override
        public void readExternal(ObjectInput in) throws IOException,
                ClassNotFoundException {
            System.out.println("readExternal");
            content = (String) in.readObject();
        }
    
        public static void main(String[] args) throws Exception {
    
    
    /*        ExternalizableTest et = new ExternalizableTest();
            ObjectOutput out = new ObjectOutputStream(new FileOutputStream(
                    new File("test")));
            out.writeObject(et);
    
            ObjectInput in = new ObjectInputStream(new FileInputStream(new File(
                    "test")));
            et = (ExternalizableTest) in.readObject();
            System.out.println(et.content);
    
            out.close();
            in.close();*/
    
    
    
    
    /*        SerializeTest et = SerializeTest.instance;
            ObjectOutput out = new ObjectOutputStream(new FileOutputStream(
                    new File("test")));
            System.out.println(et.toString());
            out.writeObject(et);
    
            ObjectInput in = new ObjectInputStream(new FileInputStream(new File(
                    "test")));
            SerializeTest et1 = (SerializeTest) in.readObject();
            System.out.println(et1.toString());
            System.out.println(et.equals(et1));
    
            out.close();
            in.close();*/
    
    
    
    
    /*        Person robin = new Person("robin", 29);
    
            String savePath = "D:\\object.txt";
    
            ExternalizableTest test = new ExternalizableTest();
    
            try {
                test.serialize(robin, savePath);
                Person person = (Person) test.deSerialize(savePath);
    
    
                System.out.println("Name:" + person.getName()
                        + " Age:" + person.getAge());
    
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }*/
        }
    
        public void serialize(Object obj, String path) throws IOException {
            ObjectOutputStream oos = null;
            try {
                oos = new ObjectOutputStream(new FileOutputStream(path));
                oos.writeObject(obj);
            } finally {
                if (null != oos)
                    oos.close();
            }
        }
    
        /**
         * 反序列化取出对象
         *
         * @param path 被序列化对象保存的位置
         * @return
         * @throws IOException
         * @throws ClassNotFoundException
         */
        public Object deSerialize(String path) throws IOException,
                ClassNotFoundException {
            ObjectInputStream ois = null;
            try {
                ois = new ObjectInputStream(new FileInputStream(path));
                return ois.readObject();
            } finally {
                if (null != ois)
                    ois.close();
            }
        }
    
    }
    
    class SerializeTest implements Serializable {
        private static final long serialVersionUID = 123456789L;
        public static SerializeTest instance = new SerializeTest();
    
        private SerializeTest() {
    
        }
    
        private Object readResolve() {
            System.out.println("read resolve");
            return instance;
        }
    
    }
    
    class Person implements Serializable {
    
        private static final long serialVersionUID = -6412852654889352693L;
    
        private String name;
    
        private int age;
    
        public String getName() {
            return name;
        }
    
        public int getAge() {
            return age;
        }
    
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
    
        private void writeObject(ObjectOutputStream out) throws IOException {
            out.writeObject(name);
            out.writeInt(age + 1);
    
            System.out.println("my write");
        }
    
        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            this.name = "zhangsan";
            this.age = 30;
            System.out.println("my read");
        }
    
        private Object readResolve() {
            System.out.println("read resolve");
            return this;
        }
    
    }

[ObjectInputStream]: https://www.codingeek.com/java/io/object-streams-serialization-deserialization-java-example-serializable-interface/
[Link 1]: http://www.journaldev.com/1377/java-singleton-design-pattern-best-practices-with-examples#serialization-and-singleton