发布于 由admin

Java 16 Records序列化Gson兼容性问题？TypeAdapter自定义与Jackson模块化配置

Java 16 Records 序列化：Gson 兼容性、TypeAdapter 自定义与 Jackson 模块化配置

大家好，今天我们来深入探讨 Java 16 Records 在序列化场景下的应用，重点解决与 Gson 的兼容性问题，以及如何通过 TypeAdapter 自定义序列化行为，并对比 Jackson 的模块化配置方法。Record 作为 Java 14 开始引入的一个重要特性，极大地简化了数据类的定义，但同时也带来了一些序列化方面的挑战，尤其是在与一些较老的序列化库配合使用时。

Record 简介与序列化需求

Record 是一个不可变的、数据载体类，它自动生成了构造函数、equals()、hashCode() 和 toString() 方法，极大地减少了样板代码。例如：

record Point(int x, int y) {}

这个 Point record 自动拥有了 x 和 y 两个字段，以及相应的构造函数、equals()、hashCode() 和 toString() 方法。

然而，默认情况下，像 Gson 这样的序列化库可能无法直接处理 Record，因为它们依赖于 JavaBean 规范，而 Record 并没有标准的 setter 方法。我们需要针对 Record 进行特殊的序列化处理。

Gson 与 Record 的默认兼容性问题

Gson 默认使用反射机制来访问类的字段，并将它们序列化为 JSON。对于 JavaBean，Gson 会查找 getter 方法（getX()、getY()）来获取字段值。但是 Record 并没有 getter 方法，而是使用组件访问器（x()、y()）。这导致 Gson 默认情况下无法正确序列化 Record。

例如，如果我们尝试直接使用 Gson 序列化一个 Point record：

import com.google.gson.Gson;

record Point(int x, int y) {}

public class GsonRecordExample {
    public static void main(String[] args) {
        Point point = new Point(10, 20);
        Gson gson = new Gson();
        String json = gson.toJson(point);
        System.out.println(json);
    }
}

运行这段代码，你可能会得到类似于 {"x":10,"y":20} 的结果，这取决于 Gson 的版本和配置。如果 Gson 版本较旧或者配置不当，可能会抛出异常或得到不正确的结果。较新版本的Gson可能已经支持record，但仍建议使用TypeAdapter来确保行为一致且可控。

使用 Gson TypeAdapter 自定义序列化

解决 Gson 与 Record 兼容性问题的最佳方法是使用 TypeAdapter。TypeAdapter 允许你完全控制特定类型的序列化和反序列化过程。

1. 创建自定义 TypeAdapter：

首先，我们需要创建一个 TypeAdapter 来处理 Point record 的序列化和反序列化。

import com.google.gson.TypeAdapter;
import com.google.google.gson.stream.JsonReader;
import com.google.google.gson.stream.JsonWriter;
import java.io.IOException;

record Point(int x, int y) {}

public class PointTypeAdapter extends TypeAdapter<Point> {

    @Override
    public void write(JsonWriter out, Point point) throws IOException {
        if (point == null) {
            out.nullValue();
            return;
        }

        out.beginObject();
        out.name("x").value(point.x());
        out.name("y").value(point.y());
        out.endObject();
    }

    @Override
    public Point read(JsonReader in) throws IOException {
        in.beginObject();
        int x = 0;
        int y = 0;

        while (in.hasNext()) {
            String name = in.nextName();
            switch (name) {
                case "x":
                    x = in.nextInt();
                    break;
                case "y":
                    y = in.nextInt();
                    break;
                default:
                    in.skipValue(); // 忽略未知字段
            }
        }

        in.endObject();
        return new Point(x, y);
    }
}

在这个 PointTypeAdapter 中，write() 方法负责将 Point 对象序列化为 JSON，read() 方法负责从 JSON 反序列化为 Point 对象。我们使用 point.x() 和 point.y() 来访问 Record 的组件，并将其写入 JSON。

2. 注册 TypeAdapter：

接下来，我们需要将 PointTypeAdapter 注册到 Gson 实例中。

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

record Point(int x, int y) {}

