知識庫 / JSON / Jackson RSS 訂閱

1. 概述

在本教程中，我們將介紹最常見的 Jackson 異常——JsonMappingException、UnrecognizedPropertyException 和 MismatchedInputException。

最後，我們將簡要討論 Jackson 的“No such method” 錯誤。

2. <em JsonMappingException</em>>: Can Not Construct Instance Of

當 JsonMappingException 異常被拋出時，通常表示在嘗試將 JSON 數據映射到 Java 對象時，無法構造出目標對象。 這通常意味着：

• JSON 數據的結構與目標對象的結構不匹配。 例如，JSON 中缺少某個字段，或者字段的類型不匹配。
• 缺少必要的構造函數參數。 目標對象需要一個或多個構造函數參數，但 JSON 數據中沒有提供這些參數。
• 存在循環引用。 JSON 數據中存在循環引用，導致無法正確構建對象。

解決 Can Not Construct Instance Of 異常的方法包括：

• 檢查 JSON 數據的結構。 確保 JSON 數據的字段名稱和類型與目標對象的屬性名稱和類型相匹配。
• 提供必要的構造函數參數。 如果目標對象需要構造函數參數，則在 JSON 數據中提供這些參數。
• 使用 JsonMappingException.printStackTrace() 打印堆棧跟蹤信息， 幫助你定位問題所在。
• 考慮使用 @JsonConstructor 註解， 並定義一個合適的構造函數，以明確指定 JSON 數據的映射規則。

2.1. 問題

首先，讓我們來看一下 JsonMappingException：無法構造實例。

當 Jackson 無法創建類的實例時，會拋出此異常，這發生在類是 抽象類 或僅僅是 接口時。

以下我們嘗試從 Zoo 類中反序列化一個實例，該類具有 抽象類型 Animal 的 animal 屬性：

public class Zoo {
    public Animal animal;
    
    public Zoo() { }
}

abstract class Animal {
    public String name;
    
    public Animal() { }
}

class Cat extends Animal {
    public int lives;
    
    public Cat() { }
}

當我們嘗試將 JSON 字符串反序列化到 Zoo 實例時，會拋出 JsonMappingException：無法構造實例：

@Test(expected = JsonMappingException.class)
public void givenAbstractClass_whenDeserializing_thenException() 
  throws IOException {
    String json = "{"animal":{"name":"lacy"}}";
    ObjectMapper mapper = new ObjectMapper();

    mapper.reader().forType(Zoo.class).readValue(json);
}

這是一個完整的異常:

com.fasterxml.jackson.databind.JsonMappingException: 
Can not construct instance of org.baeldung.jackson.exception.Animal,
  problem: abstract types either need to be mapped to concrete types, 
  have custom deserializer, 
  or be instantiated with additional type information
  at 
[Source: {"animal":{"name":"lacy"}}; line: 1, column: 2] 
(through reference chain: org.baeldung.jackson.exception.Zoo["animal"])
	at c.f.j.d.JsonMappingException.from(JsonMappingException.java:148)

2.2. 解決方案

我們可以通過簡單的註解來解決這個問題——在抽象類上添加 <em @JsonDeserialize</em> 註解：

@JsonDeserialize(as = Cat.class)
abstract class Animal {...}

請注意，如果抽象類有多個子類型，我們應考慮包含子類型信息，如在《使用 Jackson 進行繼承》一文中所示。

3. <em JsonMappingException</em>>: No Suitable Constructor

當 JsonMappingException 拋出“No Suitable Constructor”異常，通常意味着嘗試將 JSON 數據映射到 Java Bean 或其他對象時，找不到匹配的構造函數或getter方法。 具體來説，JSON 數據中的值與 Java Bean 屬性類型不匹配，或者 JSON 結構與 Java Bean 的屬性定義不一致。

這通常發生在以下情況：

• 類型不匹配： JSON 字符串的值（例如，字符串、數字、布爾值）與 Java Bean 中對應屬性的類型不匹配。
• 缺少必要的getter/setter： Java Bean 中缺少用於訪問和設置 JSON 字段值的getter或setter方法。
• 字段名稱不匹配： JSON 字段名稱與 Java Bean 中屬性名稱不匹配。
• JSON 結構不匹配： JSON 結構（例如，嵌套對象、數組）與 Java Bean 的屬性定義不一致。

解決此問題的方法包括：

