Gson 优雅实现多个枚举的自定义（反）序列化过程

来源：互联网发布：烟台华商网络怎么样编辑：程序博客网时间：2024/04/30 02:05

JDK版本

JDK版本.jpg

Gson版本

    <dependency>        <groupId>com.google.code.gson</groupId>        <artifactId>gson</artifactId>        <version>2.7</version>    </dependency>

　　Gson是实现对象序列化和反序列化的利器，但是Gson在（反）序列化枚举时默认是根据枚举值的名称来实现的，如果你想要在（反）序列化枚举时输出自己定义的枚举属性，那么此时至少有两种选择：

继承TypeAdapter抽象类并实现其中的抽象方法
实现JsonSerializer 和/或JsonDeserializer 接口

我通常是选择第二种方式，即实现接口的方式来自定义（反）序列化过程。比如下面这个实例：
针对JDK1.8新的时间API中的LocalDate进行自定义（反）序列化过程：

import com.google.gson.*;import java.lang.reflect.Type;import java.time.LocalDate;import java.time.format.DateTimeFormatter;public class LocalDateTypeAdapter implements JsonSerializer<LocalDate>, JsonDeserializer<LocalDate> {    private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");    @Override    public JsonElement serialize(LocalDate src, Type typeOfSrc, JsonSerializationContext context) {        return null == src ? null : new JsonPrimitive(formatter.format(src));    }    @Override    public LocalDate deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {        return null == json ? null : LocalDate.parse(json.getAsString(), formatter);    }}

　　当注册了该TypeAdapter的Gson在序列化LocalDate类型时，会调用其中的serialize方法，此时如果LocalDate实例非空的话，我们将调用formatter.format(src)方法将LocalDate实例格式化成指定形式的字符串，然后封装成JsonPrimitive实例并返回Gson，Gson再将返回的JsonPrimitive写入到 json 字符串中；
　　同理，当Gson反序列化时遇到LocalDate类型时，会调用其中的deserialize方法完成反序列化。

　　好了，扯完基本实现之后，现在有一个问题：那就是针对单个枚举使用这种方式那是无可厚非的。但是当你的项目中应用到的枚举数量比较多的时候，如果依然采用这种方式，那么随着而来的问题是类的增加以及出现一些小范围的重复代码。
　　要如何解决这个问题就是写作本文的意图了。
　　本文是基于JsonSerializer 和JsonDeserializer 接口来解决问题的，当然网上有针对TypeAdapter的工厂类TypeAdapterFactory来解决该问题，但是该解决方案有个不足之处，那就是需要修改Gson的源码，这里就不讲该方案了，有需要的同学自行搜索。
　　第一步：一个接口，该接口定义了Gson在（反）序列化枚举时将调用的方法：

public interface GsonEnum<E> {    String serialize();    E deserialize(String jsonEnum);}

　　接口中定义接收一个泛型E，该泛型用来表示枚举类型，里面有两个抽象方法，String serialize()方法表示将枚举序列化成字符串，E deserialize(String jsonEnum)表示将字符串反序列化成枚举并返回特定的枚举E。

　　第二步：定义枚举类并实现第一步中声明的接口，这里为了演示效果，定义了如下两个枚举：
　　派别枚举Faction：

public enum Faction implements GsonEnum<Faction> {    ABNEGATION("无私派"), AMITY("和平派"), DAUNTLESS("无畏派"), CANDOR("诚实派"), ERUDITE("博学派");    private final String name;    Faction(String name) {        this.name = name;    }    public String getName() {        return name;    }    public static Faction parse(String faction) {        switch (faction) {            case "无私派":                return Faction.ABNEGATION;            case "和平派":                return Faction.AMITY;            case "无畏派":                return Faction.DAUNTLESS;            case "诚实派":                return Faction.CANDOR;            case "博学派":                return Faction.ERUDITE;            default:                throw new IllegalArgumentException("There is not enum names with [" + faction + "] of type Faction exists! ");        }    }    @Override    public Faction deserialize(String jsonEnum) {        return Faction.parse(jsonEnum);    }    @Override    public String serialize() {        return this.getName();    }}

　　性别枚举Gender：

public enum Gender implements GsonEnum<Gender> {    MALE("男"), FEMALE("女");    private final String type;    Gender(String type) {        this.type = type;    }    public String getType() {        return type;    }    public static Gender parse(String type) {        switch (type) {            case "男":                return Gender.MALE;            case "女":                return Gender.FEMALE;            default:                throw new IllegalArgumentException("There is not enum names with [" + type + "] of type Gender exists! ");        }    }    @Override    public Gender deserialize(String jsonEnum) {        return Gender.parse(jsonEnum);    }    @Override    public String serialize() {        return this.getType();    }}

　　对于这两个枚举内部对GsonEnum接口的实现方法比较简单，所以这里就不解释了。

　　第三步：自定义Gson（反）序列化过程的GsonEnumTypeAdapter，先看具体代码实现：

public class GsonEnumTypeAdapter<E> implements JsonSerializer<E>, JsonDeserializer<E> {    private final GsonEnum<E> gsonEnum;    public GsonEnumTypeAdapter(GsonEnum<E> gsonEnum) {        this.gsonEnum = gsonEnum;    }    @Override    public JsonElement serialize(E src, Type typeOfSrc, JsonSerializationContext context) {        if (null != src && src instanceof GsonEnum) {            return new JsonPrimitive(((GsonEnum) src).serialize());        }        return null;    }    @Override    public E deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {        if (null != json) {            return gsonEnum.deserialize(json.getAsString());        }        return null;    }}

　　代码看起来很简单，唯一的构造器要求传入一个GsonEnum的实现类。
　　首先看一个测试用例：
　　（反）序列化测试时用到的类Person：

public class Person implements Serializable {    private String name;    private Gender gender;    private Faction faction;    private LocalDate birthday;    public Person() {    }    public Person(String name, Gender gender, Faction faction, LocalDate birthday) {        this.name = name;        this.gender = gender;        this.faction = faction;        this.birthday = birthday;    }    @Override    public String toString() {        return "Person{" +                "name='" + name + '\'' +                ", gender=" + gender +                ", faction=" + faction +                ", birthday=" + birthday +                '}';    }    // 省略 getter 和 setter}

　　JUnit测试实例

    @Test    public void testGson() throws Exception {        Gson gson = new GsonBuilder()                .serializeNulls()                .registerTypeAdapter(LocalDate.class, new LocalDateTypeAdapter())                .registerTypeAdapter(Gender.class, new GsonEnumTypeAdapter<>(Gender.FEMALE))                .registerTypeAdapter(Faction.class, new GsonEnumTypeAdapter<>(Faction.ABNEGATION))                .create();        Person p1 = new Person("雷卡", Gender.MALE, Faction.DAUNTLESS, LocalDate.of(1994, 10, 11));        System.out.println("调用 toString 方法：\n" + p1);        String jsonText = gson.toJson(p1);        System.out.println("将 person 转换成 json 字符串：\n" + jsonText);        System.out.println("-------------------");        Person p2 = gson.fromJson(jsonText, Person.class);        assert p2 != p1;        System.out.println("根据 json 字符串生成 person 实例：\n" + p2);    }

测试结果为：
Gson多枚举（反）序列化测试结果.jpg

　　测试结果表明我们想要的效果已经达到了，现在讲一下GsonEnumTypeAdapter的实现原理。
　　以Faction为例，首先它接收E时我们传递的是Faction枚举的一个枚举值Faction.ABNEGATION，这个枚举值没有任何限定，可以是该枚举类中的任意一个。
　　序列化Faction类型时，Gson调用其中的serialize方法，注意此时我们传入的Faction.ABNEGATION并不发挥作用，我们直接调用的是序列化时遇到的Faction实例（比如Faction.AMITY，Faction.CANDOR）的serialize实例方法，那么此时返回的必然是该枚举实例的name属性值；
　　反序列化遇到Faction类型时，Gson调用其中的deserialize方法，此时我们实际上操作的最开始传入的枚举类型Faction.ABNEGATION的deserialize方法，注意此时该方法需要传入一个字符串，刚好可以用到JsonElement自身提供的getAsString方法。再看Faction类中对deserialize方法的实现，实际上该方法并不关注调用者是谁，它真正关心的传入值是什么，根据传入的值，它可以很快获取得到对应的枚举或者抛出异常。

　　可能上面表述得不是很清楚，但实际上都是一些基础的知识，即泛型，接口，枚举的特殊性的综合应用，多看几遍应该就懂了，另外最好打上几个断点，然后debug一遍，看整个流程是怎么跑的，那样基本就清晰了。
　　另外，为确保GsonEnumTypeAdapter只接收枚举并且GsonEnum只被枚举类所实现，可以添加泛型参数的边界，如下：
　　GsonEnum的类声明

public interface GsonEnum<E extends Enum<E>>

　　GsonEnumTypeAdapter的类声明

public class GsonEnumTypeAdapter<E extends Enum<E>> implements JsonSerializer<E>, JsonDeserializer<E>

　　声明了泛型上限为Enum之后可以确保在使用该泛型时只有枚举类能够被处理。

原创声明：
本文为个人原创，如有错误与不妥，欢迎提出！
另外，未经许可，谢绝转载。

源码地址1：Git@OSC

源码地址2：GitHub

编写日期：2016-08-23 发布日期：2016-08-23

0 0