public class GsonRecordExample {
    public static void main(String[] args) {
        Point point = new Point(10, 20);

        Gson gson = new GsonBuilder()
                .registerTypeAdapter(Point.class, new PointTypeAdapter())
                .create();

        String json = gson.toJson(point);
        System.out.println(json);

        Point deserializedPoint = gson.fromJson(json, Point.class);
        System.out.println(deserializedPoint);
    }
}

我们使用 GsonBuilder 来创建一个 Gson 实例，并使用 registerTypeAdapter() 方法注册 PointTypeAdapter。这样，当 Gson 遇到 Point 类型时，就会使用我们自定义的 TypeAdapter 进行序列化和反序列化。

3. 泛型 Record 的 TypeAdapter：

如果你的 Record 是泛型的，那么你需要创建一个泛型 TypeAdapter。例如：

import com.google.gson.TypeAdapter;
import com.google.google.gson.stream.JsonReader;
import com.google.google.gson.stream.JsonWriter;
import java.io.IOException;

record Pair<K, V>(K key, V value) {}

public class PairTypeAdapter<K, V> extends TypeAdapter<Pair<K, V>> {

    private final TypeAdapter<K> keyAdapter;
    private final TypeAdapter<V> valueAdapter;

    public PairTypeAdapter(TypeAdapter<K> keyAdapter, TypeAdapter<V> valueAdapter) {
        this.keyAdapter = keyAdapter;
        this.valueAdapter = valueAdapter;
    }

    @Override
    public void write(JsonWriter out, Pair<K, V> pair) throws IOException {
        if (pair == null) {
            out.nullValue();
            return;
        }

        out.beginObject();
        out.name("key");
        keyAdapter.write(out, pair.key());
        out.name("value");
        valueAdapter.write(out, pair.value());
        out.endObject();
    }

    @Override
    public Pair<K, V> read(JsonReader in) throws IOException {
        in.beginObject();
        K key = null;
        V value = null;

        while (in.hasNext()) {
            String name = in.nextName();
            switch (name) {
                case "key":
                    key = keyAdapter.read(in);
                    break;
                case "value":
                    value = valueAdapter.read(in);
                    break;
                default:
                    in.skipValue();
            }
        }

        in.endObject();
        return new Pair<>(key, value);
    }
}

这个 PairTypeAdapter 接受两个 TypeAdapter 作为参数，分别用于处理 key 和 value 的序列化和反序列化。注册 TypeAdapter 时，你需要提供 key 和 value 的类型信息：

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;

record Pair<K, V>(K key, V value) {}

public class GsonRecordExample {
    public static void main(String[] args) {
        Pair<String, Integer> pair = new Pair<>("abc", 123);

        Gson gson = new GsonBuilder()
                .registerTypeAdapter(new TypeToken<Pair<String, Integer>>() {}.getType(),
                        new PairTypeAdapter<>(new Gson().getAdapter(String.class), new Gson().getAdapter(Integer.class)))
                .create();

        String json = gson.toJson(pair);
        System.out.println(json);

        Pair<String, Integer> deserializedPair = gson.fromJson(json, new TypeToken<Pair<String, Integer>>() {}.getType());
        System.out.println(deserializedPair);
    }
}

Jackson 的模块化配置

与 Gson 不同，Jackson 提供了更模块化的配置方式，允许你通过注册模块来扩展其功能。

1. 添加 Jackson 依赖：

首先，你需要添加 Jackson 的依赖到你的项目中。这里我们使用 Maven 作为例子：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.0</version>
</dependency>

2. 创建自定义模块：

接下来，你需要创建一个自定义模块来处理 Record 的序列化和反序列化。

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.Module;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;
import java.io.IOException;

record Point(int x, int y) {}

public class RecordModule extends Module {

    @Override
    public String getModuleName() {
        return "RecordModule";
    }

    @Override
    public Version version() {
        return Version.unknownVersion();
    }

    @Override
    public void setupModule(SetupContext context) {
        context.addSerializer(Point.class, new PointSerializer());
        context.addDeserializer(Point.class, new PointDeserializer());
    }

    static class PointSerializer extends StdSerializer<Point> {
        PointSerializer() {
            this(null);
        }

        PointSerializer(Class<Point> t) {
            super(t);
        }

        @Override
        public void serialize(Point value, JsonGenerator gen, SerializerProvider provider) throws IOException {
            gen.writeStartObject();
            gen.writeNumberField("x", value.x());
            gen.writeNumberField("y", value.y());
            gen.writeEndObject();
        }
    }

    static class PointDeserializer extends StdDeserializer<Point> {
        PointDeserializer() {
            this(null);
        }

        PointDeserializer(Class<?> vc) {
            super(vc);
        }

        @Override
        public Point deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
            JsonNode node = p.getCodec().readTree(p);
            int x = node.get("x").asInt();
            int y = node.get("y").asInt();
            return new Point(x, y);
        }
    }
}

在这个 RecordModule 中，我们定义了 PointSerializer 和 PointDeserializer 来处理 Point record 的序列化和反序列化。setupModule() 方法将 serializer 和 deserializer 注册到 Jackson 上下文中。

3. 注册模块：

最后，我们需要将 RecordModule 注册到 ObjectMapper 实例中。

import com.fasterxml.jackson.databind.ObjectMapper;

record Point(int x, int y) {}

public class JacksonRecordExample {
    public static void main(String[] args) throws Exception {
        Point point = new Point(10, 20);

        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new RecordModule());

        String json = mapper.writeValueAsString(point);
        System.out.println(json);

        Point deserializedPoint = mapper.readValue(json, Point.class);
        System.out.println(deserializedPoint);
    }
}

我们使用 ObjectMapper 创建一个 Jackson 实例，并使用 registerModule() 方法注册 RecordModule。

4. Jackson 的 Record Module (可选):

Jackson 官方提供了一个用于支持 Record 的模块，可以简化上述过程。你需要添加以下依赖：

<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jdk8</artifactId>
    <version>2.13.0</version>
</dependency>

<dependency>
    <groupId>com.fasterxml.jackson.module</groupId>
    <artifactId>jackson-module-parameter-names</artifactId>
    <version>2.13.0</version>
</dependency>

在添加完上述依赖后，你可以直接注册 ParameterNamesModule 和 Jdk8Module:

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;
import com.fasterxml.jackson.datatype.jdk8.Jdk8Module;

record Point(int x, int y) {}

public class JacksonRecordExample {
    public static void main(String[] args) throws Exception {
        Point point = new Point(10, 20);

        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new ParameterNamesModule());
        mapper.registerModule(new Jdk8Module());

        String json = mapper.writeValueAsString(point);
        System.out.println(json);

        Point deserializedPoint = mapper.readValue(json, Point.class);
        System.out.println(deserializedPoint);
    }
}

总结：Gson 与 Jackson 的对比

特性 Gson Jackson
序列化方式 反射 反射、模块化
Record 支持 需要自定义 TypeAdapter 通过自定义模块或官方模块支持
配置方式 GsonBuilder，注册 TypeAdapter ObjectMapper，注册模块
灵活性 较高，可以完全控制序列化过程 更模块化，易于扩展和维护
性能 取决于 TypeAdapter 的实现 通常比 Gson 更快，尤其是在处理复杂对象时

最佳实践与注意事项

  • 选择合适的序列化库： 根据你的项目需求和性能要求选择合适的序列化库。Jackson 通常比 Gson 更快，但 Gson 更易于使用。
  • 自定义序列化策略： 尽可能使用自定义的序列化策略（如 TypeAdapter 或 Jackson 模块）来处理 Record，以确保序列化行为的一致性和可控性。
  • 处理 null 值： 在 TypeAdapter 或 Jackson 模块中，务必处理 null 值，避免出现空指针异常。
  • 版本兼容性： 注意 Gson 和 Jackson 的版本兼容性，确保你的代码在不同的版本下都能正常工作。
  • 测试： 编写单元测试来验证你的序列化和反序列化代码，确保其正确性。

最后的话：掌握序列化，拥抱 Records

Java 16 Records 的引入极大地简化了数据类的定义，但同时也带来了一些序列化方面的挑战。通过掌握 Gson 的 TypeAdapter 和 Jackson 的模块化配置，我们可以轻松地解决这些挑战，并充分利用 Records 的优势。希望今天的讲解对你有所帮助。序列化是一个重要的课题，需要不断学习和实践，才能掌握其精髓。正确地使用序列化技术，可以使我们的程序更加健壮、高效。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注