Serializing Enums with Jackson

Question

I have Enum desrcibed below:

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

I am returning an array of enumerations with my controller ( new OrderType[] {UNKNOWN,TYPEA,TYPEB,TYPEC}; ), and Spring serializes it to the following json line:

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

What is the best approach to get Jackson to serialize enums just like POJO? For example:.

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

I played with different annotations, but could not get such a result.

Answer 1

Finally, I found the solution myself.

I had to annotate enum using @JsonSerialize(using = OrderTypeSerializer.class) and implement my own serializer:

 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 

available from https://github.com/FasterXML/jackson-databind/issues/24

just tested it with version 2.1.2

answer to TheZuck :

I tried your example, got Json:

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

My code is:

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

}

and dependencies:

 <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

I found a very nice and concise solution, especially useful when you cannot modify the enum classes, as was the case in my case. Then you must provide a custom ObjectMapper with a specific function enabled. These features are available with 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); } } 

There are more features related to enumeration, see here:

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

Answer 4

Here is my solution. I want to convert enum to form {id: ..., name: ...} .

With 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); } } 

With 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.CLOSED translated into {id: "CLOSED", name: "closed rule"} .

Answer 5

Use @JsonCreator annotation, create getType () method, serialize using toString function or object

 {"ATIVO"} 

or

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

An easy way to serialize Enum is using the @JsonFormat annotation. @JsonFormat can configure Enum serialization in three ways.

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

uses the OrderType :: name method as a serialization method. Serialization of type OrderType.TypeA "TYPEA"

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

uses the OrderType :: ordinal method as a serialization method. Serialization of type OrderType.TypeA is 1

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

treats OrderType as a POJO. The serialization of the type OrderType.TypeA is {"id":1,"name":"Type A"}

JsonFormat.Shape.OBJECT is what you need in your case.

Somewhat more complicated is your decision by specifying a serializer for Enum.

Check out this link: https://fasterxml.imtqy.com/jackson-annotations/javadoc/2.2.0/com/fasterxml/jackson/annotation/JsonFormat.html