Jackson enum Serializing y DeSerializer

Estoy usando JAVA 1.6 y Jackson 1.9.9 Tengo una enumeración

public enum Event {
    FORGOT_PASSWORD("forgot password");

    private final String value;

    private Event(final String description) {
        this.value = description;
    }

    @JsonValue
    final String value() {
        return this.value;
    }
}

He agregado un @JsonValue, esto parece hacer el trabajo en el que serializa el objeto:

{"event":"forgot password"}

pero cuando trato de deserializar me sale un

Caused by: org.codehaus.jackson.map.JsonMappingException: Can not construct instance of com.globalrelay.gas.appsjson.authportal.Event from String value 'forgot password': value not one of declared Enum instance names

¿Que me estoy perdiendo aqui?

La solución de serializador / deserializador señalada por @xbakesx es excelente si desea desacoplar completamente su clase enum de su representación JSON.

Alternativamente, si se prefiere una solución en sí misma, una implementación basada en @JsonCreatory @JsonValueanotaciones serían más conveniente.

Aprovechando el ejemplo de @Stanley, la siguiente es una solución completa e independiente (Java 6, Jackson 1.9):

public enum DeviceScheduleFormat {

    Weekday,
    EvenOdd,
    Interval;

    private static Map<String, DeviceScheduleFormat> namesMap = new HashMap<String, DeviceScheduleFormat>(3);

    static {
        namesMap.put("weekday", Weekday);
        namesMap.put("even-odd", EvenOdd);
        namesMap.put("interval", Interval);
    }

    @JsonCreator
    public static DeviceScheduleFormat forValue(String value) {
        return namesMap.get(StringUtils.lowerCase(value));
    }

    @JsonValue
    public String toValue() {
        for (Entry<String, DeviceScheduleFormat> entry : namesMap.entrySet()) {
            if (entry.getValue() == this)
                return entry.getKey();
        }

        return null; // or fail
    }
}

Tenga en cuenta que a partir de este compromiso en junio de 2015 (Jackson 2.6.2 y superior) ahora puede simplemente escribir:

public enum Event {
    @JsonProperty("forgot password")
    FORGOT_PASSWORD;
}

Debe crear un método de fábrica estático que tome un solo argumento y lo anote con @JsonCreator(disponible desde Jackson 1.2)

@JsonCreator
public static Event forValue(String value) { ... }

Lea más sobre la anotación JsonCreator aquí .

Respuesta real:

El deserializador predeterminado para enums usa .name()para deserializar, por lo que no está usando el @JsonValue. Entonces, como señaló @OldCurmudgeon, tendrías que pasar {"event": "FORGOT_PASSWORD"}para que coincida con el .name()valor.

Otra opción (suponiendo que desea que los valores json de escritura y lectura sean los mismos) ...

Más información:

Hay (aún) otra forma de gestionar el proceso de serialización y deserialización con Jackson. Puede especificar estas anotaciones para usar su propio serializador y deserializador personalizados:

@JsonSerialize(using = MySerializer.class)
@JsonDeserialize(using = MyDeserializer.class)
public final class MyClass {
    ...
}

Luego tienes que escribir MySerializery MyDeserializerque se ve así:

MySerializer

public final class MySerializer extends JsonSerializer<MyClass>
{
    @Override
    public void serialize(final MyClass yourClassHere, final JsonGenerator gen, final SerializerProvider serializer) throws IOException, JsonProcessingException
    {
        // here you'd write data to the stream with gen.write...() methods
    }

}

MyDeserializer

public final class MyDeserializer extends org.codehaus.jackson.map.JsonDeserializer<MyClass>
{
    @Override
    public MyClass deserialize(final JsonParser parser, final DeserializationContext context) throws IOException, JsonProcessingException
    {
        // then you'd do something like parser.getInt() or whatever to pull data off the parser
        return null;
    }

}

Por último, especialmente para hacer esto en una enumeración JsonEnumque serializa con el método getYourValue(), su serializador y deserializador podrían verse así:

public void serialize(final JsonEnum enumValue, final JsonGenerator gen, final SerializerProvider serializer) throws IOException, JsonProcessingException
{
    gen.writeString(enumValue.getYourValue());
}

public JsonEnum deserialize(final JsonParser parser, final DeserializationContext context) throws IOException, JsonProcessingException
{
    final String jsonValue = parser.getText();
    for (final JsonEnum enumValue : JsonEnum.values())
    {
        if (enumValue.getYourValue().equals(jsonValue))
        {
            return enumValue;
        }
    }
    return null;
}

He encontrado una solución muy agradable y concisa, especialmente útil cuando no puede modificar las clases de enumeración como era en mi caso. Luego, debe proporcionar un ObjectMapper personalizado con una determinada característica habilitada. Esas características están disponibles desde Jackson 1.6. Entonces solo necesita escribir el toString()método en su enumeración.

public class CustomObjectMapper extends ObjectMapper {
    @PostConstruct
    public void customConfiguration() {
        // Uses Enum.toString() for serialization of an Enum
        this.enable(WRITE_ENUMS_USING_TO_STRING);
        // Uses Enum.toString() for deserialization of an Enum
        this.enable(READ_ENUMS_USING_TO_STRING);
    }
}

Hay más funciones relacionadas con la enumeración disponibles, consulte aquí:

https://github.com/FasterXML/jackson-databind/wiki/Serialization-Features https://github.com/FasterXML/jackson-databind/wiki/Deserialization-Features

Prueba esto.

public enum Event {

    FORGOT_PASSWORD("forgot password");

    private final String value;

    private Event(final String description) {
        this.value = description;
    }

    private Event() {
        this.value = this.name();
    }

    @JsonValue
    final String value() {
        return this.value;
    }
}

Puede personalizar la deserialización para cualquier atributo.

Declare su clase deserialize usando annotationJsonDeserialize ( import com.fasterxml.jackson.databind.annotation.JsonDeserialize) para el atributo que se procesará. Si esto es una enumeración:

@JsonDeserialize(using = MyEnumDeserialize.class)
private MyEnum myEnum;

De esta manera, su clase se utilizará para deserializar el atributo. Este es un ejemplo completo:

public class MyEnumDeserialize extends JsonDeserializer<MyEnum> {

    @Override
    public MyEnum deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
        JsonNode node = jsonParser.getCodec().readTree(jsonParser);
        MyEnum type = null;
        try{
            if(node.get("attr") != null){
                type = MyEnum.get(Long.parseLong(node.get("attr").asText()));
                if (type != null) {
                    return type;
                }
            }
        }catch(Exception e){
            type = null;
        }
        return type;
    }
}

Hay varios enfoques que puede tomar para lograr la deserialización de un objeto JSON en una enumeración. Mi estilo favorito es hacer una clase interna:

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonProperty;
import org.hibernate.validator.constraints.NotEmpty;

import java.util.Arrays;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

import static com.fasterxml.jackson.annotation.JsonFormat.Shape.OBJECT;

@JsonFormat(shape = OBJECT)
public enum FinancialAccountSubAccountType {
  MAIN("Main"),
  MAIN_DISCOUNT("Main Discount");

  private final static Map<String, FinancialAccountSubAccountType> ENUM_NAME_MAP;
  static {
    ENUM_NAME_MAP = Arrays.stream(FinancialAccountSubAccountType.values())
      .collect(Collectors.toMap(
        Enum::name,
        Function.identity()));
  }

  private final String displayName;

  FinancialAccountSubAccountType(String displayName) {
    this.displayName = displayName;
  }

  @JsonCreator
  public static FinancialAccountSubAccountType fromJson(Request request) {
    return ENUM_NAME_MAP.get(request.getCode());
  }

  @JsonProperty("name")
  public String getDisplayName() {
    return displayName;
  }

  private static class Request {
    @NotEmpty(message = "Financial account sub-account type code is required")
    private final String code;
    private final String displayName;

    @JsonCreator
    private Request(@JsonProperty("code") String code,
                    @JsonProperty("name") String displayName) {
      this.code = code;
      this.displayName = displayName;
    }

    public String getCode() {
      return code;
    }

    @JsonProperty("name")
    public String getDisplayName() {
      return displayName;
    }
  }
}

Aquí hay otro ejemplo que usa valores de cadena en lugar de un mapa.

public enum Operator {
    EQUAL(new String[]{"=","==","==="}),
    NOT_EQUAL(new String[]{"!=","<>"}),
    LESS_THAN(new String[]{"<"}),
    LESS_THAN_EQUAL(new String[]{"<="}),
    GREATER_THAN(new String[]{">"}),
    GREATER_THAN_EQUAL(new String[]{">="}),
    EXISTS(new String[]{"not null", "exists"}),
    NOT_EXISTS(new String[]{"is null", "not exists"}),
    MATCH(new String[]{"match"});

    private String[] value;

    Operator(String[] value) {
        this.value = value;
    }

    @JsonValue
    public String toStringOperator(){
        return value[0];
    }

    @JsonCreator
    public static Operator fromStringOperator(String stringOperator) {
        if(stringOperator != null) {
            for(Operator operator : Operator.values()) {
                for(String operatorString : operator.value) {
                    if (stringOperator.equalsIgnoreCase(operatorString)) {
                        return operator;
                    }
                }
            }
        }
        return null;
    }
}

En el contexto de una enumeración, usar @JsonValuenow (since 2.0) funciona para la serialización y deserialización.

Según las anotaciones de jackson javadoc para@JsonValue :

NOTA: cuando se usa para enumeraciones Java, una característica adicional es que el valor devuelto por el método anotado también se considera el valor para deserializar, no solo JSON String para serializar como. Esto es posible ya que el conjunto de valores de Enum es constante y es posible definir la asignación, pero no se puede hacer en general para los tipos POJO; como tal, esto no se usa para la deserialización de POJO.

Por lo tanto, tener la Eventenumeración anotada tal como funciona anteriormente (tanto para la serialización como para la deserialización) con jackson 2.0+.

Además de usar @JsonSerialize @JsonDeserialize, también puede usar SerializationFeature y DeserializationFeature (enlace jackson) en el mapeador de objetos.

Como DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE, que dan el tipo de enumeración predeterminado si el proporcionado no está definido en la clase de enumeración.

La forma más simple que encontré es usar la anotación @ JsonFormat.Shape.OBJECT para la enumeración.

@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum MyEnum{
    ....
}

En mi caso, esto es lo que se resolvió:

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonProperty;

@JsonFormat(shape = JsonFormat.Shape.OBJECT)
public enum PeriodEnum {

    DAILY(1),
    WEEKLY(2),
    ;

    private final int id;

    PeriodEnum(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return this.name();
    }

    @JsonCreator
    public static PeriodEnum fromJson(@JsonProperty("name") String name) {
        return valueOf(name);
    }
}

Serializa y deserializa los siguientes json:

{
  "id": 2,
  "name": "WEEKLY"
}

¡Espero que ayude!