Jackson databind enum Groß-/Kleinschreibung nicht beachten

Wie kann ich eine JSON-Zeichenfolge deserialisieren, die Aufzählungswerte enthält, bei denen die Groß-/Kleinschreibung nicht beachtet wird? (mit Jackson Databind)

Der JSON-String:

[{"url": "foo", "type": "json"}]

und mein Java-POJO:

public static class Endpoint {

    public enum DataType {
        JSON, HTML
    }

    public String url;
    public DataType type;

    public Endpoint() {

    }

}

In diesem Fall Deserialisieren des JSON mit "type":"json" würde scheitern wo wie "type":"JSON" würde funktionieren. Aber ich möchte "json" aus Gründen der Namenskonvention auch zu funktionieren.

Das Serialisieren des POJO führt auch zu Großbuchstaben "type":"JSON"

Ich dachte an die Verwendung @JsonCreator und @JsonGetter:

    @JsonCreator
    private Endpoint(@JsonProperty("name") String url, @JsonProperty("type") String type) {
        this.url = url;
        this.type = DataType.valueOf(type.toUpperCase());
    }

    //....
    @JsonGetter
    private String getType() {
        return type.name().toLowerCase();
    }

Und es hat funktioniert. Aber ich habe mich gefragt, ob es eine bessere Lösung gibt, weil das für mich wie ein Hack aussieht.

Ich kann auch einen benutzerdefinierten Deserializer schreiben, aber ich habe viele verschiedene POJOs, die Aufzählungen verwenden, und es wäre schwer zu warten.

Kann jemand eine bessere Methode zum Serialisieren und Deserialisieren von Enumerationen mit der richtigen Namenskonvention vorschlagen?

Ich möchte nicht, dass meine Aufzählungen in Java Kleinbuchstaben sind!

Hier ist ein Testcode, den ich verwendet habe:

    String data = "[{"url":"foo", "type":"json"}]";
    Endpoint[] arr = new ObjectMapper().readValue(data, Endpoint[].class);
        System.out.println("POJO[]->" + Arrays.toString(arr));
        System.out.println("JSON ->" + new ObjectMapper().writeValueAsString(arr));

Jackson 2.9

Dies ist jetzt ganz einfach, mit jackson-databind 2.9.0 und höher

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.enable(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS);

// objectMapper now deserializes enums in a case-insensitive manner

Vollständiges Beispiel mit Tests

import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {

  private enum TestEnum { ONE }
  private static class TestObject { public TestEnum testEnum; }

  public static void main (String[] args) {
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.enable(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS);

    try {
      TestObject uppercase = 
        objectMapper.readValue("{ "testEnum": "ONE" }", TestObject.class);
      TestObject lowercase = 
        objectMapper.readValue("{ "testEnum": "one" }", TestObject.class);
      TestObject mixedcase = 
        objectMapper.readValue("{ "testEnum": "oNe" }", TestObject.class);

      if (uppercase.testEnum != TestEnum.ONE) throw new Exception("cannot deserialize uppercase value");
      if (lowercase.testEnum != TestEnum.ONE) throw new Exception("cannot deserialize lowercase value");
      if (mixedcase.testEnum != TestEnum.ONE) throw new Exception("cannot deserialize mixedcase value");

      System.out.println("Success: all deserializations worked");
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Ich bin in meinem Projekt auf dasselbe Problem gestoßen, wir haben uns entschieden, unsere Enumerationen mit einem String-Schlüssel zu erstellen und zu verwenden @JsonValue und einen statischen Konstruktor für die Serialisierung bzw. Deserialisierung.

public enum DataType {
    JSON("json"), 
    HTML("html");

    private String key;

    DataType(String key) {
        this.key = key;
    }

    @JsonCreator
    public static DataType fromString(String key) {
        return key == null
                ? null
                : DataType.valueOf(key.toUpperCase());
    }

    @JsonValue
    public String getKey() {
        return key;
    }
}

Seit Jackson 2.6 können Sie dies einfach tun:

    public enum DataType {
        @JsonProperty("json")
        JSON,
        @JsonProperty("html")
        HTML
    }

Ein vollständiges Beispiel finden Sie unter dieser Kern.

In Version 2.4.0 können Sie einen benutzerdefinierten Serializer für alle Enum-Typen registrieren (Verknüpfung zum Github-Problem). Sie können auch den standardmäßigen Enum-Deserializer selbst ersetzen, der den Enum-Typ erkennt. Hier ist ein Beispiel:

public class JacksonEnum {

    public static enum DataType {
        JSON, HTML
    }

    public static void main(String[] args) throws IOException {
        List<DataType> types = Arrays.asList(JSON, HTML);
        ObjectMapper mapper = new ObjectMapper();
        SimpleModule module = new SimpleModule();
        module.setDeserializerModifier(new BeanDeserializerModifier() {
            @Override
            public JsonDeserializer<Enum> modifyEnumDeserializer(DeserializationConfig config,
                                                              final JavaType type,
                                                              BeanDescription beanDesc,
                                                              final JsonDeserializer<?> deserializer) {
                return new JsonDeserializer<Enum>() {
                    @Override
                    public Enum deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
                        Class<? extends Enum> rawClass = (Class<Enum<?>>) type.getRawClass();
                        return Enum.valueOf(rawClass, jp.getValueAsString().toUpperCase());
                    }
                };
            }
        });
        module.addSerializer(Enum.class, new StdSerializer<Enum>(Enum.class) {
            @Override
            public void serialize(Enum value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
                jgen.writeString(value.name().toLowerCase());
            }
        });
        mapper.registerModule(module);
        String json = mapper.writeValueAsString(types);
        System.out.println(json);
        List<DataType> types2 = mapper.readValue(json, new TypeReference<List<DataType>>() {});
        System.out.println(types2);
    }
}

Ausgabe:

["json","html"]
[JSON, HTML]

Ich habe mich für die Lösung von . entschieden Sam B. aber eine einfachere Variante.

public enum Type {
    PIZZA, APPLE, PEAR, SOUP;

    @JsonCreator
    public static Type fromString(String key) {
        for(Type type : Type.values()) {
            if(type.name().equalsIgnoreCase(key)) {
                return type;
            }
        }
        return null;
    }
}

Wenn Sie Spring Boot verwenden 2.1.x mit Jackson 2.9 Sie können einfach diese Anwendungseigenschaft verwenden:

spring.jackson.mapper.accept-case-insensitive-enums=true

Für diejenigen, die versuchen, Enum zu deserialisieren und dabei die Groß-/Kleinschreibung ignorieren GET-Parameter, das Aktivieren von ACCEPT_CASE_INSENSITIVE_ENUMS bringt nichts. Es wird nicht helfen, da diese Option nur für funktioniert Körperdeserialisierung. Versuchen Sie stattdessen Folgendes:

public class StringToEnumConverter implements Converter<String, Modes> {
    @Override
    public Modes convert(String from) {
        return Modes.valueOf(from.toUpperCase());
    }
}

und dann

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addConverter(new StringToEnumConverter());
    }
}

Die Antwort- und Codebeispiele stammen von Hier