Jackson with JSON: Unrecognized field, not marked as ignorable
JavaJsonData BindingJacksonJava Problem Overview
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: java.io.StringReader@1198891; line: 1, column: 13]
(through reference chain: Wrapper["wrapper"])
at org.codehaus.jackson.map.exc.UnrecognizedPropertyException
.from(UnrecognizedPropertyException.java:53)
Java Solutions
Solution 1 - Java
You can use Jackson's class-level annotation:
import com.fasterxml.jackson.annotation.JsonIgnoreProperties
@JsonIgnoreProperties
class { ... }
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)
Solution 2 - Java
You can use
ObjectMapper objectMapper = getObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
It will ignore all the properties that are not declared.
Solution 3 - Java
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.
Solution 4 - Java
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)
Solution 5 - Java
it can be achieved 2 ways:
-
Mark the POJO to ignore unknown properties
@JsonIgnoreProperties(ignoreUnknown = true)
-
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)
Solution 6 - Java
Adding setters and getters solved the problem, what I felt is the actual issue was how to solve it but not how to suppress/ignore the error. I got the error "Unrecognized field.. not marked as ignorable.."
Though I use the below annotation on top of the class it was not able to parse the json object and give me the input
> @JsonIgnoreProperties(ignoreUnknown = true)
Then I realized that I did not add setters and getters, after adding setters and getters to the "Wrapper" and to the "Student" it worked like a charm.
Solution 7 - Java
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.
Solution 8 - Java
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);
Solution 9 - Java
If you are using Jackson 2.0
ObjectMapper mapper = new ObjectMapper();
mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
Solution 10 - Java
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)
Solution 11 - Java
It worked for me with the following code:
ObjectMapper mapper =new ObjectMapper();
mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
Solution 12 - Java
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
Solution 13 - Java
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".
Solution 14 - Java
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.
Solution 15 - Java
If you want to apply @JsonIgnoreProperties
to all class in you application then the best way it is override Spring boot default jackson object.
In you application config file define a bean to create jackson object mapper like this.
@Bean
public ObjectMapper getObjectMapper() {
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
return mapper;
}
Now, you don't need to mark every class and it will ignore all unknown properties.
Solution 16 - Java
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
}
Solution 17 - Java
Problem is your property in your JSON is called "wrapper" and your property in Wrapper.class is called "students".
So either...
- Correct the name of the property in either the class or JSON.
- Annotate your property variable as per StaxMan's comment.
- Annotate the setter (if you have one)
Solution 18 - Java
What worked for me, was to make the property public.
Solution 19 - Java
Somehow after 45 posts and 10 years, no one has posted the correct answer for my case.
@Data //Lombok
public class MyClass {
private int foo;
private int bar;
@JsonIgnore
public int getFoobar() {
return foo + bar;
}
}
In my case, we have a method called getFoobar()
, but no foobar
property (because it's computed from other properties). @JsonIgnoreProperties
on the class does not work.
The solution is to annotate the method with @JsonIgnore
Solution 20 - Java
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"}]}
Solution 21 - Java
One other possibility is this property in the application.properties
spring.jackson.deserialization.fail-on-unknown-properties=false
, which won't need any other code change in your application. And when you believe the contract is stable, you can remove this property or mark it true.
Solution 22 - Java
For my part, the only line
@JsonIgnoreProperties(ignoreUnknown = true)
didn't work too.
Just add
@JsonInclude(Include.NON_EMPTY)
Jackson 2.4.0
Solution 23 - Java
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.
Solution 24 - Java
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;
}
Solution 25 - Java
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.
Solution 26 - Java
set public your class fields not private.
public Class Student {
public String name;
public String id;
//getters & setters for name & id here
}
Solution 27 - Java
This may not be the same problem that the OP had but in case someone got here with the same mistake I had then this will help them solve their problem. I got the same error as the OP when I used an ObjectMapper from a different dependency as the JsonProperty annotation.
This works:
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.annotation.JsonProperty;
Does NOT work:
import org.codehaus.jackson.map.ObjectMapper; //org.codehaus.jackson:jackson-mapper-asl:1.8.8
import com.fasterxml.jackson.annotation.JsonProperty; //com.fasterxml.jackson.core:jackson-databind:2.2.3
Solution 28 - Java
If for some reason you cannot add the @JsonIgnoreProperties annotations to your class and you are inside a web server/container such as Jetty. You can create and customize the ObjectMapper inside a custom provider
import javax.ws.rs.ext.ContextResolver;
import javax.ws.rs.ext.Provider;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
@Provider
public class CustomObjectMapperProvider implements ContextResolver<ObjectMapper> {
private ObjectMapper objectMapper;
@Override
public ObjectMapper getContext(final Class<?> cls) {
return getObjectMapper();
}
private synchronized ObjectMapper getObjectMapper() {
if(objectMapper == null) {
objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}
return objectMapper;
}
}
Solution 29 - Java
This worked perfectly for me
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
Solution 30 - Java
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);
Solution 31 - Java
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
}
Solution 32 - Java
FAIL_ON_UNKNOWN_PROPERTIES option is true by default:
FAIL_ON_UNKNOWN_PROPERTIES (default: true)
Used to control whether encountering of unknown properties (one for which there is no setter; and there is no fallback "any setter" method defined using @JsonAnySetter annotation) should result in a JsonMappingException (when enabled), or just quietly ignored (when disabled)
Solution 33 - Java
Google brought me here and i was surprised to see the answers... all suggested bypassing the error ( which always bites back 4 folds later in developement ) rather than solving it until this gentleman restored by faith in SO!
objectMapper.readValue(responseBody, TargetClass.class)
is used to convert a json String to an class object, whats missing is that the TargetClass
should have public get
ter / set
ters. Same is missing in OP's question snippet too! :)
via lombok your class as below should work!!
@Data
@Builder
public class TargetClass {
private String a;
}
Solution 34 - Java
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
@JsonIgnoreProperties
Solution 35 - Java
When we are generating getters and setters, specially which starts with 'is' keyword, IDE generally removes the 'is'. e.g.
private boolean isActive;
public void setActive(boolean active) {
isActive = active;
}
public isActive(){
return isActive;
}
In my case, i just changed the getter and setter.
private boolean isActive;
public void setIsActive(boolean active) {
isActive = active;
}
public getIsActive(){
return isActive;
}
And it was able to recognize the field.
Solution 36 - Java
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.
Solution 37 - Java
In my case a I have to add public getters and setters to leave fields private.
ObjectMapper mapper = new ObjectMapper();
Application application = mapper.readValue(input, Application.class);
I use jackson-databind 2.10.0.pr3 .
Solution 38 - Java
The shortest solution without setter/getter is to add @JsonProperty
to a class field:
public class Wrapper {
@JsonProperty
private List<Student> wrapper;
}
public class Student {
@JsonProperty
private String name;
@JsonProperty
private String id;
}
Also, you called students list "wrapper" in your json, so Jackson expects a class with a field called "wrapper".
Solution 39 - Java
Just in case anyone else is using force-rest-api like me, here is how I used this discussion to solve it (Kotlin):
var result = forceApi.getSObject("Account", "idhere")
result.jsonMapper.configure( DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
val account: Account = result.`as`(Account::class.java)
It looks like force-rest-api is using an old version of jackson's.
Solution 40 - Java
You should just change the field of List
Solution 41 - Java
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
}
Solution 42 - Java
In my case error came due to following reason
-
Initially it was working fine,then i renamed one variable,made the changes in code and it gave me this error.
-
Then i applied jackson ignorant property also but it did not work.
-
Finally after re defining my getters and setters methods according to name of my variable this error was resolved
So make sure to redifine getters and setters also.
Solution 43 - Java
Change Wrapper class to
public Class Wrapper {
@JsonProperty("wrapper") // add this line
private List<Student> students;
}
What this does is to recognise the students
field as wrapper
key of the json object.
Also I personally prefer using Lombok Annotations for Getters and Setters as
@Getter
@Setter
public Class Wrapper {
@JsonProperty("wrapper") // add this line
private List<Student> students;
}
Since I have not tested the above code with Lombok and @JsonProperty
together, I'll suggest you to add the following code to Wrapper class as well to override Lombok's default getter and setter.
public List<Student> getWrapper(){
return students;
}
public void setWrapper(List<Student> students){
this.students = students;
}
Also check this out to deserialise lists using Jackson.
Solution 44 - Java
As per this documentation, you can use the Jackson2ObjectMapperBuilder to build your ObjectMapper:
@Autowired
Jackson2ObjectMapperBuilder objectBuilder;
ObjectMapper mapper = objectBuilder.build();
String json = "{\"id\": 1001}";
By default, Jackson2ObjectMapperBuilder disables the error unrecognizedpropertyexception.
Solution 45 - Java
Json field:
"blog_host_url": "some.site.com"
Kotlin field
var blogHostUrl: String = "https://google.com"
In my case i needed just to use @JsonProperty
annotation in my dataClass.
Example:
data class DataBlogModel(
@JsonProperty("blog_host_url") var blogHostUrl: String = "https://google.com"
)
Here's article: https://www.baeldung.com/jackson-name-of-property
Solution 46 - Java
ObjectMapper objectMapper = new ObjectMapper()
.configure(DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT, true);
Solution 47 - Java
I ran into this once when my JSON payload included a property that was not recognised by the API. The solution was to rename/remove the offending property.
Solution 48 - Java
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.