• 驗證 JSON 數據： 確保 JSON 數據格式正確，並且數據類型與 Java Bean 屬性類型匹配。
• 修改 Java Bean 定義： 根據 JSON 結構修改 Java Bean 的屬性定義，確保屬性類型與 JSON 數據類型匹配。
• 添加必要的getter/setter： 為 Java Bean 添加必要的getter和setter方法，以便能夠正確地將 JSON 數據映射到 Java Bean 屬性中。
• 使用 JSON 轉換器： 使用 JSON 轉換器（例如，Jackson、Gson）來自動將 JSON 數據轉換為 Java Bean 對象。

3.1. 問題

現在我們來看常見的 JsonMappingException：未找到合適的構造函數。

當 Jackson 無法訪問構造函數時，會拋出此異常。

在下面的示例中，類 User 沒有默認構造函數：

public class User {
    public int id;
    public String name;

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

當嘗試將 JSON 字符串反序列化為 User 時，會拋出 JsonMappingException: No Suitable Constructor Found 異常。

@Test(expected = JsonMappingException.class)
public void givenNoDefaultConstructor_whenDeserializing_thenException() 
  throws IOException {
    String json = "{"id":1,"name":"John"}";
    ObjectMapper mapper = new ObjectMapper();

    mapper.reader().forType(User.class).readValue(json);
}

這是完整的異常:

com.fasterxml.jackson.databind.JsonMappingException: 
No suitable constructor found for type 
[simple type, class org.baeldung.jackson.exception.User]:
 can not instantiate from JSON object (need to add/enable type information?)
 at [Source: {"id":1,"name":"John"}; line: 1, column: 2]
        at c.f.j.d.JsonMappingException.from(JsonMappingException.java:148)

3.2. 解決方案

為了解決這個問題，我們只需添加一個默認構造函數：

public class User {
    public int id;
    public String name;

    public User() {
        super();
    }

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

現在當我們進行反序列化時，流程將正常工作：

@Test
public void givenDefaultConstructor_whenDeserializing_thenCorrect() 
  throws IOException {
 
    String json = "{"id":1,"name":"John"}";
    ObjectMapper mapper = new ObjectMapper();

    User user = mapper.reader()
      .forType(User.class).readValue(json);
    assertEquals("John", user.name);
}

4. <em JsonMappingException: 根名稱與預期不匹配

4.1. 問題

接下來，讓我們看看 JsonMappingException：根名稱與預期不匹配。

此異常在 JSON 與 Jackson 期望的格式不完全匹配時拋出。

例如，主 JSON 可能被包裹：

@Test(expected = JsonMappingException.class)
public void givenWrappedJsonString_whenDeserializing_thenException()
  throws IOException {
    String json = "{"user":{"id":1,"name":"John"}}";

    ObjectMapper mapper = new ObjectMapper();
    mapper.enable(DeserializationFeature.UNWRAP_ROOT_VALUE);

    mapper.reader().forType(User.class).readValue(json);
}

這是完整的異常:

com.fasterxml.jackson.databind.JsonMappingException:
Root name 'user' does not match expected ('User') for type
 [simple type, class org.baeldung.jackson.dtos.User]
 at [Source: {"user":{"id":1,"name":"John"}}; line: 1, column: 2]
   at c.f.j.d.JsonMappingException.from(JsonMappingException.java:148)

4.2. 解決方案

我們可以使用註解 @JsonRootName 來解決這個問題：

@JsonRootName(value = "user")
public class UserWithRoot {
    public int id;
    public String name;
}

當我們嘗試反序列化包裝後的JSON，它能夠正確地工作：

@Test
public void 
  givenWrappedJsonStringAndConfigureClass_whenDeserializing_thenCorrect() 
  throws IOException {
 
    String json = "{"user":{"id":1,"name":"John"}}";

    ObjectMapper mapper = new ObjectMapper();
    mapper.enable(DeserializationFeature.UNWRAP_ROOT_VALUE);

    UserWithRoot user = mapper.reader()
      .forType(UserWithRoot.class)
      .readValue(json);
    assertEquals("John", user.name);
}

5. <em JsonMappingException: No Serializer Found for Class

5.1. 問題

現在我們來查看 JsonMappingException：未找到序列化器異常。

當我們在嘗試序列化實例時，其屬性和它們的 getter 方法為私有時，會拋出此異常。

我們將嘗試序列化一個 UserWithPrivateFields：

public class UserWithPrivateFields {
    int id;
    String name;
}

當我們嘗試序列化 UserWithPrivateFields 實例時，會拋出 JsonMappingException: No Serializer Found for Class 異常：

@Test(expected = JsonMappingException.class)
public void givenClassWithPrivateFields_whenSerializing_thenException() 
  throws IOException {
    UserWithPrivateFields user = new UserWithPrivateFields(1, "John");

    ObjectMapper mapper = new ObjectMapper();
    mapper.writer().writeValueAsString(user);
}

以下是完整的異常信息：

com.fasterxml.jackson.databind.JsonMappingException: 
No serializer found for class org.baeldung.jackson.exception.UserWithPrivateFields
 and no properties discovered to create BeanSerializer 
(to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS) )
  at c.f.j.d.ser.impl.UnknownSerializer.failForEmpty(UnknownSerializer.java:59)

5.2. 解決方案

我們可以通過配置 ObjectMapper 的可見性來解決此問題：

@Test
public void givenClassWithPrivateFields_whenConfigureSerializing_thenCorrect() 
  throws IOException {
 
    UserWithPrivateFields user = new UserWithPrivateFields(1, "John");

    ObjectMapper mapper = new ObjectMapper();
    mapper.setVisibility(PropertyAccessor.FIELD, Visibility.ANY);

    String result = mapper.writer().writeValueAsString(user);
    assertThat(result, containsString("John"));
}

我們也可以使用註解 @JsonAutoDetect</em/>。

@JsonAutoDetect(fieldVisibility = Visibility.ANY)
public class UserWithPrivateFields { ... }

@Test(expected = JsonMappingException.class)
public void givenJsonOfArray_whenDeserializing_thenException() 
  throws JsonProcessingException, IOException {
 
    String json 
      = "[{"id":1,"name":"John"},{"id":2,"name":"Adam"}]";
    ObjectMapper mapper = new ObjectMapper();
    mapper.reader().forType(User.class).readValue(json);
}

com.fasterxml.jackson.databind.JsonMappingException:
Can not deserialize instance of 
  org.baeldung.jackson.dtos.User out of START_ARRAY token
  at [Source: [{"id":1,"name":"John"},{"id":2,"name":"Adam"}]; line: 1, column: 1]
  at c.f.j.d.JsonMappingException.from(JsonMappingException.java:148)

@Test
public void givenJsonOfArray_whenDeserializing_thenCorrect() 
  throws JsonProcessingException, IOException {
 
    String json
      = "[{"id":1,"name":"John"},{"id":2,"name":"Adam"}]";
   
    ObjectMapper mapper = new ObjectMapper();
    List<User> users = mapper.reader()
      .forType(new TypeReference<List<User>>() {})
      .readValue(json);

    assertEquals(2, users.size());
}

public class Person {

