傑克遜枚舉序列化器和解串器

Question

我使用JAVA 1.6和傑克遜1.9.9我有一個枚舉

public enum Event { 
    FORGOT_PASSWORD("forgot password"); 

    private final String value; 

    private Event(final String description) { 
     this.value = description; 
    } 

    @JsonValue 
    final String value() { 
     return this.value; 
    } 
} 

我添加了一個@JsonValue，這似乎做對象序列化工作成：

{"event":"forgot password"} 

但是當我嘗試反序列化，我得到一個

Caused by: org.codehaus.jackson.map.JsonMappingException: Can not construct instance of com.globalrelay.gas.appsjson.authportal.Event from String value 'forgot password': value not one of declared Enum instance names 

缺少什麼我在這裏？

Answer 1

如果您希望將yor枚舉類與其JSON表示完全分離，那麼xbakesx指出的序列化器/反序列化器解決方案是非常好的解決方案。

或者，如果您更喜歡自包含的解決方案，基於@JsonCreator和@JsonValue註釋的實現將更加方便。

因此，利用Stanley的例子，下面是一個完整的自包含解決方案（Java 6，Jackson 1。9）：

public enum DeviceScheduleFormat { 
    Weekday, 
    EvenOdd, 
    Interval; 

    private static Map<String, DeviceScheduleFormat> namesMap = new HashMap<String, DeviceScheduleFormat>(3); 

    static { 
     namesMap.put("weekday", Weekday); 
     namesMap.put("even-odd", EvenOdd); 
     namesMap.put("interval", Interval); 
    } 

    @JsonCreator 
    public static DeviceScheduleFormat forValue(String value) { 
     return namesMap.get(StringUtils.lowerCase(value)); 
    } 

    @JsonValue 
    public String toValue() { 
     for (Entry<String, DeviceScheduleFormat> entry : namesMap.entrySet()) { 
      if (entry.getValue() == this) 
       return entry.getKey(); 
     } 

     return null; // or fail 
    } 
} 

Answer 2

實際答：

默認解串器枚舉使用.name()反序列化，所以它不使用@JsonValue。正如@OldCurmudgeon指出的那樣，您需要傳入{"event": "FORGOT_PASSWORD"}以匹配.name()的值。

的另一種選擇（假設你想要寫和讀的JSON值是相同的）...

更多信息：

有（又）另一種方式來管理序列化和與傑克遜的反序列化過程。您可以指定這些批註使用自己定製的串行器和解串：

@JsonSerialize(using = MySerializer.class) 
@JsonDeserialize(using = MyDeserializer.class) 
public final class MyClass { 
    ... 
} 

然後，你必須寫MySerializer和MyDeserializer它看起來像這樣：

MySerializer

public final class MySerializer extends JsonSerializer<MyClass> 
{ 
    @Override 
    public void serialize(final MyClass yourClassHere, final JsonGenerator gen, final SerializerProvider serializer) throws IOException, JsonProcessingException 
    { 
     // here you'd write data to the stream with gen.write...() methods 
    } 

} 

MyDeserializer

public final class MyDeserializer extends org.codehaus.jackson.map.JsonDeserializer<MyClass> 
{ 
    @Override 
    public MyClass deserialize(final JsonParser parser, final DeserializationContext context) throws IOException, JsonProcessingException 
    { 
     // then you'd do something like parser.getInt() or whatever to pull data off the parser 
     return null; 
    } 

} 

最後一點，尤其是對這樣做是爲了與方法getYourValue()序列化的枚舉JsonEnum，你的串行器和解串可能是這樣的：

public void serialize(final JsonEnum enumValue, final JsonGenerator gen, final SerializerProvider serializer) throws IOException, JsonProcessingException 
{ 
    gen.writeString(enumValue.getYourValue()); 
} 

public JsonEnum deserialize(final JsonParser parser, final DeserializationContext context) throws IOException, JsonProcessingException 
{ 
    final String jsonValue = parser.getText(); 
    for (final JsonEnum enumValue : JsonEnum.values()) 
    { 
     if (enumValue.getYourValue().equals(jsonValue)) 
     { 
      return enumValue; 
     } 
    } 
    return null; 
} 

Answer 3

您應該創建一個靜態工廠方法這需要一個參數與@JsonCreator註釋它（因爲傑克遜1.2可用）

@JsonCreator 
public static Event forValue(String value) { ... } 

瞭解更多關於JsonCreator註釋here。

Answer 4

