Serializar enumeraciones con Jackson

90

Tengo una enumeración descrita a continuación:

public enum OrderType {

  UNKNOWN(0, "Undefined"),
  TYPEA(1, "Type A"),
  TYPEB(2, "Type B"),
  TYPEC(3, "Type C");

  private Integer id;
  private String name;

  private WorkOrderType(Integer id, String name) {
    this.id = id;
    this.name = name;
  }

  //Setters, getters....
}

Devuelvo la matriz de enumeración con mi controlador ( new OrderType[] {UNKNOWN,TYPEA,TYPEB,TYPEC};), y Spring la serializa en la siguiente cadena json:

["UNKNOWN", "TYPEA", "TYPEB", "TYPEC"]

¿Cuál es el mejor enfoque para obligar a Jackson a serializar enumeraciones como los POJO? P.ej:

[
  {"id": 1, "name": "Undefined"},
  {"id": 2, "name": "Type A"},
  {"id": 3, "name": "Type B"},
  {"id": 4, "name": "Type C"}
]

Jugué con diferentes anotaciones pero no pude conseguir tal resultado.

java  json  spring  spring-mvc  jackson 
— Nofate
fuente
1
Parece que ya encontró la solución; ¡estupendo! ¿Tenía curiosidad por saber por qué lo necesita?
— StaxMan
Estoy desarrollando una aplicación GWT que se comunica con el lado del servidor a través de JSON. Esta enumeración proporcionará valores de opción para el cuadro combinado.
— Nofate
Ah, vale. Una especie de abreviatura para un conjunto de valores ... interesante.
— StaxMan

Respuestas:

87

Finalmente encontré la solución yo mismo.

Tuve que anotar enum @JsonSerialize(using = OrderTypeSerializer.class)e implementar un serializador personalizado:

public class OrderTypeSerializer extends JsonSerializer<OrderType> {

  @Override
  public void serialize(OrderType value, JsonGenerator generator,
            SerializerProvider provider) throws IOException,
            JsonProcessingException {

    generator.writeStartObject();
    generator.writeFieldName("id");
    generator.writeNumber(value.getId());
    generator.writeFieldName("name");
    generator.writeString(value.getName());
    generator.writeEndObject();
  }
}
— Nofate
fuente
4
Tenga en cuenta que para configurar Jackson para utilizar el procesamiento de (des) serialización personalizado, una alternativa al uso de una anotación es registrar (des) serializadores con un módulo de configuración. wiki.fasterxml.com/JacksonHowToCustomSerializers
— Programador Bruce
1
Esto no funcionó para mí usando Spring 3.1.1. Mi @Controller todavía devuelve json sin mis atributos.
— Dave
Tengo algunas enumeraciones y quiero obtener todas las enumeraciones con una función. ¿Cómo puedo hacerlo?
— Morteza Malvandi
Para un tipo de enumeración, tengo que definir un deserializador personalizado. ¿Existe alguna solución genérica?
— Chao
78 
@JsonFormat(shape= JsonFormat.Shape.OBJECT)
public enum SomeEnum

disponible desde https://github.com/FasterXML/jackson-databind/issues/24

recién probado funciona con la versión 2.1.2

respuesta a TheZuck :

Probé tu ejemplo, obtuve Json: 

{"events":[{"type":"ADMIN"}]}

Mi código:

@RequestMapping(value = "/getEvent") @ResponseBody
  public EventContainer getEvent() {
    EventContainer cont = new EventContainer();
    cont.setEvents(Event.values());
    return cont;
 }

class EventContainer implements Serializable {

  private Event[] events;

  public Event[] getEvents() {
    return events;
 }

 public void setEvents(Event[] events) {
   this.events = events;
 }
}

y las dependencias son:

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-annotations</artifactId>
  <version>${jackson.version}</version>
</dependency>

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-core</artifactId>
  <version>${jackson.version}</version>
</dependency>

<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>${jackson.version}</version>
  <exclusions>
    <exclusion>
      <artifactId>jackson-annotations</artifactId>
      <groupId>com.fasterxml.jackson.core</groupId>
    </exclusion>
    <exclusion>
      <artifactId>jackson-core</artifactId>
      <groupId>com.fasterxml.jackson.core</groupId>
    </exclusion>
  </exclusions>
</dependency>

<jackson.version>2.1.2</jackson.version>
— Vecnas
fuente
2
Me gusta esta alternativa, es más limpia, sin embargo, la probé con esta clase y el tipo no se serializa, ¿alguna idea de lo que está mal? @JsonFormat (forma = JsonFormat.Shape.OBJECT) @JsonAutoDetect () evento público enum {VISIT_WEBSITE (Type.ADMIN); @JsonProperty public Type type; public Type getType () {tipo de retorno; } Evento (tipo tipo) {this.type = type; } public enum Type {ADMIN, CONSUMER,}} Estoy usando Jackson 2.1.2
— TheZuck
— Agregué
descubrí lo que estaba mal, estaba usando Jackson 2.1.2 pero mi versión Spring todavía era 3.1, por lo que no era compatible con esta versión. Actualizado a 3.2.1 y todo está bien ahora. ¡Gracias!
— TheZuck
@Vecnas ¿Puedo anular el valor predeterminado @JsonFormatde la enumeración cuando se usa en otra entidad? por ejemplo, una entidad en la que quiero que la enumeración se serialice como una cadena en lugar de un objeto. Intento agregar otro @JsonFormaten el campo de la clase que usa la enumeración, pero siempre se serializa como un objeto.
— Herau
Lo que encontré, use - @JsonSerialize (usando = ToStringSerializer.class) para un campo, usa toString (). No es una solución estricta, pero funciona
— Vecnas
25

Encontré una solución muy agradable y concisa, especialmente útil cuando no se pueden modificar las clases de enumeración como fue en mi caso. Luego, debe proporcionar un ObjectMapper personalizado con una determinada función habilitada. Esas funciones están disponibles desde Jackson 1.6.

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

— lagivan
fuente
4
Estoy de acuerdo. Además, en Jackson 2.5, no necesita un mapeador de objetos personalizado. Solo haz esto: objMapper.enable(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);y esto:objMapper.enable(DeserializationFeature.READ_ENUMS_USING_TO_STRING);
— Jake Toronto
14

Aquí está mi solución. Quiero transformar enum en {id: ..., name: ...}forma.

Con Jackson 1.x :

pom.xml:

<properties>
    <jackson.version>1.9.13</jackson.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.codehaus.jackson</groupId>
        <artifactId>jackson-core-asl</artifactId>
        <version>${jackson.version}</version>
    </dependency>
    <dependency>
        <groupId>org.codehaus.jackson</groupId>
        <artifactId>jackson-mapper-asl</artifactId>
        <version>${jackson.version}</version>
    </dependency>
</dependencies>

Rule.java:

import org.codehaus.jackson.map.annotate.JsonSerialize;
import my.NamedEnumJsonSerializer;
import my.NamedEnum;

@Entity
@Table(name = "RULE")
public class Rule {
    @Column(name = "STATUS", nullable = false, updatable = true)
    @Enumerated(EnumType.STRING)
    @JsonSerialize(using = NamedEnumJsonSerializer.class)
    private Status status;
    public Status getStatus() { return status; }
    public void setStatus(Status status) { this.status = status; }

    public static enum Status implements NamedEnum {
        OPEN("open rule"),
        CLOSED("closed rule"),
        WORKING("rule in work");

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

NamedEnum.java:

package my;

public interface NamedEnum {
    String name();
    String getName();
}

NamedEnumJsonSerializer.java:

package my;

import my.NamedEnum;
import java.io.IOException;
import java.util.*;
import org.codehaus.jackson.JsonGenerator;
import org.codehaus.jackson.JsonProcessingException;
import org.codehaus.jackson.map.JsonSerializer;
import org.codehaus.jackson.map.SerializerProvider;

public class NamedEnumJsonSerializer extends JsonSerializer<NamedEnum> {
    @Override
    public void serialize(NamedEnum value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
        Map<String, String> map = new HashMap<>();
        map.put("id", value.name());
        map.put("name", value.getName());
        jgen.writeObject(map);
    }
}

Con Jackson 2.x :

pom.xml:

<properties>
    <jackson.version>2.3.3</jackson.version>
</properties>

<dependencies>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>${jackson.version}</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>${jackson.version}</version>
    </dependency>
</dependencies>

Rule.java:

import com.fasterxml.jackson.annotation.JsonFormat;

@Entity
@Table(name = "RULE")
public class Rule {
    @Column(name = "STATUS", nullable = false, updatable = true)
    @Enumerated(EnumType.STRING)
    private Status status;
    public Status getStatus() { return status; }
    public void setStatus(Status status) { this.status = status; }

    @JsonFormat(shape = JsonFormat.Shape.OBJECT)
    public static enum Status {
        OPEN("open rule"),
        CLOSED("closed rule"),
        WORKING("rule in work");

        private String name;
        Status(String name) { this.name = name; }
        public String getName() { return this.name; }
        public String getId() { return this.name(); }
    };
}

Rule.Status.CLOSEDtraducido a {id: "CLOSED", name: "closed rule"}.

— Gavenkoa
fuente
Excelente. Me salvaste el día :-)
— sriram
4

Una forma fácil de serializar Enum es usar la anotación @JsonFormat. @JsonFormat puede configurar la serialización de un Enum de tres formas.

@JsonFormat.Shape.STRING
public Enum OrderType {...}

utiliza OrderType :: name como método de serialización. La serialización de OrderType.TypeA es“TYPEA”

@JsonFormat.Shape.NUMBER
Public Enum OrderTYpe{...}

utiliza OrderType :: ordinal como método de serialización. La serialización de OrderType.TypeA es1

@JsonFormat.Shape.OBJECT
Public Enum OrderType{...}

trata OrderType como un POJO. La serialización de OrderType.TypeA es{"id":1,"name":"Type A"}

JsonFormat.Shape.OBJECT es lo que necesita en su caso.

Una forma un poco más complicada es su solución, especificando un serializador para Enum.

Consulte esta referencia: https://fasterxml.github.io/jackson-annotations/javadoc/2.2.0/com/fasterxml/jackson/annotation/JsonFormat.html

— rayo
fuente
3

Use la anotación @JsonCreator, cree el método getType (), se serialice con toString o el objeto funcione 

{"ATIVO"}

o

{"type": "ATIVO", "descricao": "Ativo"}

...

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.JsonNodeType;

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

    ATIVO("Ativo"),
    PENDENTE_VALIDACAO("Pendente de Validação"),
    INATIVO("Inativo"),
    BLOQUEADO("Bloqueado"),
    /**
     * Usuarios cadastrados pelos clientes que não possuem acesso a aplicacao,
     * caso venham a se cadastrar este status deve ser alterado
     */
    NAO_REGISTRADO("Não Registrado");

    private SituacaoUsuario(String descricao) {
        this.descricao = descricao;
    }

    private String descricao;

    public String getDescricao() {
        return descricao;
    }

    // TODO - Adicionar metodos dinamicamente
    public String getType() {
        return this.toString();
    }

    public String getPropertieKey() {
        StringBuilder sb = new StringBuilder("enum.");
        sb.append(this.getClass().getName()).append(".");
        sb.append(toString());
        return sb.toString().toLowerCase();
    }

    @JsonCreator
    public static SituacaoUsuario fromObject(JsonNode node) {
        String type = null;
        if (node.getNodeType().equals(JsonNodeType.STRING)) {
            type = node.asText();
        } else {
            if (!node.has("type")) {
                throw new IllegalArgumentException();
            }
            type = node.get("type").asText();
        }
        return valueOf(type);
    }

}
— Gleidosn
fuente
0

En Spring Boot 2, la forma más sencilla es declarar en su application.properties:

spring.jackson.serialization.WRITE_ENUMS_USING_TO_STRING=true
spring.jackson.deserialization.READ_ENUMS_USING_TO_STRING=true

y defina el método toString () de sus enumeraciones.

— JRA_TLL
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.