    private String firstName;
    private String lastName;
    private String contact;

    // standard getters and setters
}

{
    "firstName":"Azhrioun",
    "lastName":"Abderrahim",
    "contact":{
        "email":"[email protected]"
    }
}

<p>Jackson 失敗，堆棧跟蹤如下：</p>

Cannot deserialize value of type `java.lang.String` from Object value (token `JsonToken.START_OBJECT`)
 at [Source: (String)"{"firstName":"Azhrioun","lastName":"Abderrahim","contact":{"email":"[email protected]"}}"; line: 1, column: 59] (through reference chain: com.baeldung.exceptions.Person["contact"])
...

@Test
public void givenJsonObject_whenDeserializingIntoString_thenException() throws IOException {
    final String json = "{\"firstName\":\"Azhrioun\",\"lastName\":\"Abderrahim\",\"contact\":{\"email\":\"[email protected]\"}}";
    final ObjectMapper mapper = new ObjectMapper();

    Exception exception = assertThrows(JsonMappingException.class, () -> mapper.reader()
      .forType(Person.class)
      .readValue(json));

    assertTrue(exception.getMessage()
      .contains("Cannot deserialize value of type `java.lang.String` from Object value (token `JsonToken.START_OBJECT`)"));
}

public class Contact {

    private String email;

    // standard getter and setter
}

public class PersonContact {

    private String firstName;
    private String lastName;
    private Contact contact;
 
