Question

假设Java类中有以下枚举：

enum AccessMode {
    READ_WRITE,
    READ_ONLY,
    WRITE_ONLY
};

只要JSON包含枚举字段的有效值，JSON反序列化就可以正常使用Gson，例如：

"access": "READ_WRITE"

不幸的是，fromJson（）确实在JSON中检测到无效的枚举值，例如：

"access": "READ_XXX"

如何在使用Gson反序列化JSON文件时添加枚举值检查？

Answer 1

从版本2.8.2开始，Gson不支持这样的用例。我相信作为一种特殊的GsonBuilder配置方法，作为Gson开发团队的建议提交是值得的。您现在可以做的最多的事情是编写一个自定义的枚举类型适配器，它几乎复制了com.google.gson.internal.bind.EnumTypeAdapter功能，但添加了名称检查。

final class StrictEnumTypeAdapterFactory
        implements TypeAdapterFactory {

    private static final TypeAdapterFactory allStrictEnumTypeAdapterFactory = new StrictEnumTypeAdapterFactory(enumClass -> true);

    private final Predicate<? super Class<? extends Enum<?>>> isStrictEnumClass;

    private StrictEnumTypeAdapterFactory(final Predicate<? super Class<? extends Enum<?>>> isStrictEnumClass) {
        this.isStrictEnumClass = isStrictEnumClass;
    }

    static TypeAdapterFactory get(final Predicate<? super Class<? extends Enum<?>>> isStrictEnumClass) {
        return new StrictEnumTypeAdapterFactory(isStrictEnumClass);
    }

    static TypeAdapterFactory get() {
        return allStrictEnumTypeAdapterFactory;
    }

    @Override
    public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> typeToken) {
        final Class<? super T> rawType = typeToken.getRawType();
        // Skip non-enums
        if ( !Enum.class.isAssignableFrom(rawType) ) {
            return null;
        }
        // Check if the enum is supported by the "strict" policy
        @SuppressWarnings("unchecked")
        final Class<? extends Enum<?>> enumRawType = (Class<? extends Enum<?>>) rawType;
        if ( !isStrictEnumClass.test(enumRawType) ) {
            return null;
        }
        // Trivial rawtypes/unchecked casts
        @SuppressWarnings({ "rawtypes", "unchecked" })
        final TypeAdapter<? extends Enum<?>> strictEnumTypeAdapter = StrictEnumTypeAdapter.get((Class) enumRawType);
        @SuppressWarnings("unchecked")
        final TypeAdapter<T> castTypeAdapter = (TypeAdapter<T>) strictEnumTypeAdapter;
        return castTypeAdapter;
    }

    private static final class StrictEnumTypeAdapter<E extends Enum<E>>
            extends TypeAdapter<E> {

        private final Class<E> enumClass;
        private final Map<String, E> nameToEnumConstant;
        private final Map<E, String> enumConstantToName;

        private StrictEnumTypeAdapter(final Class<E> enumClass, final Map<String, E> nameToEnumConstant, final Map<E, String> enumConstantToName) {
            this.enumClass = enumClass;
            this.nameToEnumConstant = nameToEnumConstant;
            this.enumConstantToName = enumConstantToName;
        }

        private static <E extends Enum<E>> TypeAdapter<E> get(final Class<E> enumClass) {
            final Map<String, E> nameToEnumConstant = new HashMap<>();
            final Map<E, String> enumConstantToName = new HashMap<>();
            final Map<String, E> enumNameToEnumConstant = Stream.of(enumClass.getEnumConstants())
                    .collect(Collectors.toMap(Enum::name, Function.identity()));
            Stream.of(enumClass.getFields())
                    // It can be either a simple enum constant, or an enum constant that overrides
                    .filter(field -> enumClass.isAssignableFrom(field.getType()))
                    .forEach(field -> {
                        final E enumConstant = enumNameToEnumConstant.get(field.getName());
                        // For compatibility with the original type adapter, we have to respect the @SeriaizedName annotation
                        final SerializedName serializedName = field.getAnnotation(SerializedName.class);
                        if ( serializedName == null ) {
                            nameToEnumConstant.put(field.getName(), enumConstant);
                            enumConstantToName.put(enumConstant, field.getName());
                        } else {
                            nameToEnumConstant.put(serializedName.value(), enumConstant);
                            enumConstantToName.put(enumConstant, serializedName.value());
                            for ( final String alternate : serializedName.alternate() ) {
                                nameToEnumConstant.put(alternate, enumConstant);
                            }
                        }
                    });
            return new StrictEnumTypeAdapter<>(enumClass, nameToEnumConstant, enumConstantToName)
                    .nullSafe(); // A convenient method to handle nulls
        }

        @Override
        public void write(final JsonWriter out, final E value)
                throws IOException {
            out.value(enumConstantToName.get(value));
        }

        @Override
        public E read(final JsonReader in)
                throws IOException {
            final String key = in.nextString();
            // This is what the original type adapter probably misses
            if ( !nameToEnumConstant.containsKey(key) ) {
                throw new JsonParseException(enumClass + " does not have an enum named " + key + " at " + in);
            }
            return nameToEnumConstant.get(key);
        }

    }

}

简单测试：

private static final Gson gson = new GsonBuilder()
        .registerTypeAdapterFactory(StrictEnumTypeAdapterFactory.get())
        .create();

public static void main(final String... args)
        throws IOException {
    try ( final JsonReader jsonReader = Resources.getPackageResourceJsonReader(Q49572505.class, "good.json") ) {
        System.out.println(gson.<Status>fromJson(jsonReader, Status.class).access);
    }
    try ( final JsonReader jsonReader = Resources.getPackageResourceJsonReader(Q49572505.class, "bad.json") ) {
        try {
            gson.<Status>fromJson(jsonReader, Status.class);
            throw new AssertionError();
        } catch ( final JsonParseException ex ) {
            System.out.println(ex.getMessage());
        }
    }
}

输出：

READ_WRITE
class q49572505.AccessMode在JsonReader第2行第22列路径$ .access
没有名为READ_XXX的枚举

Answer 2

你可以看看@ Moshi。我发现它是GSON的合适且直接的替代品，它已经支持这种行为。

@ Lyubomyr_Shaydarlv的解决方案可行，但如果您不想复制GSON的内部代码，可以将其用作自定义TypeAdapterFactory中的委托。运行适配器，如果它返回null，则表示该值无效。这样做的好处是它继承并更改了默认的enum转换器。

class StrictEnumTypeAdapterFactory implements TypeAdapterFactory {
    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
        Class<T> rawType = (Class<T>) type.getRawType();
        if (!rawType.isEnum()) {
            return null;
        }
        return newStrictEnumAdapter(gson.getDelegateAdapter(this, type));
    }

    private <T> TypeAdapter<T> newStrictEnumAdapter(
            final TypeAdapter<T> delegateAdapter) {
        return new TypeAdapter<T>() {

            @Override
            public void write(JsonWriter out, T value) throws IOException {
                delegateAdapter.write(out, value);
            }

            @Override
            public T read(JsonReader in) throws IOException {
                // Peek at the next value and save it for the error message
                // if you don't need the offending value's actual name
                String enumValue = in.nextString();
                JsonReader delegateReader = new JsonReader(new StringReader('"' + enumValue + '"'));
                T value = delegateAdapter.read(delegateReader);
                delegateReader.close();
                if (value == null) throw new IllegalStateException("Invalid enum value - " + enumValue);
                return value;
            }
        };
    }
}

在反序列化期间，Gson检查枚举值

2 个答案: