How to deserialize Enum with Jackson?

user_233286 0
Viewed 3481

A user POSTs {"lang": ["en_US", "en_UK"]} to a REST API. I want to fill an object which has this property List<EnmLanguage> lang;. Every other thing works except JSON arrays.

My EnmLanguage.java is:

@JsonSerialize(
    using = BaseEnumSerializer.class
)
@JsonDeserialize(
    using = BaseEnumDeserializer.class
)
public enum EnmLanguage implements BaseEnum, Serializable {
    en_US {
        public String getCode() {
            return "en_US";
        }

        public String getText(EnmLanguage s) {
            return s == EnmLanguage.en_US ? "English" : "İngilizce";
        }
    },

My BaseEnum.java is:

public interface BaseEnum {
    Object getCode();

    String getText(EnmLanguage lang);

    default String getText() {
        return this.getText(EnmLanguage.tr_TR);
    }

    default Map<String, Object> getMap(EnmLanguage lang) {
        return new HashMap<String, Object>() {
            {
                this.put("name", BaseEnum.this.getText(lang));
                this.put("id", BaseEnum.this.getCode());
            }
        };
    }

    default Map<String, Object> getMap() {
        return this.getMap(EnmLanguage.tr_TR);
    }

    static <T extends Enum<T> & BaseEnum> T fromCode(Class<T> parent, Object code) {
        Map<Object, T> lookup = new HashMap();
        Enum[] var3 = (Enum[])parent.getEnumConstants();
        int var4 = var3.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            T d = var3[var5];
            lookup.put(((BaseEnum)d).getCode().toString(), d);
        }

        return (Enum)lookup.get(code.toString());
    }
}

My BaseEnumDeserialiazer is:

public class BaseEnumDeserializer<T extends Enum<T> & BaseEnum> extends StdDeserializer<T> {
    public BaseEnumDeserializer() {
        this((Class)null);
    }

    public BaseEnumDeserializer(Class<T> vc) {
        super(vc);
    }

    public T deserialize(JsonParser jsonparser, DeserializationContext context) throws IOException {
        Field field = this.findField(jsonparser.getCurrentName(), jsonparser.getCurrentValue().getClass());
        Class<T> javaType = field.getType();
        return BaseEnum.fromCode(javaType, jsonparser.getText());
    }

    public Field findField(String name, Class<?> c) {
        while(c != null) {
            Field[] var3 = c.getDeclaredFields();
            int var4 = var3.length;

            for(int var5 = 0; var5 < var4; ++var5) {
                Field field = var3[var5];
                if (!Modifier.isStatic(field.getModifiers()) && field.getName().equals(name)) {
                    return field;
                }
            }

            c = c.getSuperclass();
        }

        return null;
    }
}

But at the end it doesn't convert "lang": ["en_US", "en_UK"] into List of EnmLanguage. I think it doesn't know to which BaseEnum convert. How should I let it know that it should convert it into List<EnmLanguage>?

jackson serialization java
3 Answers

For your specific case it would probably be enough to add static @JsonCreator method inside base type.

interface Lang {
    @JsonCreator
    static Lang valueOf(String value) {
        return Languages.valueOf(value);
    }
}

@JsonFormat(shape = JsonFormat.Shape.STRING)
enum Languages implements Lang {
    en_US,
    en_GB
}

And then you can parse it as any other class

class LangTest {
    private final ObjectMapper mapper = new ObjectMapper()
            .setAnnotationIntrospector(new JacksonAnnotationIntrospector());

    @Test
    void readsJson() throws IOException {
        final Lang[] tree = this.mapper
                .readerFor(Lang[].class)
                .readValue("[\"en_US\", \"en_GB\"]");
        Assertions.assertArrayEquals(
                tree,
                new Lang[]{
                        Languages.en_US,
                        Languages.en_GB
                }
        );
    }
}
user_124624440

Here's a simple BaseEnum interface,

public interface BaseEnum {
    Object getCode();

    String getText();
}

Here's EnmLanguage implementing the BaseEnum interface,

public enum EnmLanguage implements BaseEnum {

    en_US("en_US", "English"),
    en_UK("en_UK", "English"),
    tr_TR("tr_TR", "Turkish");

    private String code;

    private String text;

    EnmLanguage(String code, String text) {
        this.code = code;
        this.text = text;
    }

    @Override
    public String getCode() {
        return code;
    }

    @Override
    public String getText() {
        return text;
    }
}

Here's another EnmElement implementing the BaseEnum interface,

public enum EnmElement implements BaseEnum {

    H("H", "Hydrogen"),
    He("He", "Helium"),
    Li("Li", "Lithium");

    private String code;

    private String text;

    EnmElement(String code, String text) {
        this.code = code;
        this.text = text;
    }

    @Override
    public String getCode() {
        return code;
    }

    @Override
    public String getText() {
        return text;
    }
}

Here's a simple Unit test,

import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.Test;

import java.io.IOException;

import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;

public class EnumTest {

    @Test
    public void testDeserializeLanguage() throws IOException {
        ObjectMapper mapper = new ObjectMapper();

        EnmLanguage[] expected = {EnmLanguage.en_US, EnmLanguage.tr_TR};
        EnmLanguage[] actual = mapper
                .readerFor(EnmLanguage[].class)
                .readValue(mapper.writeValueAsString(expected));
        assertNotNull(actual);
        assertArrayEquals(expected, actual);
    }

    @Test
    public void testDeserializeElement() throws IOException {
        ObjectMapper mapper = new ObjectMapper();

        EnmElement[] expected = {EnmElement.H, EnmElement.He, EnmElement.Li};
        EnmElement[] actual = mapper
                .readerFor(EnmElement[].class)
                .readValue(mapper.writeValueAsString(expected));
        assertNotNull(actual);
        assertArrayEquals(expected, actual);
    }
}

A slightly more complicated example using the enums,

import lombok.Data;

@Data
public class CompositeExample {

    private String name;

    private EnmLanguage[] lands;

    private EnmElement[] elements;
}

A sample unit test snippet,

 @Test
 public void testDeserialize() throws IOException {
     CompositeExample expected = new CompositeExample();

     String name = "Hello";
     expected.setName(name);

     EnmLanguage[] langs = {EnmLanguage.en_US, EnmLanguage.tr_TR};
     expected.setLangs(langs);

     EnmElement[] elements = {EnmElement.H, EnmElement.He,  EnmElement.Li};
     expected.setElements(elements);

     ObjectMapper mapper = new ObjectMapper();
     String json = mapper.writeValueAsString(expected);
     //{"name":"Hello","langs":["en_US","tr_TR"],"elements":["H","He","Li"]}

     CompositeExample actual = mapper
             .readerFor(CompositeExample.class)
             .readValue(json);
     assertNotNull(actual);
     assertEquals(expected, actual);
 }
user_80123790

Try to enable reading and writing enums using toString():

objectMapper.configure(SerializationFeature.WRITE_ENUMS_USING_TO_STRING, true);
objectMapper.configure(DeserializationFeature.READ_ENUMS_USING_TO_STRING, true);
user_2602290
Related