    // standard getters and setters
}

@Test
public void givenJsonObject_whenDeserializingIntoObject_thenDeserialize() throws IOException {
    final String json = "{\"firstName\":\"Azhrioun\",\"lastName\":\"Abderrahim\",\"contact\":{\"email\":\"[email protected]\"}}";
    final ObjectMapper mapper = new ObjectMapper();

    PersonContact person = mapper.reader()
      .forType(PersonContact.class)
      .readValue(json);

    assertEquals("[email protected]", person.getContact().getEmail());
}

8. <em 多次未識別屬性異常>

8.1. 問題

現在我們來看一下 UnrecognizedPropertyException。

此異常在從 JSON 字符串中反序列化時，如果 JSON 字符串中存在未知的屬性，則會拋出。

我們將嘗試反序列化包含額外屬性“checked”的 JSON 字符串：

@Test(expected = UnrecognizedPropertyException.class)
public void givenJsonStringWithExtra_whenDeserializing_thenException() 
  throws IOException {
 
    String json = "{"id":1,"name":"John", "checked":true}";

    ObjectMapper mapper = new ObjectMapper();
    mapper.reader().forType(User.class).readValue(json);
}

這是完整的異常:

com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException:
Unrecognized field "checked" (class org.baeldung.jackson.dtos.User),
 not marked as ignorable (2 known properties: "id", "name"])
 at [Source: {"id":1,"name":"John", "checked":true}; line: 1, column: 38]
 (through reference chain: org.baeldung.jackson.dtos.User["checked"])
  at c.f.j.d.exc.UnrecognizedPropertyException.from(
    UnrecognizedPropertyException.java:51)

8.2. 解決方案

我們可以通過配置 ObjectMapper 來解決此問題。

@Test
public void givenJsonStringWithExtra_whenConfigureDeserializing_thenCorrect() 
  throws IOException {
 
    String json = "{"id":1,"name":"John", "checked":true}";

    ObjectMapper mapper = new ObjectMapper();
    mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

    User user = mapper.reader().forType(User.class).readValue(json);
    assertEquals("John", user.name);
}

我們也可以使用註解 @JsonIgnoreProperties：

@JsonIgnoreProperties(ignoreUnknown = true)
public class User {...}

9. <em JsonParseException: 意外字符 (”’ (代碼 39))

9.1. 問題描述

接下來，我們討論一下 JsonParseException: 意外字符 (”’ (代碼 39)) 異常。

此異常在 被反序列化的 JSON 字符串中包含單引號，而不是雙引號時 拋出。

我們將嘗試反序列化包含單引號的 JSON 字符串：

@Test(expected = JsonParseException.class)
public void givenStringWithSingleQuotes_whenDeserializing_thenException() 
  throws JsonProcessingException, IOException {
 
    String json = "{'id':1,'name':'John'}";
    ObjectMapper mapper = new ObjectMapper();

    mapper.reader()
      .forType(User.class).readValue(json);
}

以下是完整的異常：

