Serializzare enumerazioni con Jackson

Question

Ho un Enum desrcibed di seguito:

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.... 
} 

torno gamma enum con il mio controller (new OrderType[] {UNKNOWN,TYPEA,TYPEB,TYPEC};), e Spring serializza nella seguente stringa JSON:

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

Cosa è l'approccio migliore per costringere Jackson a serializzare enumerazioni come i POJO? Ad es .:

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

Ho giocato con annotazioni diverse ma non sono riuscito a ottenere tale risultato.

Answer 1

Finalmente ho trovato la soluzione da solo.

ho dovuto annotare enum con @JsonSerialize(using = OrderTypeSerializer.class) e implementare serializzatore personalizzato:

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 

disponibile dal https://github.com/FasterXML/jackson-databind/issues/24

appena testato funziona con la versione 2.1.2

risposta a TheZuck:

Ho cercato il tuo esempio, ha ottenuto JSON:

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

Il mio codice:

@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; 
} 
} 

e le dipendenze sono:

<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

Ecco la mia soluzione. Voglio trasformare enum in formato {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> 

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

Answer 4

Ho trovato una soluzione molto bella e concisa, particolarmente utile quando non è possibile modificare le classi enum come nel mio caso. Quindi devi fornire un ObjectMapper personalizzato con una determinata funzione abilitata. Quelle funzionalità sono disponibili da 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); 
    } 
} 

Non ci sono più caratteristiche enum legati a disposizione, vedi qui:

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

Answer 5

Usa @JsonCreator annotazioni, creare il metodo getType(), è serializzare con toString o un oggetto di lavoro

{"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

Un modo semplice per serializzare Enum sta usando @JsonFormat annotazione. @JsonFormat può configurare la serializzazione di un Enum in tre modi.

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

utilizza OrderType :: name come metodo di serializzazione. La serializzazione di OrderType.TypeA è “TYPEA”

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

utilizza OrderType :: ordinale come metodo di serializzazione. Serializzazione dei OrderType.TypeA è 1

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

tratta OrderType come POJO. La serializzazione di OrderType.TypeA è {"id":1,"name":"Type A"}

JsonFormat.Shape.OBJECT è quello che serve nel vostro caso.

Un po 'più complicato è la soluzione, specificando un serializzatore per l'Enum.

Partenza questo riferimento: https://fasterxml.github.io/jackson-annotations/javadoc/2.2.0/com/fasterxml/jackson/annotation/JsonFormat.html