项目中前后端交互使用json，遇到复杂结构对象（比如：对象，多态，枚举等等）json串，进行反序列化时，可能无法得到我们想要的结果，此时就需要做一些处理了。下面直接上代码演示吧

枚举类：

自定义json串：

{"dataType":{"type":"int"}}

这里只取复杂对象中的某一个相关类，定义了一个TslDataTypeRR类，枚举类Type为内部类，此时是最开始对象，反序列化的时候，是无法拿到Type属性值的

public class TslDataTypeRR {
    private final Type type;
    public TslDataTypeRR(Type type) {
        this.type = type;
    }
    public Type getType() {
        return type;
    }
   
    public enum Type  {
        INT("int"),
        TEXT("text");

        private final String type;
        Type(String type) {
            this.type = type;
        }
        public static Type getItem(String type){
            for(Type item : values()){
                if(item.getType().equals(type)){
                    return item;
                }
            }
            return null;
        }

        public String getType() {
            return type;
        }
      
    }

通过Gson反序列化是无法拿到期望结果的

Gson gson = new GsonBuilder()
                .serializeNulls()
               .create();
TslDataTypeRR element2 = gson.fromJson(jsonData, TslDataTypeRR.class);

下面进行解决方案演示：

第一步，定义一个接口

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

第二步，构建一个Adapter: GsonEnumTypeAdapter,来根据GsonEnum来处理此类枚举接口，方便以后其他枚举类，直接套用此方法

import com.google.gson.*;

import java.lang.reflect.Type;

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接口并将枚举类型当泛型传进去，并重写序列化和反序列化方法，写parse方法来辅助

public class TslDataTypeRR {

    private final Type type;
    public TslDataTypeRR(Type type) {
        this.type = type;
    }

    public Type getType() {
        return type;
    }

    public static enum Type implements GsonEnum<TslDataTypeRR.Type> {
        INT("int"),
        TEXT("text"),
        DOUBLE("double");

        private final String type;

        Type(String type) {
            this.type = type;
        }

        public static Type getItem(String type){
            for(Type item : values()){
                if(item.getType().equals(type)){
                    return item;
                }
            }
            return null;
        }


        public String getType() {
            return type;
        }

        //此方法里面，有几个枚举值，就写几个case
        public static Type parse(String faction) {
            switch (faction) {
                case "int":
                    return Type.INT;
                case "text":
                    return Type.TEXT;
                case "double":
                    return Type.DOUBLE;
                default:
                    throw new IllegalArgumentException("There is not enum names with [" + faction + "] of type Faction exists! ");
            }
        }


        @Override
        public String serialize() {
            return this.getType();
        }

        @Override
        public Type deserialize(String jsonEnum) {
            return Type.parse(jsonEnum);
        }
    }

第四步，构建Gson对象，将自定义序列化adapter加入初始化中，并

Gson gson = new GsonBuilder()
                .serializeNulls()
//此处只是传了一个TslDataType.Type.TEXT，只是为了获取此枚举类，写任意一个枚举类值都可以
//如果还有其他的枚举类需要反序列化，只需让枚举类重复第三步，并在此多加一条registerTypeAdapter即可
                .registerTypeAdapter(TslDataTypeRR.Type.class, new GsonEnumTypeAdapter<>(TslDataType.Type.TEXT)) 
                .create();

TslDataTypeRR element2 = gson.fromJson(jsonData, TslDataTypeRR.class);
//fixme 此时，这element2中的type就通过 int值反序列化成 INT枚举类型了

注：

  • 此处只是传了一个TslDataType.Type.TEXT，只是为了获取此枚举类，写任意一个枚举类值都可以
  • 如果还有其他的枚举类需要反序列化，只需让枚举类重复第三步，并在此多加一条registerTypeAdapter即可

至此，就完成了基于Gson的枚举自定义反序列化

 

第二种方法，直接lmd实现Gson的自定义序列化和反序列化，直接附上工具代码吧，看一眼应该就能明白

TslDeserializer tslDeserializer = new TslDeserializer("type");
        tslDeserializer.registerSpecsType("int", IntSpecs.class);
        tslDeserializer.registerSpecsType("text", TextSpecs.class);
        tslDeserializer.registerSpecsType("date", DateSpecs.class);
        tslDeserializer.registerSpecsType("bool", BoolSpecs.class);
        tslDeserializer.registerSpecsType("enum", EnumSpecs.class);
        tslDeserializer.registerSpecsType("array", ArraySpecs.class);
        tslDeserializer.registerSpecsType("float", FloatSpecs.class);
        tslDeserializer.registerSpecsType("struct", StructSpecs.class);
        tslDeserializer.registerSpecsType("double", DoubleSpecs.class);
        Gson gson = new GsonBuilder()
                .serializeNulls()
                .registerTypeAdapter(TslDataType.class, tslDeserializer)
                .registerTypeAdapter(TslDataType.Type.class, (JsonSerializer<TslDataType.Type>) (src, typeOfSrc, context) -> context.serialize(src.getType()))
                .registerTypeAdapter(TslServiceElement.CallType.class, (JsonSerializer<TslServiceElement.CallType>) (src, typeOfSrc, context) -> context.serialize(src.getType()))
                .registerTypeAdapter(TslEventElement.EventType.class, (JsonSerializer<TslEventElement.EventType>) (src, typeOfSrc, context) -> context.serialize(src.getValue()))
                .registerTypeAdapter(TslServiceElement.CallType.class,(JsonDeserializer<TslServiceElement.CallType>)(json,typeOf,context) -> TslServiceElement.CallType.getItem(json.getAsString()))
                .registerTypeAdapter(TslEventElement.EventType.class,(JsonDeserializer<TslEventElement.EventType>)(json,typeOf,context) -> TslEventElement.EventType.getItem(json.getAsString()))
                .setPrettyPrinting()
                .create();