知識庫 / JSON / Jackson RSS 訂閱

public class Fruit {
    public String variety;

    @JsonKey
    public String name;

    public Fruit(String variety, String name) {
        this.variety = variety;
        this.name = name;
    }

    @JsonValue
    public String getFullName() {
        return this.variety + " " + this.name;
    }
}

我們必須注意到，在任何 Fruit 對象作為 Map 鍵出現時，我們都希望使用它的名稱進行序列化。但是，當它作為值出現時，我們希望同時使用它的名稱和品種。

現在，讓我們初始化兩個 Fruit 類的實例和一個 ObjectMapper 類的實例，用於序列化目的：

private static final Fruit FRUIT1 = new Fruit("Alphonso", "Mango");
private static final Fruit FRUIT2 = new Fruit("Black", "Grapes");
private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

接下來，我們應該記住，在序列化獨立實例時，會使用 @JsonValue 屬性進行序列化。讓我們驗證一下這對於這兩個對象是否成立：

@Test
public void givenObject_WhenSerialize_ThenUseJsonValueForSerialization() 
  throws JsonProcessingException {
    String serializedValueForFruit1 = OBJECT_MAPPER.writeValueAsString(FRUIT1);
    Assertions.assertEquals("\"Alphonso Mango\"", serializedValueForFruit1);
    String serializedValueForFruit2 = OBJECT_MAPPER.writeValueAsString(FRUIT2);
    Assertions.assertEquals("\"Black Grapes\"", serializedValueForFruit2);
}

進一步來説，讓我們將 selectionByFruit Map，該 Map 包含 Fruit 類的實例，作為鍵進行序列化：

@Test
public void givenMapWithObjectKeys_WhenSerialize_ThenUseJsonKeyForSerialization() 
  throws JsonProcessingException {
    // Given
    Map<Fruit, String> selectionByFruit = new LinkedHashMap<>();
    selectionByFruit.put(FRUIT1, "Hagrid");
    selectionByFruit.put(FRUIT2, "Hercules");
    // When
    String serializedValue = OBJECT_MAPPER.writeValueAsString(selectionByFruit);
    // Then
    Assertions.assertEquals("{\"Mango\":\"Hagrid\",\"Grapes\":\"Hercules\"}", serializedValue);
}

正如預期的那樣，@JsonKey 註解被用於此序列化。此外，我們使用了 LinkedHashMap 以在訪問和序列化期間修復鍵的順序。

最後，讓我們查看將 selectionByPerson Map（其中包含 Fruit 類的實例）序列化後的結果：

@Test
public void givenMapWithObjectValues_WhenSerialize_ThenUseJsonValueForSerialization() 
  throws JsonProcessingException {
    // Given
    Map<String, Fruit> selectionByPerson = new LinkedHashMap<>();
    selectionByPerson.put("Hagrid", FRUIT1);
    selectionByPerson.put("Hercules", FRUIT2);
    // When
    String serializedValue = OBJECT_MAPPER.writeValueAsString(selectionByPerson);
    // Then
    Assertions.assertEquals("{\"Hagrid\":\"Alphonso Mango\",\"Hercules\":\"Black Grapes\"}", 
      serializedValue);
}

太棒了！我們已成功地根據對象在 Map 中作為鍵或值的角色，切換了序列化策略。

4. 反序列化

反序列化將字節流轉換為 Java 對象，以便在代碼中使用。 在本部分，我們將反序列化 JSON 輸入，將其轉換為具有不同簽名的 Map 對象。

4.1. Map<String, String> 反序列化

對於一個簡單的例子，我們以 JSON 格式的輸入字符串為例，將其轉換為一個 Map<String, String> Java 集合：

String jsonInput = "{\"key\": \"value\"}";
TypeReference<HashMap<String, String>> typeRef 
  = new TypeReference<HashMap<String, String>>() {};
Map<String, String> map = mapper.readValue(jsonInput, typeRef);

我們使用 Jackson 的 ObjectMapper，正如我們在序列化中所做的那樣，使用 readValue() 處理輸入。 此外，請注意我們使用 Jackson 的 TypeReference，我們將在此處的所有反序列化示例中使用它來描述我們的目標 Map 的類型。 這是一個 toString() 表示形式的 Map：

{key=value}

4.2. Map<Object, String> 反序列化

現在，讓我們更改我們的輸入 JSON 以及目標 TypeReference 的類型為 Map<MyPair, String>：

String jsonInput = "{\"Abbott and Costello\" : \"Comedy\"}";

TypeReference<HashMap<MyPair, String>> typeRef 
  = new TypeReference<HashMap<MyPair, String>>() {};
Map<MyPair,String> map = mapper.readValue(jsonInput, typeRef);

我們需要創建一個構造函數 MyPair，該構造函數接受一個包含兩個元素的 String，並將它們解析為 MyPair 的元素：

public MyPair(String both) {
    String[] pairs = both.split("and");
    this.first = pairs[0].trim();
    this.second = pairs[1].trim();
}

我們的 Map<MyPair,String> 對象的 toString() 是:

{Abbott and Costello=Comedy}

當我們將數據反序列化到包含 Map 的 Java 類時，我們可以使用 Jackson 的 KeyDeserializer 類，這是 Jackson 提供的眾多 反序列化 類之一。讓我們使用 @JsonCreator、@JsonProperty 和 @JsonDeserialize 註解我們的 ClassWithAMap 類。

public class ClassWithAMap {

  @JsonProperty("map")
  @JsonDeserialize(keyUsing = MyPairDeserializer.class)
  private Map<MyPair, String> map;

  @JsonCreator
  public ClassWithAMap(Map<MyPair, String> map) {
    this.map = map;
  }
 
  // public getters/setters omitted
}

public class MyPairDeserializer extends KeyDeserializer {

  @Override
  public MyPair deserializeKey(
    String key, 
    DeserializationContext ctxt) throws IOException, 
    JsonProcessingException {
      
      return new MyPair(key);
    }
}

String jsonInput = "{\"Abbott and Costello\":\"Comedy\"}";

ClassWithAMap classWithMap = mapper.readValue(jsonInput,
  ClassWithAMap.class);

{Abbott and Costello=Comedy}

String jsonInput = "{\"Abbott and Costello\" : \"Comedy and 1940s\"}";
TypeReference<HashMap<MyPair, MyPair>> typeRef 
  = new TypeReference<HashMap<MyPair, MyPair>>() {};
Map<MyPair,MyPair> map = mapper.readValue(jsonInput, typeRef);

{Abbott and Costello=Comedy and 1940s}