com.fasterxml.jackson.core.JsonParseException:
Unexpected character (''' (code 39)): 
  was expecting double-quote to start field name
  at [Source: {'id':1,'name':'John'}; line: 1, column: 3]
  at c.f.j.core.JsonParser._constructError(JsonParser.java:1419)

9.2. 解決方案

我們可以通過配置 ObjectMapper 以允許使用單引號來解決這個問題：

@Test
public void 
  givenStringWithSingleQuotes_whenConfigureDeserializing_thenCorrect() 
  throws JsonProcessingException, IOException {
 
    String json = "{'id':1,'name':'John'}";

    JsonFactory factory = new JsonFactory();
    factory.enable(JsonParser.Feature.ALLOW_SINGLE_QUOTES);
    ObjectMapper mapper = new ObjectMapper(factory);

    User user = mapper.reader().forType(User.class)
      .readValue(json);
 
    assertEquals("John", user.name);
}

10. <em JsonParseException</em>: 意外字符 (‘c’ (code n))

本節將討論另一個常見的解析異常，<em JsonParseException</em>: 意外字符 (‘c’ (code n))。當 JSON 解析器在解析過程中遇到意外字符時，此異常會發生。`異常消息中指示的特定意外字符（<em ‘c’）和其 Unicode 碼點（<em ‘n’）。

10.1. 問題

JsonParseException: 意外字符（‘c’ (代碼 n)) 異常通常由於解析的 JSON 字符串中的語法錯誤或無效字符引起的。這些錯誤可能源於各種問題，例如缺少逗號、JSON 對象或數組的嵌套錯誤，或 JSON 語法中不允許的字符。

讓我們嘗試反序列化一個缺少“name”字段雙引號的 JSON 字符串：

@Test(expected = JsonParseException.class)
public void givenInvalidJsonString_whenDeserializing_thenException() throws JsonProcessingException, IOException {
    String json = "{\"id\":1, name:\"John\"}"; // Missing double quotes around 'name'
    ObjectMapper mapper = new ObjectMapper();
    mapper.reader().forType(User.class).readValue(json);
}

以下是完整的異常信息:

com.fasterxml.jackson.core.JsonParseException: Unexpected character ('n' (code 110)): 
was expecting double-quote to start field name
at [Source: (String)"{"id":1, name:"John"}"; line: 1, column: 11]
at com.fasterxml.jackson.core.JsonParser._constructError(JsonParser.java:2477)

10.2. 解決方案

為了解決 <em >JsonParseException: Unexpected character (‘c’ (code n))</em > 異常，務必仔細檢查 JSON 字符串是否存在語法錯誤，並確保其符合 JSON 規範。

常見的解決方案包括修正語法錯誤，例如缺失或位置不正確的逗號，確保對象和數組的正確嵌套，以及移除 JSON 語法中不允許的任何字符。

11. MismatchedInputException: 無法反序列化實例

MismatchedInputException 異常有不同的變體。它可能發生在未為 POJO 類提供默認構造函數，或者未使用 @JsonProperty 註解對不可變字段的構造函數參數進行標註時。

此外，當將不兼容的 JSON 數組反序列化為 Java 對象時，也可能導致此異常。

11.1. 問題：缺少默認構造函數

當嘗試將 JSON 字符串反序列化為沒有默認構造函數或無參數構造函數的 POJO 類時，會發生此異常。 由於 Jackson 需要實例化目標類，因此缺少默認構造函數會導致異常。

為了演示此異常，讓我們創建一個名為 Book 的類：

class Book {
    private int id;
    private String title;  
    
    public Book(int id, String title) {
        this.id = id;
        this.title = title; 
    }  
    // getters and setters
}

在這裏，我們創建一個不包含默認構造函數的POJO類。

接下來，讓我們將JSON字符串映射到POJO類中：

@Test
void givenJsonString_whenDeserializingToBook_thenIdIsCorrect() throws JsonProcessingException {
    String jsonString = "{\"id\":\"10\",\"title\":\"Harry Potter\"}";
    ObjectMapper mapper = new ObjectMapper();
    Book book = mapper.readValue(jsonString, Book.class);
    assertEquals(book.getId(),10);
}

上述測試 拋出了 ：

com.fasterxml.jackson.databind.exc.InvalidDefinitionException: 
Cannot construct instance of `com.baeldung.mismatchedinputexception.Book` (no Creators, like default constructor, exist): cannot deserialize from Object value (no delegate- or property-based Creator)
at [Source: (String)"{"id":"10","title":"Harry Potter"}"; line: 1, column: 2]

// ...   
public Book() {
}
// ...

class Animals {
    private final int id;
    private String name;
    
    public Animals(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

@Test
void givenJsonString_whenDeserializingToJavaObjectWithImmutableField_thenIdIsCorrect() throws JsonProcessingException {
    String jsonString = "{\"id\":10,\"name\":\"Dog\"}";
    ObjectMapper mapper = new ObjectMapper();
    Animals animal = mapper.readValue(jsonString, Animals.class);
    assertEquals(animal.getId(),10);
}

com.fasterxml.jackson.databind.exc.InvalidDefinitionException: 
Cannot construct instance of `com.baeldung.mismatchedinputexception.Animals` (no Creators, like default constructor, exist): cannot deserialize from Object value (no delegate- or property-based Creator)
at [Source: (String)"{"id":10,"name":"Dog"}"; line: 1, column: 2]

Animals(@JsonProperty("id") int id, @JsonProperty("name") String name) {
   this.id = id;
   this.name = name;
}

@Test
void givenJsonString_whenDeserializingToBookList_thenTitleIsCorrect() throws JsonProcessingException {
    String jsonString = "[{\"id\":\"10\",\"title\":\"Harry Potter\"}]";
    ObjectMapper mapper = new ObjectMapper();
    Book book = mapper.readValue(jsonString, Book.class);
    assertEquals(book.getTitle(),"Harry Potter");
}

com.fasterxml.jackson.databind.exc.MismatchedInputException: 
Cannot deserialize value of type `com.baeldung.mismatchedinputexception.Book` from Array value (token `JsonToken.START_ARRAY`)
at [Source: (String)"[{"id":"10","title":"Harry Potter"}]"; line: 1, column: 1]

@Test
void givenJsonString_whenDeserializingToBookList_thenTitleIsCorrect() throws JsonProcessingException {
    String jsonString = "[{\"id\":\"10\",\"title\":\"Harry Potter\"}]";
    ObjectMapper mapper = new ObjectMapper();
    List<Book> book = mapper.readValue(jsonString, new TypeReference<List<Book>>(){});
    assertEquals(book.get(0).getTitle(),"Harry Potter");
}

java.lang.NoSuchMethodError:
com.fasterxml.jackson.core.JsonParser.getValueAsString()Ljava/lang/String;
 at c.f.j.d.deser.std.StringDeserializer.deserialize(StringDeserializer.java:24)