Home » Java » Jackson with JSON: Unrecognized field, not marked as ignorable

Jackson with JSON: Unrecognized field, not marked as ignorable

Posted by: admin November 2, 2017 Leave a comment

Questions:

I need to convert a certain JSON string to a Java object. I am using Jackson for JSON handling. I have no control over the input JSON (I read from a web service). This is my input JSON:

{"wrapper":[{"id":"13","name":"Fred"}]}

Here is a simplified use case:

private void tryReading() {
    String jsonStr = "{\"wrapper\"\:[{\"id\":\"13\",\"name\":\"Fred\"}]}";
    ObjectMapper mapper = new ObjectMapper();  
    Wrapper wrapper = null;
    try {
        wrapper = mapper.readValue(jsonStr , Wrapper.class);
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("wrapper = " + wrapper);
}

My entity class is:

public Class Student { 
    private String name;
    private String id;
    //getters & setters for name & id here
}

My Wrapper class is basically a container object to get my list of students:

public Class Wrapper {
    private List<Student> students;
    //getters & setters here
}

I keep getting this error and “wrapper” returns null. I am not sure what’s missing. Can someone help please?

org.codehaus.jackson.map.exc.UnrecognizedPropertyException: 
    Unrecognized field "wrapper" (Class Wrapper), not marked as ignorable
 at [Source: [email protected]; line: 1, column: 13] 
    (through reference chain: Wrapper["wrapper"])
 at org.codehaus.jackson.map.exc.UnrecognizedPropertyException
    .from(UnrecognizedPropertyException.java:53)
Answers:

You can use Jackson’s class-level annotation:

@JsonIgnoreProperties

It will ignore every property you haven’t defined in your POJO. Very useful when you are just looking for a couple of properties in the JSON and don’t want to write the whole mapping. More info at Jackson’s website. If you want to ignore any non declared property, you should write:

@JsonIgnoreProperties(ignoreUnknown = true)

Questions:
Answers:

You can use

ObjectMapper objectMapper = getObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

It will ignore all the properties that are not declared.

Questions:
Answers:

The first answer is almost correct, but what is needed is to change getter method, NOT field — field is private (and not auto-detected); further, getters have precedence over fields if both are visible.
(there are ways to make private fields visible, too, but if you want to have getter there’s not much point)

So getter should either be named “getWrapper()”, or annotated with:

@JsonProperty("wrapper")

if you prefer getter method name as is.

Questions:
Answers:

This just perfectly worked for me

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(
    DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);

@JsonIgnoreProperties(ignoreUnknown = true) annotation did not.

Questions:
Answers:

This works better than All please refer to this property.

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    projectVO = objectMapper.readValue(yourjsonstring, Test.class);

Questions:
Answers:

using Jackson 2.6.0, this worked for me:

private static final ObjectMapper objectMapper = 
    new ObjectMapper()
        .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

and with setting:

@JsonIgnoreProperties(ignoreUnknown = true)

Questions:
Answers:

If you are using Jackson 2.0

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

Questions:
Answers:

it can be achieved 2 ways:

  1. Mark the POJO to ignore unknown properties

    @JsonIgnoreProperties(ignoreUnknown = true)
    
  2. Configure ObjectMapper that serializes/De-serializes the POJO/json as below:

    ObjectMapper mapper =new ObjectMapper();            
    // for Jackson version 1.X        
    mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    // for Jackson version 2.X
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false) 
    
Questions:
Answers:

It worked for me with the following code:

ObjectMapper mapper =new ObjectMapper();    
mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);

Questions:
Answers:

According to the doc you can ignore selected fields or all uknown fields:

 // to prevent specified fields from being serialized or deserialized
 // (i.e. not include in JSON output; or being set even if they were included)
 @JsonIgnoreProperties({ "internalId", "secretKey" })

 // To ignore any unknown properties in JSON input without exception:
 @JsonIgnoreProperties(ignoreUnknown=true)

Questions:
Answers:

Jackson is complaining because it can’t find a field in your class Wrapper that’s called “wrapper”. It’s doing this because your JSON object has a property called “wrapper”.

I think the fix is to rename your Wrapper class’s field to “wrapper” instead of “students”.

Questions:
Answers:

I have tried the below method and it works for such JSON format reading with Jackson.
Use the already suggested solution of: annotating getter with @JsonProperty("wrapper")

Your wrapper class

public Class Wrapper{ 
  private List<Student> students;
  //getters & setters here 
} 

My Suggestion of wrapper class

public Class Wrapper{ 

  private StudentHelper students; 

  //getters & setters here 
  // Annotate getter
  @JsonProperty("wrapper")
  StudentHelper getStudents() {
    return students;
  }  
} 


public class StudentHelper {

  @JsonProperty("Student")
  public List<Student> students; 

  //CTOR, getters and setters
  //NOTE: If students is private annotate getter with the annotation @JsonProperty("Student")
}

This would however give you the output of the format:

{"wrapper":{"student":[{"id":13,"name":Fred}]}}

Also for more information refer to https://github.com/FasterXML/jackson-annotations

Hope this helps

Questions:
Answers:

This solution is generic when reading json streams and need to get only some fields while fields not mapped correctly in your Domain Classes can be ignored:

import org.codehaus.jackson.annotate.JsonIgnoreProperties;
@JsonIgnoreProperties(ignoreUnknown = true)

A detailed solution would be to use a tool such as jsonschema2pojo to autogenerate the required Domain Classes such as Student from the Schema of the json Response. You can do the latter by any online json to schema converter.

Questions:
Answers:

As no one else has mentioned, thought I would…

Problem is your property in your JSON is called “wrapper” and your property in Wrapper.class is called “students”.

So either…

  1. Correct the name of the property in either the class or JSON.
  2. Annotate your property variable as per StaxMan’s comment.
  3. Annotate the setter (if you have one)
Questions:
Answers:

Annotate the field students as below since there is mismatch in names of json property and java property

public Class Wrapper {
    @JsonProperty("wrapper")
    private List<Student> students;
    //getters & setters here
}

Questions:
Answers:

Your input

{"wrapper":[{"id":"13","name":"Fred"}]}

indicates that it is an Object, with a field named “wrapper”, which is a Collection of Students. So my recommendation would be,

Wrapper = mapper.readValue(jsonStr , Wrapper.class);

where Wrapper is defined as

class Wrapper {
    List<Student> wrapper;
}

Questions:
Answers:

For my part, the only line

@JsonIgnoreProperties(ignoreUnknown = true)

didn’t work too.

Just add

@JsonInclude(Include.NON_EMPTY)

Jackson 2.4.0

Questions:
Answers:

This worked perfectly for me

objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

Questions:
Answers:

What worked for me, was to make the property public. It solved the problem for me.

Questions:
Answers:

Either Change

public Class Wrapper {
    private List<Student> students;
    //getters & setters here
}

to

public Class Wrapper {
    private List<Student> wrapper;
    //getters & setters here
}

—- or —-

Change your JSON string to

{"students":[{"id":"13","name":"Fred"}]}

Questions:
Answers:

I fixed this problem by simply changing the signatures of my setter and getter methods of my POJO class. All I had to do was change the getObject method to match what the mapper was looking for. In my case I had a getImageUrl originally, but the JSON data had image_url which was throwing the mapper off. I changed both my setter and getters to getImage_url and setImage_url.

Hope this helps.

Questions:
Answers:

The POJO should be defined as

Response class

public class Response {
    private List<Wrapper> wrappers;
    // getter and setter
}

Wrapper class

public class Wrapper {
    private String id;
    private String name;
    // getters and setters
}

and mapper to read value

Response response = mapper.readValue(jsonStr , Response.class);

Questions:
Answers:

The new Firebase Android introduced some huge changes ; below the copy of the doc :

[https://firebase.google.com/support/guides/firebase-android] :

Update your Java model objects

As with the 2.x SDK, Firebase Database will automatically convert Java objects that you pass to DatabaseReference.setValue() into JSON and can read JSON into Java objects using DataSnapshot.getValue().

In the new SDK, when reading JSON into a Java object with DataSnapshot.getValue(), unknown properties in the JSON are now ignored by default so you no longer need @JsonIgnoreExtraProperties(ignoreUnknown=true).

To exclude fields/getters when writing a Java object to JSON, the annotation is now called @Exclude instead of @JsonIgnore.

BEFORE

@JsonIgnoreExtraProperties(ignoreUnknown=true)
public class ChatMessage {
   public String name;
   public String message;
   @JsonIgnore
   public String ignoreThisField;
}

dataSnapshot.getValue(ChatMessage.class)

AFTER

public class ChatMessage {
   public String name;
   public String message;
   @Exclude
   public String ignoreThisField;

}

dataSnapshot.getValue(ChatMessage.class)

If there is an extra property in your JSON that is not in your Java class, you will see this warning in the log files:

W/ClassMapper: No setter/field for ignoreThisProperty found on class com.firebase.migrationguide.ChatMessage

You can get rid of this warning by putting an @IgnoreExtraProperties annotation on your class. If you want Firebase Database to behave as it did in the 2.x SDK and throw an exception if there are unknown properties, you can put a @ThrowOnExtraProperties annotation on your class.

Questions:
Answers:

This may be a very late response, but just changing the POJO to this should solve the json string provided in the problem (since, the input string is not in your control as you said):

public class Wrapper {
    private List<Student> wrapper;
    //getters & setters here
}

Questions:
Answers:

You should just change the field of List from “students” to “wrapper” just the json file and the mapper will look it up.

Questions:
Answers:

In my case it was simple: the REST-service JSON Object was updated (a property was added), but the REST-client JSON Object wasn’t. As soon as i’ve updated JSON client object the ‘Unrecognized field …’ exception has vanished.

Questions:
Answers:

Your json string is not inline with the mapped class.
Change the input string

String jsonStr = "{\"students\"\:[{\"id\":\"13\",\"name\":\"Fred\"}]}";

Or change your mapped class

public class Wrapper {
    private List<Student> wrapper;
    //getters & setters here
}

Questions:
Answers:

You need to verify all fields of the class you are parsing in, make it the same as in your original JSONObject. It helped me and in my case.

@JsonIgnoreProperties(ignoreUnknown = true) didn’t help at all.

Questions:
Answers:

I was created public field, worked for me. In your case like below :

public Class Student { 
public String name;
public String id;

}