我發現一個非常漂亮和簡潔的解決方案，尤其是有用的，當你不能修改枚舉類，因爲它是在我的情況。然後，您應該提供一個自定義的ObjectMapper，並啓用某個功能。那些功能從傑克遜1.6開始就可用。所以你只需要在你的枚舉中寫toString()方法。

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

有更多可用的枚舉相關的功能，在這裏看到：

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

Answer 5

注意，由於this commit在2015年6月（傑克遜2.6.2及以上版本），你現在可以簡單地編寫：

public enum Event { 
    @JsonProperty("forgot password") 
    FORGOT_PASSWORD; 
} 

Answer 6

您可以自定義任何屬性的反序列化。

使用將要處理的屬性annotationJsonDeserialize（import com.fasterxml.jackson.databind.annotation.JsonDeserialize）聲明你的反序列化類。如果這是一個枚舉：

@JsonDeserialize(using = MyEnumDeserialize.class) 
private MyEnum myEnum; 

這樣你的類將用於反序列化屬性。這是一個完整的例子：

public class MyEnumDeserialize extends JsonDeserializer<MyEnum> { 

    @Override 
    public MyEnum deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { 
     JsonNode node = jsonParser.getCodec().readTree(jsonParser); 
     MyEnum type = null; 
     try{ 
      if(node.get("attr") != null){ 
       type = MyEnum.get(Long.parseLong(node.get("attr").asText())); 
       if (type != null) { 
        return type; 
       } 
      } 
     }catch(Exception e){ 
      type = null; 
     } 
     return type; 
    } 
} 

Answer 7

這是另一個使用字符串值而不是地圖的例子。

public enum Operator { 
    EQUAL(new String[]{"=","==","==="}), 
    NOT_EQUAL(new String[]{"!=","<>"}), 
    LESS_THAN(new String[]{"<"}), 
    LESS_THAN_EQUAL(new String[]{"<="}), 
    GREATER_THAN(new String[]{">"}), 
    GREATER_THAN_EQUAL(new String[]{">="}), 
    EXISTS(new String[]{"not null", "exists"}), 
    NOT_EXISTS(new String[]{"is null", "not exists"}), 
    MATCH(new String[]{"match"}); 

    private String[] value; 

    Operator(String[] value) { 
     this.value = value; 
    } 

    @JsonValue 
    public String toStringOperator(){ 
     return value[0]; 
    } 

    @JsonCreator 
    public static Operator fromStringOperator(String stringOperator) { 
     if(stringOperator != null) { 
      for(Operator operator : Operator.values()) { 
       for(String operatorString : operator.value) { 
        if (stringOperator.equalsIgnoreCase(operatorString)) { 
         return operator; 
        } 
       } 
      } 
     } 
     return null; 
    } 
} 

Answer 8

有多種方法可以完成將JSON對象反序列化爲枚舉。我最喜歡的風格是做一個內心階層：

import com.fasterxml.jackson.annotation.JsonCreator; 
import com.fasterxml.jackson.annotation.JsonFormat; 
import com.fasterxml.jackson.annotation.JsonProperty; 
import org.hibernate.validator.constraints.NotEmpty; 

import java.util.Arrays; 
import java.util.Map; 
import java.util.function.Function; 
import java.util.stream.Collectors; 

import static com.fasterxml.jackson.annotation.JsonFormat.Shape.OBJECT; 

@JsonFormat(shape = OBJECT) 
public enum FinancialAccountSubAccountType { 
    MAIN("Main"), 
    MAIN_DISCOUNT("Main Discount"); 

    private final static Map<String, FinancialAccountSubAccountType> ENUM_NAME_MAP; 
    static { 
    ENUM_NAME_MAP = Arrays.stream(FinancialAccountSubAccountType.values()) 
     .collect(Collectors.toMap(
     Enum::name, 
     Function.identity())); 
    } 

    private final String displayName; 

    FinancialAccountSubAccountType(String displayName) { 
    this.displayName = displayName; 
    } 

    @JsonCreator 
    public static FinancialAccountSubAccountType fromJson(Request request) { 
    return ENUM_NAME_MAP.get(request.getCode()); 
    } 

    @JsonProperty("name") 
    public String getDisplayName() { 
    return displayName; 
    } 

    private static class Request { 
    @NotEmpty(message = "Financial account sub-account type code is required") 
    private final String code; 
    private final String displayName; 

    @JsonCreator 
    private Request(@JsonProperty("code") String code, 
        @JsonProperty("name") String displayName) { 
     this.code = code; 
     this.displayName = displayName; 
    } 

    public String getCode() { 
     return code; 
    } 

    @JsonProperty("name") 
    public String getDisplayName() { 
     return displayName; 
    } 
    } 
}