Question

我不理解在序列化类时如何处理依赖字段的一般原则。

有许多模式，其中字段显示相互依赖。例如，下面我在构造函数中为列表创建一个可观察的包装器。在创建时，包装器会获取依赖项字段并将其包装起来。

此类未在Gson和默认Java反序列化器中反序列化。

在Gson中，它调用默认构造函数，它首先建立链接。但是后来Gson为delegate成员创建了新实例，这打破了链接，因为observable现在引用了过时的对象。

我不明白，Gson创建者如果调用默认构造函数，如果他们后来放弃它的功能，该怎么办？他们是否认为每个班级都可以直接进行现场分配？

Java默认序列化也不起作用。他们只是忽略了瞬态场，它仍然是空的。不调用构造函数。

我也不明白：如果他们没有调用构造函数，那么他们为什么不假设Serializable接口有一些构造函数等效的方法，应该在deserializtion之后调用？

package tests;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;

import javafx.collections.FXCollections;
import javafx.collections.ObservableList;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonIOException;

public class Try05 {

    public static class MyList implements Serializable {

        private static final long serialVersionUID = 7048098048856503023L;

        ArrayList<Integer> delegate = new ArrayList<Integer>();
        transient ObservableList<Integer> observable = FXCollections.observableList(delegate);

        public void add(int value) {
            observable.add(value);
        }

        public int sum() {
            int ans = 0;
            for (Integer i : observable) {
                ans += i.intValue();
            }
            return ans;
        }

        @Override
        public String toString() {
            return delegate.toString();
        }

    }

    public static void tryGson() throws JsonIOException, IOException {

        Gson gson = new GsonBuilder().enableComplexMapKeySerialization().serializeNulls().setPrettyPrinting().setVersion(1.0)
                .create();

        MyList list = new MyList();

        list.add(12);
        list.add(13);

        System.out.println(String.format("list = %s, sum = %d", list.toString(), list.sum()));
        System.out.println(String.format("hash = %d", System.identityHashCode(list.delegate)));

        File file = File.createTempFile("list", ".json");

        FileWriter writer = new FileWriter(file);
        gson.toJson(list, writer);
        writer.flush();
        writer.close();

        list = gson.fromJson(new FileReader(file), MyList.class);

        list.add(14);

        System.out.println(String.format("list = %s, sum = %d", list.toString(), list.sum()));
        System.out.println(String.format("hash = %d", System.identityHashCode(list.delegate)));

    }

    public static void tryBuiltin() throws IOException, ClassNotFoundException {

        MyList list = new MyList();

        list.add(12);
        list.add(13);

        System.out.println(String.format("list = %s, sum = %d", list.toString(), list.sum()));
        System.out.println(String.format("hash = %d", System.identityHashCode(list.delegate)));

        File file = File.createTempFile("list", ".json");

        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
        out.writeObject(list);
        out.flush();
        out.close();

        ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
        list = (MyList) in.readObject();

        list.add(14);

        System.out.println(String.format("list = %s, sum = %d", list.toString(), list.sum()));
        System.out.println(String.format("hash = %d", System.identityHashCode(list.delegate)));

    }


    public static void main(String[] args) {

        try {

            tryGson();

            tryBuiltin();

        } catch (JsonIOException | IOException | ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }



    }


}

Answer 1

关于Serializable接口不包含反序列化方法的说法不正确 - 有;使用默认的java序列化，您可以声明一个在读取对象时将调用的特殊方法。它看起来像这样：

private /* or any other access modifier */ void readObject(ObjectInputStream in) throws IOException {
    // your code here
}

在这种情况下，此方法的内容如下所示：

in.defaultReadObject(); // invoke default read
observable = FXCollections.observableList(delegate); // initialise observable

有关此方法及其他方法的更多信息，请查看Serializable类的规范： http://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html

序列化时如何处理依赖字段？

1 个答案: