enumeraciones Serialización con Jackson

Question

Tengo una enumeración desrcibed 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.... 
} 

vuelvo gama de enumeración con mi controlador (new OrderType[] {UNKNOWN,TYPEA,TYPEB,TYPEC};), y la primavera serializa en la siguiente cadena JSON:

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

Lo ¿Cuál es el mejor enfoque para obligar a Jackson a serializar enumeraciones como POJOs? Ej .:

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

He jugado con diferentes anotaciones, pero no lograba conseguir tal resultado.

Answer 1

Finalmente encontré la solución yo mismo.

que tuvieron para anotar enumeración con @JsonSerialize(using = OrderTypeSerializer.class) e implementar 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(); 
    } 
} 

Answer 2

@JsonFormat(shape= JsonFormat.Shape.OBJECT) 
public enum SomeEnum 

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

acabo de probar que funciona con la versión 2.1.2

respuesta a TheZuck:

traté tu ejemplo, consiguió 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 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> 

Answer 3

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

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> 

Regla.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.CLOSED traducido a {id: "CLOSED", name: "closed rule"}.

Answer 4

He encontrado una solución muy agradable y concisa, especialmente útil cuando no se pueden modificar las clases enum como en mi caso. Luego debe proporcionar un ObjectMapper personalizado con una característica determinada habilitada. Esas características 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 características relacionadas con ENUM disponible, ver aquí:

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

Answer 5

Uso @JsonCreator anotación, crear getType método(), es serializar con toString u objeto de trabajo

{"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); 
    } 

} 

Answer 6

Una manera fácil de serializar Enum está utilizando la anotación @JsonFormat. @JsonFormat puede configurar la serialización de un Enum de tres maneras.

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

usa OrderType :: name como el método de serialización. Serialización de OrderType.TypeA es “TYPEA”

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

utiliza OrderType :: ordinal como el método de serialización. Serialización de OrderType.TypeA es 1

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

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

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

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

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