
Jackson - Serialization Annotations
- Jackson - @JsonAnyGetter
- Jackson - @JsonGetter
- Jackson - @JsonPropertyOrder
- Jackson - @JsonRawValue
- Jackson - @JsonValue
- Jackson - @JsonRootName
- Jackson - @JsonSerialize
Jackson - Deserialization Annotations
- Jackson - @JsonCreator
- Jackson - @JacksonInject
- Jackson - @JsonAnySetter
- Jackson - @JsonSetter
- Jackson - @JsonDeserialize
- Jackson - @JsonEnumDefaultValue
Jackson - Property Inclusion Annotations
- Jackson - @JsonIgnoreProperties
- Jackson - @JsonIgnore
- Jackson - @JsonIgnoreType
- Jackson - @JsonInclude
- Jackson - @JsonAutoDetect
Jackson - Type Handling Annotations
Jackson - General Annotations
- Jackson - @JsonProperty
- Jackson - @JsonFormat
- Jackson - @JsonUnwrapped
- Jackson - @JsonView
- Jackson - @JsonManagedReference
- Jackson - @JsonBackReference
- Jackson - @JsonIdentityInfo
- Jackson - @JsonFilter
Jackson - Miscellaneous
Jackson - Resources
Jackson Annotations - Quick Guide
Jackson Annotations - Environment Setup
This chapter will guide you on how to prepare a development environment to start your work with Jackson Annotations. It will also teach you how to set up JDK on your machine before you set up GSON −
Setup Java Development Kit (JDK)
You can download the latest version of SDK from Oracle's Java site − Java SE Downloads. You will find instructions for installing JDK in downloaded files, follow the given instructions to install and configure the setup. Finally set PATH and JAVA_HOME environment variables to refer to the directory that contains java and javac, typically java_install_dir/bin and java_install_dir respectively.
If you are running Windows and have installed the JDK in C:\jdk-24, you would have to put the following line in your C:\autoexec.bat file.
set PATH=C:\jdk-24;%PATH% set JAVA_HOME=C:\jdk-24
Alternatively, on Windows NT/2000/XP, you will have to right-click on My Computer, select Properties → Advanced → Environment Variables. Then, you will have to update the PATH value and click the OK button.
On Unix (Solaris, Linux, etc.), if the SDK is installed in /usr/local/jdk-24 and you use the C shell, you will have to put the following into your .cshrc file.
setenv PATH /usr/local/jdk-24/bin:$PATH setenv JAVA_HOME /usr/local/jdk-24
Alternatively, if you use an Integrated Development Environment (IDE) like Borland JBuilder, Eclipse, IntelliJ IDEA, or Sun ONE Studio, you will have to compile and run a simple program to confirm that the IDE knows where you have installed Java. Otherwise, you will have to carry out a proper setup as given in the document of the IDE.
Popular Java Editors
To write your Java programs, you need a text editor. There are many sophisticated IDEs available in the market. But for now, you can consider one of the following −
Notepad − On Windows machine, you can use any simple text editor like Notepad (Recommended for this tutorial), TextPad.
Netbeans − It is a Java IDE that is open-source and free, which can be downloaded from www.netbeans.org/index.html.
Eclipse − It is also a Java IDE developed by the eclipse open-source community and can be downloaded from www.eclipse.org.
Jackson Environment
Download the latest version of jackson and related jar files.
At the time of writing this tutorial, we have copied them into C:\>Jackson folder.
OS | Archive name |
---|---|
Windows | jackson-core-2.20.0-rc1.jar;jackson-databind-2.20.0-rc1.jar;jackson-annotations-3.0-rc5.jar |
Linux | jackson-core-2.20.0-rc1.jar;jackson-databind-2.20.0-rc1.jar;jackson-annotations-3.0-rc5.jar |
Mac | jackson-core-2.20.0-rc1.jar;jackson-databind-2.20.0-rc1.jar;jackson-annotations-3.0-rc5.jar |
Set CLASSPATH Variable
Set the CLASSPATH environment variable to point to the Guice jar location. Assuming, you have stored Guice and related jars in Jackson folder on various Operating Systems as follows.
OS | Output |
---|---|
Windows | Set the environment variable CLASSPATH to %CLASSPATH%;C:\Jackson\jackson-core-2.20.0-rc1.jar;C:\Jackson\jackson-databind-2.20.0-rc1.jar;C:\Jackson\jackson-annotations-3.0-rc5.jar; |
Linux | export CLASSPATH=$CLASSPATH:Jackson/jackson-core-2.20.0-rc1.jar:Jackson/jackson-databind-2.20.0-rc1.jar:Jackson/jackson-annotations-3.0-rc5.jar:. |
Mac | export CLASSPATH=$CLASSPATH:Jackson/jackson-core-2.20.0-rc1.jar:Jackson/jackson-databind-2.20.0-rc1.jar:Jackson/jackson-annotations-3.0-rc5:. |
Jackson Annotations - @JsonAnyGetter
Overview
@JsonAnyGetter annotation allows a getter method to return Map which is then used to serialize the additional properties of JSON in the similar fashion as other properties.
Example - Serialization without using @JsonAnyGetter
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.util.HashMap; import java.util.Map; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try{ Student student = new Student(); student.add("Name", "Mark"); student.add("RollNo", "1"); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { private Map<String, String> properties; public Student(){ properties = new HashMap<>(); } public Map<String, String> getProperties(){ return properties; } public void add(String property, String value){ properties.put(property, value); } }
Output
Run the JacksonTester and verify the output −
{ "properties" : { "RollNo" : "1", "Name" : "Mark" } }
Example - Serialization with @JsonAnyGetter
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.util.HashMap; import java.util.Map; import com.fasterxml.jackson.annotation.JsonAnyGetter; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try{ Student student = new Student(); student.add("Name", "Mark"); student.add("RollNo", "1"); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { private Map<String, String> properties; public Student(){ properties = new HashMap<>(); } @JsonAnyGetter public Map<String, String> getProperties(){ return properties; } public void add(String property, String value){ properties.put(property, value); } }
Output
Run the JacksonTester and verify the output −
{ "RollNo" : "1", "Name" : "Mark" }
Here we're utilizing the @JsonAnyGetter to treat the properties map to act as other properties of the object.
Jackson Annotations - @JsonGetter
Overview
@JsonAnyGetter annotation allows a specific method to be marked as getter method.
Example - Serialization without using @JsonGetter
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try { Student student = new Student("Mark", 1); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { private String name; private int rollNo; public Student(String name, int rollNo){ this.name = name; this.rollNo = rollNo; } public String getStudentName(){ return name; } public int getRollNo(){ return rollNo; } }
Output
Run the JacksonTester and verify the output −
{ "rollNo" : 1, "studentName" : "Mark" }
Example - Serialization with @JsonGetter
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.annotation.JsonGetter; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try { Student student = new Student("Mark", 1); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { private String name; private int rollNo; public Student(String name, int rollNo){ this.name = name; this.rollNo = rollNo; } @JsonGetter public String getStudentName(){ return name; } public int getRollNo(){ return rollNo; } }
Output
Run the JacksonTester and verify the output −
{ "rollNo" : 1, "studentName" : "Mark" }
Here we can see Jackson by default picks the getter of the Object. In case, we need to provide a custom getter method, we can use @JsonGetter annotation.
Jackson Annotations - @JsonPropertyOrder
Overview
@JsonPropertyOrder annotation allows a specific order to be preserved while serializing a JSON object.
Example - Serialization without using @JsonPropertyOrder
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try { Student student = new Student("Mark", 1); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { private String name; private int rollNo; public Student(String name, int rollNo) { this.name = name; this.rollNo = rollNo; } public String getName(){ return name; } public int getRollNo(){ return rollNo; } }
Output
Run the JacksonTester and verify the output −
{ "name" : "Mark", "rollNo" : 1 }
Example - Serialization with @JsonPropertyOrder
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.annotation.JsonPropertyOrder; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try { Student student = new Student("Mark", 1); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } @JsonPropertyOrder({ "rollNo", "name" }) class Student { private String name; private int rollNo; public Student(String name, int rollNo){ this.name = name; this.rollNo = rollNo; } public String getName(){ return name; } public int getRollNo(){ return rollNo; } }
Output
Run the JacksonTester and verify the output −
{ "rollNo" : 1, "name" : "Mark" }
Jackson Annotations - @JsonRawValue
Overview
@JsonRawValue annotation allows to serialize a text without escaping or without any decoration.
Example - Serialization without using @JsonRawValue
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try { Student student = new Student("Mark", 1, "{\"attr\":false}"); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { private String name; private int rollNo; private String json; public Student(String name, int rollNo, String json){ this.name = name; this.rollNo = rollNo; this.json = json; } public String getName(){ return name; } public int getRollNo(){ return rollNo; } public String getJson(){ return json; } }
Output
Run the JacksonTester and verify the output −
{ "name" : "Mark", "rollNo" : 1, "json" : {\"attr\":false} }
Example - Serialization with @JsonRawValue
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.annotation.JsonRawValue; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try { Student student = new Student("Mark", 1, "{\"attr\":false}"); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { private String name; private int rollNo; @JsonRawValue private String json; public Student(String name, int rollNo, String json) { this.name = name; this.rollNo = rollNo; this.json = json; } public String getName(){ return name; } public int getRollNo(){ return rollNo; } public String getJson(){ return json; } }
Output
Run the JacksonTester and verify the output −
{ "name" : "Mark", "rollNo" : 1, "json" : {"attr":false} }
Here we're using @JsonRawValue annotation over json property to escape special characters as evident in the output.
Jackson Annotations - @JsonValue
Overview
@JsonValue annotation allows to serialize an entire object using its single method.
Example - Serialization without using @JsonValue
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonValue; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try { Student student = new Student("Mark", 1); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { private String name; private int rollNo; public Student(String name, int rollNo){ this.name = name; this.rollNo = rollNo; } public String getName(){ return name; } public int getRollNo(){ return rollNo; } public String toString(){ return "{ name : " + name + " }"; } }
Output
Run the JacksonTester and verify the output −
{ "name" : "Mark", "rollNo" : 1 }
Example - Serialization with @JsonValue
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonValue; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try { Student student = new Student("Mark", 1); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { private String name; private int rollNo; public Student(String name, int rollNo){ this.name = name; this.rollNo = rollNo; } public String getName(){ return name; } public int getRollNo(){ return rollNo; } @JsonValue public String toString(){ return "{ name : " + name + " }"; } }
Output
Run the JacksonTester and verify the output −
"{ name : Mark }"
Here using @JsonValue annotation, we've controlled the default Serialization by toString() method.
Jackson Annotations - @JsonRootName
Overview
@JsonRootName annotation allows to have a root node specified over the JSON. We need to enable wrap root value as well.
Example - Serialization without using @JsonRootName
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try { Student student = new Student("Mark", 1); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { private String name; private int rollNo; public Student(String name, int rollNo){ this.name = name; this.rollNo = rollNo; } public String getName(){ return name; } public int getRollNo(){ return rollNo; } }
Output
Run the JacksonTester and verify the output −
{ "name" : "Mark", "rollNo" : 1 }
Example - Serialization with @JsonRootName
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonRootName; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.SerializationFeature; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try { Student student = new Student("Mark", 1); mapper.enable(SerializationFeature.WRAP_ROOT_VALUE); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } @JsonRootName(value = "student") class Student { private String name; private int rollNo; public Student(String name, int rollNo){ this.name = name; this.rollNo = rollNo; } public String getName(){ return name; } public int getRollNo(){ return rollNo; } }
Output
Run the JacksonTester and verify the output −
{ "student" : { "name" : "Mark", "rollNo" : 1 } }
Here we've enabled root node by using ObjectMapper.enable(SerializationFeature.WRAP_ROOT_VALUE). By default, it prints the root name as class name as "Student". We've customized the root name using @JsonRootName annotation.
Jackson Annotations - @JsonSerialize
Overview
@JsonSerialize annotation is used to specify custom serializer to marshall the json object.
Example - Serialization without using @JsonSerialize
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.annotation.JsonSerialize; import com.fasterxml.jackson.databind.ser.std.StdSerializer; public class JacksonTester { public static void main(String args[]) throws ParseException { ObjectMapper mapper = new ObjectMapper(); SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy"); try { Student student = new Student("Mark", 1, dateFormat.parse("20-11-1984")); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { private String name; private int rollNo; private Date dateOfBirth; public Student(String name, int rollNo, Date dob){ this.name = name; this.rollNo = rollNo; this.dateOfBirth = dob; } public String getName(){ return name; } public int getRollNo(){ return rollNo; } public Date getDateOfBirth(){ return dateOfBirth; } }
Output
Run the JacksonTester and verify the output −
{ "name" : "Mark", "rollNo" : 1, "dateOfBirth" : 469737000000 }
Example - Serialization with @JsonSerialize
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import com.fasterxml.jackson.core.JsonGenerator; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.SerializerProvider; import com.fasterxml.jackson.databind.annotation.JsonSerialize; import com.fasterxml.jackson.databind.ser.std.StdSerializer; public class JacksonTester { public static void main(String args[]) throws ParseException { ObjectMapper mapper = new ObjectMapper(); SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy"); try { Student student = new Student("Mark", 1, dateFormat.parse("20-11-1984")); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { private String name; private int rollNo; @JsonSerialize(using = CustomDateSerializer.class) private Date dateOfBirth; public Student(String name, int rollNo, Date dob){ this.name = name; this.rollNo = rollNo; this.dateOfBirth = dob; } public String getName(){ return name; } public int getRollNo(){ return rollNo; } public Date getDateOfBirth(){ return dateOfBirth; } } class CustomDateSerializer extends StdSerializer<Date> { private static final long serialVersionUID = 1L; private static SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy"); public CustomDateSerializer() { this(null); } public CustomDateSerializer(Class<Date> t) { super(t); } @Override public void serialize(Date value, JsonGenerator generator, SerializerProvider arg2) throws IOException { generator.writeString(formatter.format(value)); } }
Output
Run the JacksonTester and verify the output −
{ "name" : "Mark", "rollNo" : 1, "dateOfBirth" : "20-11-1984" }
Here we can compare the output, as date serialization is customized using CustomDateSerializer object put in use by @JsonSerialize annotation.
Jackson Annotations - @JsonCreator
Overview
@JsonCreator annotation is used to fine tune the constructor or factory method used in deserialization. We'll be using @JsonProperty as well to achieve the same. In the example below, we are matching an json with different format to our class by defining the required property names.
Example - Deserialization without using @JsonCreator
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws ParseException{ String json = "{\"id\":1,\"theName\":\"Mark\"}"; ObjectMapper mapper = new ObjectMapper(); try { Student student = mapper .readerFor(Student.class) .readValue(json); System.out.println(student.rollNo +", " + student.name); } catch (IOException e) { e.printStackTrace(); } } } class Student { public String name; public int rollNo; public Student(String name, int rollNo){ this.name = name; this.rollNo = rollNo; } }
Output
Run the JacksonTester and verify the output −
com.fasterxml.jackson.databind.exc.InvalidDefinitionException: Cannot construct instance of 'com.tutorialspoint.Student' (no Creators, like default constructor, exist): cannot deserialize from Object value (no delegate- or property-based Creator) at [Source: REDACTED ('StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION' disabled); line: 1, column: 2] at com.fasterxml.jackson.databind.exc.InvalidDefinitionException.from(InvalidDefinitionException.java:67) at com.fasterxml.jackson.databind.DeserializationContext.reportBadDefinition(DeserializationContext.java:1942) at com.fasterxml.jackson.databind.DatabindContext.reportBadDefinition(DatabindContext.java:415) at com.fasterxml.jackson.databind.DeserializationContext.handleMissingInstantiator(DeserializationContext.java:1429) at com.fasterxml.jackson.databind.deser.BeanDeserializerBase.deserializeFromObjectUsingNonDefault(BeanDeserializerBase.java:1514) at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserializeFromObject(BeanDeserializer.java:340) at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserialize(BeanDeserializer.java:177) at com.fasterxml.jackson.databind.deser.DefaultDeserializationContext.readRootValue(DefaultDeserializationContext.java:342) at com.fasterxml.jackson.databind.ObjectReader._bindAndClose(ObjectReader.java:2130) at com.fasterxml.jackson.databind.ObjectReader.readValue(ObjectReader.java:1565) at com.tutorialspoint.JacksonTester.main(JacksonTester.java:15)
Example - Deserialization with @JsonCreator
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws ParseException{ String json = "{\"id\":1,\"theName\":\"Mark\"}"; ObjectMapper mapper = new ObjectMapper(); try { Student student = mapper .readerFor(Student.class) .readValue(json); System.out.println(student.rollNo +", " + student.name); } catch (IOException e) { e.printStackTrace(); } } } class Student { public String name; public int rollNo; @JsonCreator public Student(@JsonProperty("theName") String name, @JsonProperty("id") int rollNo){ this.name = name; this.rollNo = rollNo; } }
Output
Run the JacksonTester and verify the output −
1, Mark
Here we can see easily, that in case of custom JSON, Jackson throws exception. To handle custom JSON, we can customize deserialization using @JsonCreator and @JsonProperty.
Jackson Annotations - @JacksonInject
Overview
@JacksonInject annotation is used when a property value is to be injected instead of being parsed from Json input. In the example below, we are to insert a value into object instead of parsing from the Json.
Example - Deserialization without using @JacksonInject
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws ParseException{ String json = "{\"name\":\"Mark\"}"; ObjectMapper mapper = new ObjectMapper(); try { Student student = mapper .readerFor(Student.class) .readValue(json); System.out.println(student.rollNo +", " + student.name); } catch (IOException e) { e.printStackTrace(); } } } class Student { public String name; public int rollNo; }
Output
Run the JacksonTester and verify the output −
0, Mark
Example - Deserialization with @JacksonInject
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import com.fasterxml.jackson.annotation.JacksonInject; import com.fasterxml.jackson.databind.InjectableValues; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws ParseException{ String json = "{\"name\":\"Mark\"}"; InjectableValues injectableValues = new InjectableValues.Std() .addValue(int.class, 1); ObjectMapper mapper = new ObjectMapper(); try { Student student = mapper .reader(injectableValues) .forType(Student.class) .readValue(json); System.out.println(student.rollNo +", " + student.name); } catch (IOException e) { e.printStackTrace(); } } } class Student { public String name; @JacksonInject public int rollNo; }
Output
Run the JacksonTester and verify the output −
1, Mark
Here we can see, using @JacksonInject, we can a inject value in our object during deserialization easily.
Jackson Annotations - @JsonAnySetter
Overview
@JsonAnySetter annotation allows a setter method to use Map which is then used to deserialize the additional properties of JSON in the similar fashion as other properties.
Example - Deserialization without using @JsonAnySetter
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.util.HashMap; import java.util.Map; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); String jsonString = "{\"RollNo\" : \"1\",\"Name\" : \"Mark\"}"; try { Student student = mapper.readerFor(Student.class).readValue(jsonString); System.out.println(student.getProperties().get("Name")); System.out.println(student.getProperties().get("RollNo")); } catch (IOException e) { e.printStackTrace(); } } } class Student { private Map<String, String> properties; public Student(){ properties = new HashMap<>(); } public Map<String, String> getProperties(){ return properties; } public void add(String property, String value){ properties.put(property, value); } }
Output
Run the JacksonTester and verify the output −
com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException: Unrecognized field "RollNo" (class com.tutorialspoint.Student), not marked as ignorable (one known property: "properties"]) at [Source: REDACTED ('StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION' disabled); line: 1, column: 14] (through reference chain: com.tutorialspoint.Student["RollNo"]) at com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException.from(UnrecognizedPropertyException.java:61) at com.fasterxml.jackson.databind.DeserializationContext.handleUnknownProperty(DeserializationContext.java:1207) at com.fasterxml.jackson.databind.deser.std.StdDeserializer.handleUnknownProperty(StdDeserializer.java:2295) at com.fasterxml.jackson.databind.deser.BeanDeserializerBase.handleUnknownProperty(BeanDeserializerBase.java:1823) at com.fasterxml.jackson.databind.deser.BeanDeserializerBase.handleUnknownVanilla(BeanDeserializerBase.java:1801) at com.fasterxml.jackson.databind.deser.BeanDeserializer.vanillaDeserialize(BeanDeserializer.java:308) at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserialize(BeanDeserializer.java:169) at com.fasterxml.jackson.databind.deser.DefaultDeserializationContext.readRootValue(DefaultDeserializationContext.java:342) at com.fasterxml.jackson.databind.ObjectReader._bindAndClose(ObjectReader.java:2130) at com.fasterxml.jackson.databind.ObjectReader.readValue(ObjectReader.java:1565) at com.tutorialspoint.JacksonTester.main(JacksonTester.java:14)
Example - Deserialization with @JsonAnySetter
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.util.HashMap; import java.util.Map; import com.fasterxml.jackson.annotation.JsonAnySetter; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); String jsonString = "{\"RollNo\" : \"1\",\"Name\" : \"Mark\"}"; try { Student student = mapper.readerFor(Student.class).readValue(jsonString); System.out.println(student.getProperties().get("Name")); System.out.println(student.getProperties().get("RollNo")); } catch (IOException e) { e.printStackTrace(); } } } class Student { private Map<String, String> properties; public Student(){ properties = new HashMap<>(); } public Map<String, String> getProperties(){ return properties; } @JsonAnySetter public void add(String property, String value){ properties.put(property, value); } }
Output
Run the JacksonTester and verify the output −
Mark 1
Here we can see, without using @JsonAnySetter, we get the exception during deserialization. Using @JsonAnySetter annotation, we can use map as properties of an object.
Jackson Annotations - @JsonSetter
Overview
@JsonSetter annotation allows a specific method to be marked as setter method.
Example - Deserialization without using @JsonSetter
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonSetter; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); String jsonString = "{\"rollNo\":1,\"name\":\"Marks\"}"; try { Student student = mapper.readerFor(Student.class).readValue(jsonString); System.out.println(student.getRollNo() + ", " + student.getName()); } catch (IOException e) { e.printStackTrace(); } } } class Student { private int rollNo; private String name; public void setTheName(String name) { this.name = name; } public void setTheRollNo(int rollNo) {this.rollNo = rollNo;} public int getRollNo() {return rollNo;} public String getName() {return name;} }
Output
Run the JacksonTester and verify the output −
1, Marks
Example - Deserialization with @JsonSetter
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonSetter; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); String jsonString = "{\"rollNo\":1,\"name\":\"Marks\"}"; try { Student student = mapper.readerFor(Student.class).readValue(jsonString); System.out.println(student.getRollNo() + ", " + student.getName()); } catch (IOException e) { e.printStackTrace(); } } } class Student { private int rollNo; private String name; @JsonSetter("name") public void setTheName(String name) { this.name = name; } public void setTheRollNo(int rollNo) {this.rollNo = rollNo;} public int getRollNo() {return rollNo;} public String getName() {return name;} }
Output
Run the JacksonTester and verify the output −
1, Marks
Here we can see, even without using @JsonSetter, Jackson handles the custom setter methods. But using @JsonSetter is recommended for custom setter methods.
Jackson Annotations - @JsonDeserialize
Overview
@JsonDeserialize annotation is used to specify custom deserializer to unmarshall the json object.
Example - Deserialization without using @JsonDeserialize
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import java.util.Date; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws ParseException{ ObjectMapper mapper = new ObjectMapper(); String jsonString = "{\"name\":\"Mark\",\"dateOfBirth\":\"20-12-1984\"}"; try { Student student = mapper .readerFor(Student.class) .readValue(jsonString); System.out.println(student.dateOfBirth); } catch (IOException e) { e.printStackTrace(); } } } class Student { public String name; public Date dateOfBirth; }
Output
Run the JacksonTester and verify the output −
com.fasterxml.jackson.databind.exc.InvalidFormatException: Cannot deserialize value of type 'java.util.Date' from String "20-12-1984": not a valid representation (error: Failed to parse Date value '20-12-1984': Cannot parse date "20-12-1984": not compatible with any of standard forms ("yyyy-MM-dd'T'HH:mm:ss.SSSX", "yyyy-MM-dd'T'HH:mm:ss.SSS", "EEE, dd MMM yyyy HH:mm:ss zzz", "yyyy-MM-dd")) at [Source: REDACTED ('StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION' disabled); line: 1, column: 30] (through reference chain: com.tutorialspoint.Student["dateOfBirth"]) at com.fasterxml.jackson.databind.exc.InvalidFormatException.from(InvalidFormatException.java:67) at com.fasterxml.jackson.databind.DeserializationContext.weirdStringException(DeserializationContext.java:2013) at com.fasterxml.jackson.databind.DeserializationContext.handleWeirdStringValue(DeserializationContext.java:1299) at com.fasterxml.jackson.databind.deser.std.StdDeserializer._parseDate(StdDeserializer.java:1426) at com.fasterxml.jackson.databind.deser.std.StdDeserializer._parseDate(StdDeserializer.java:1368) at com.fasterxml.jackson.databind.deser.std.DateDeserializers$DateBasedDeserializer._parseDate(DateDeserializers.java:200) at com.fasterxml.jackson.databind.deser.std.DateDeserializers$DateDeserializer.deserialize(DateDeserializers.java:302) at com.fasterxml.jackson.databind.deser.std.DateDeserializers$DateDeserializer.deserialize(DateDeserializers.java:280) at com.fasterxml.jackson.databind.deser.impl.FieldProperty.deserializeAndSet(FieldProperty.java:137) at com.fasterxml.jackson.databind.deser.BeanDeserializer.vanillaDeserialize(BeanDeserializer.java:302) at com.fasterxml.jackson.databind.deser.BeanDeserializer.deserialize(BeanDeserializer.java:169) at com.fasterxml.jackson.databind.deser.DefaultDeserializationContext.readRootValue(DefaultDeserializationContext.java:342) at com.fasterxml.jackson.databind.ObjectReader._bindAndClose(ObjectReader.java:2130) at com.fasterxml.jackson.databind.ObjectReader.readValue(ObjectReader.java:1565) at com.tutorialspoint.JacksonTester.main(JacksonTester.java:16)
Example - Deserialization with @JsonDeserialize
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.DeserializationContext; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import com.fasterxml.jackson.databind.deser.std.StdDeserializer; public class JacksonTester { public static void main(String args[]) throws ParseException{ ObjectMapper mapper = new ObjectMapper(); String jsonString = "{\"name\":\"Mark\",\"dateOfBirth\":\"20-12-1984\"}"; try { Student student = mapper .readerFor(Student.class) .readValue(jsonString); System.out.println(student.dateOfBirth); } catch (IOException e) { e.printStackTrace(); } } } class Student { public String name; @JsonDeserialize(using = CustomDateDeserializer.class) public Date dateOfBirth; } class CustomDateDeserializer extends StdDeserializer<Date> { private static final long serialVersionUID = 1L; private static SimpleDateFormat formatter = new SimpleDateFormat("dd-MM-yyyy"); public CustomDateDeserializer() { this(null); } public CustomDateDeserializer(Classt) { super(t); } @Override public Date deserialize(JsonParser parser, DeserializationContext context) throws IOException, JsonProcessingException { String date = parser.getText(); try { return formatter.parse(date); } catch (ParseException e) { e.printStackTrace(); } return null; } }
Output
Run the JacksonTester and verify the output −
Thu Dec 20 00:00:00 IST 1984
Here we can see, without using @JsonDeserialize, Jackson is unable to handle string deserialization to date. Using @JsonDeserialize we can define and set a custom deserializer for us.
Jackson Annotations - @JsonEnumDefaultValue
Overview
@JsonEnumDefaultValue annotation is used to deserialize an unknown enum value using a default value.
Example - Deserialization without using @JsonEnumDefaultValue
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import com.fasterxml.jackson.annotation.JsonEnumDefaultValue; import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws ParseException{ ObjectMapper mapper = new ObjectMapper(); String jsonString = "\"abc\""; try { LETTERS value = mapper.readValue(jsonString, LETTERS.class); System.out.println(value); } catch (IOException e) { e.printStackTrace(); } } } enum LETTERS { A, B }
Output
Run the JacksonTester and verify the output −
com.fasterxml.jackson.databind.exc.InvalidFormatException: Cannot deserialize value of type 'com.tutorialspoint.LETTERS' from String "abc": not one of the values accepted for Enum class: [A, B] at [Source: REDACTED ('StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION' disabled); line: 1, column: 1] at com.fasterxml.jackson.databind.exc.InvalidFormatException.from(InvalidFormatException.java:67) at com.fasterxml.jackson.databind.DeserializationContext.weirdStringException(DeserializationContext.java:2013) at com.fasterxml.jackson.databind.DeserializationContext.handleWeirdStringValue(DeserializationContext.java:1299) at com.fasterxml.jackson.databind.deser.std.EnumDeserializer._deserializeAltString(EnumDeserializer.java:450) at com.fasterxml.jackson.databind.deser.std.EnumDeserializer._fromString(EnumDeserializer.java:307) at com.fasterxml.jackson.databind.deser.std.EnumDeserializer.deserialize(EnumDeserializer.java:272) at com.fasterxml.jackson.databind.deser.DefaultDeserializationContext.readRootValue(DefaultDeserializationContext.java:342) at com.fasterxml.jackson.databind.ObjectMapper._readMapAndClose(ObjectMapper.java:4971) at com.fasterxml.jackson.databind.ObjectMapper.readValue(ObjectMapper.java:3887) at com.fasterxml.jackson.databind.ObjectMapper.readValue(ObjectMapper.java:3855) at com.tutorialspoint.JacksonTester.main(JacksonTester.java:13)
Example - Deserialization with @JsonEnumDefaultValue
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import com.fasterxml.jackson.annotation.JsonEnumDefaultValue; import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws ParseException{ ObjectMapper mapper = new ObjectMapper(); mapper.enable(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE); String jsonString = "\"abc\""; try { LETTERS value = mapper.readValue(jsonString, LETTERS.class); System.out.println(value); } catch (IOException e) { e.printStackTrace(); } } } enum LETTERS { A, B, @JsonEnumDefaultValue UNKNOWN }
Output
Run the JacksonTester and verify the output −
UNKNOWN
Here we can see, without using @JsonEnumDefaultValue, Jackson is unable to handle unknown enum value during deserialization. Using @JsonEnumDefaultValue we can define and set a default enum value for us.
Jackson Annotations - @JsonEnumDefaultValue
Overview
@JsonIgnoreProperties annotation is used at class level to mark a property or list of properties to be ignored.
Example - Serialization without using @JsonIgnoreProperties
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) { ObjectMapper mapper = new ObjectMapper(); try { Student student = new Student(1,11,"1ab","Mark"); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { public int id; public String systemId; public int rollNo; public String name; Student(int id, int rollNo, String systemId, String name){ this.id = id; this.systemId = systemId; this.rollNo = rollNo; this.name = name; } }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "systemId" : "1ab", "rollNo" : 11, "name" : "Mark" }
Example - Serialization with @JsonIgnoreProperties
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) { ObjectMapper mapper = new ObjectMapper(); try { Student student = new Student(1,11,"1ab","Mark"); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } @JsonIgnoreProperties({ "id", "systemId" }) class Student { public int id; public String systemId; public int rollNo; public String name; Student(int id, int rollNo, String systemId, String name){ this.id = id; this.systemId = systemId; this.rollNo = rollNo; this.name = name; } }
Output
Run the JacksonTester and verify the output −
{ "rollNo" : 11, "name" : "Mark" }
Here we can see, without using @JsonIgnoreProperties, Jackson is serializing all values by default. Using @JsonIgnoreProperties we can define the properties which are not to be serialized.
Jackson Annotations - @JsonIgnore
Overview
@JsonIgnore annotation is used at mark a property of special type to be ignored.
Example - Serialization without using @JsonIgnore
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) { ObjectMapper mapper = new ObjectMapper(); try { Student student = new Student(1,11,"1ab","Mark"); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { public int id; public String systemId; public int rollNo; public String name; Student(int id, int rollNo, String systemId, String name){ this.id = id; this.systemId = systemId; this.rollNo = rollNo; this.name = name; } }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "systemId" : "1ab", "rollNo" : 11, "name" : "Mark" }
Example - Serialization with @JsonIgnore
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonIgnore; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try{ Student student = new Student(1,11,"1ab","Mark"); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { public int id; @JsonIgnore public String systemId; public int rollNo; public String name; Student(int id, int rollNo, String systemId, String name){ this.id = id; this.systemId = systemId; this.rollNo = rollNo; this.name = name; } }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "rollNo" : 11, "name" : "Mark" }
Here we can see, without using @JsonIgnore, Jackson is serializing all values by default. Using @JsonIgnore we can define the property which is to be ignored during serialization.
Jackson Annotations - @JsonIgnoreType
Overview
@JsonIgnoreType annotation is used at mark a property of special type to be ignored.
Example - Serialization without using @JsonIgnoreType
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) { ObjectMapper mapper = new ObjectMapper(); try { Student student = new Student(1,11,"1ab","Mark"); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { public int id; public String systemId; public int rollNo; public String name; Student(int id, int rollNo, String systemId, String name){ this.id = id; this.systemId = systemId; this.rollNo = rollNo; this.name = name; } }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "systemId" : "1ab", "rollNo" : 11, "nameObj" : { "name" : "Mark" } }
Example - Serialization with @JsonIgnoreType
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonIgnoreType; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try { Student student = new Student(1,11,"1ab","Mark"); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { public int id; public String systemId; public int rollNo; public Name nameObj; Student(int id, int rollNo, String systemId, String name){ this.id = id; this.systemId = systemId; this.rollNo = rollNo; nameObj = new Name(name); } @JsonIgnoreType class Name { public String name; Name(String name){ this.name = name; } } }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "systemId" : "1ab", "rollNo" : 11 }
Here we can see, without using @JsonIgnoreType, Jackson is serializing all values by default including an inner class. Using @JsonIgnoreType we can define the properties of certain type which are to be ignored during serialization.
Jackson Annotations - @JsonInclude
Overview
@JsonInclude annotation is used to exclude properties having null/empty or default values.
Example - Serialization without using @JsonInclude
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try { Student student = new Student(1,null); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { public int id; public String name; Student(int id,String name){ this.id = id; this.name = name; } }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "name" : null }
Example - Serialization with @JsonInclude
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try { Student student = new Student(1,null); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } @JsonInclude(JsonInclude.Include.NON_NULL) class Student { public int id; public String name; Student(int id,String name){ this.id = id; this.name = name; } }
Output
Run the JacksonTester and verify the output −
{ "id" : 1 }
Here we can see, without using @JsonInclude, Jackson is serializing all values including null as well. Using @JsonInclude we can define the values which are to be ignored during serialization.
Jackson Annotations - @JsonAutoDetect
Overview
@JsonAutoDetect annotation is used to include properties which are not accessible otherwise.
Example - Serialization without using @JsonAutoDetect
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try{ Student student = new Student(1,"Mark"); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { private int id; private String name; Student(int id,String name) { this.id = id; this.name = name; } }
Output
Run the JacksonTester and verify the output −
com.fasterxml.jackson.databind.exc.InvalidDefinitionException: No serializer found for class com.tutorialspoint.Student and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS) at com.fasterxml.jackson.databind.exc.InvalidDefinitionException.from(InvalidDefinitionException.java:77) at com.fasterxml.jackson.databind.SerializerProvider.reportBadDefinition(SerializerProvider.java:1359) at com.fasterxml.jackson.databind.DatabindContext.reportBadDefinition(DatabindContext.java:415) at com.fasterxml.jackson.databind.ser.impl.UnknownSerializer.failForEmpty(UnknownSerializer.java:52) at com.fasterxml.jackson.databind.ser.impl.UnknownSerializer.serialize(UnknownSerializer.java:29) at com.fasterxml.jackson.databind.ser.DefaultSerializerProvider._serialize(DefaultSerializerProvider.java:503) at com.fasterxml.jackson.databind.ser.DefaultSerializerProvider.serializeValue(DefaultSerializerProvider.java:342) at com.fasterxml.jackson.databind.ObjectWriter$Prefetch.serialize(ObjectWriter.java:1587) at com.fasterxml.jackson.databind.ObjectWriter._writeValueAndClose(ObjectWriter.java:1289) at com.fasterxml.jackson.databind.ObjectWriter.writeValueAsString(ObjectWriter.java:1140) at com.tutorialspoint.JacksonTester.main(JacksonTester.java:13)
Example - Serialization with @JsonAutoDetect
JacksonTester.java
package com.tutorialpoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try{ Student student = new Student(1,"Mark"); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } @JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY) class Student { private int id; private String name; Student(int id,String name) { this.id = id; this.name = name; } }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "name" : "Mark" }
Here we can see, without using @JsonAutoDetect, Jackson is unable to deserialize to private fields. Using @JsonAutoDetect we can include private fields which are not accessible during deserialization otherwise.
Jackson Annotations - @JsonAutoDetect
Overview
@JsonAutoDetect annotation is used to include properties which are not accessible otherwise.
Example - Serialization without using @JsonAutoDetect
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try{ Student student = new Student(1,"Mark"); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { private int id; private String name; Student(int id,String name) { this.id = id; this.name = name; } }
Output
Run the JacksonTester and verify the output −
com.fasterxml.jackson.databind.exc.InvalidDefinitionException: No serializer found for class com.tutorialspoint.Student and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS) at com.fasterxml.jackson.databind.exc.InvalidDefinitionException.from(InvalidDefinitionException.java:77) at com.fasterxml.jackson.databind.SerializerProvider.reportBadDefinition(SerializerProvider.java:1359) at com.fasterxml.jackson.databind.DatabindContext.reportBadDefinition(DatabindContext.java:415) at com.fasterxml.jackson.databind.ser.impl.UnknownSerializer.failForEmpty(UnknownSerializer.java:52) at com.fasterxml.jackson.databind.ser.impl.UnknownSerializer.serialize(UnknownSerializer.java:29) at com.fasterxml.jackson.databind.ser.DefaultSerializerProvider._serialize(DefaultSerializerProvider.java:503) at com.fasterxml.jackson.databind.ser.DefaultSerializerProvider.serializeValue(DefaultSerializerProvider.java:342) at com.fasterxml.jackson.databind.ObjectWriter$Prefetch.serialize(ObjectWriter.java:1587) at com.fasterxml.jackson.databind.ObjectWriter._writeValueAndClose(ObjectWriter.java:1289) at com.fasterxml.jackson.databind.ObjectWriter.writeValueAsString(ObjectWriter.java:1140) at com.tutorialspoint.JacksonTester.main(JacksonTester.java:13)
Example - Serialization with @JsonAutoDetect
JacksonTester.java
package com.tutorialpoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ ObjectMapper mapper = new ObjectMapper(); try{ Student student = new Student(1,"Mark"); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } @JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY) class Student { private int id; private String name; Student(int id,String name) { this.id = id; this.name = name; } }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "name" : "Mark" }
Here we can see, without using @JsonAutoDetect, Jackson is unable to deserialize to private fields. Using @JsonAutoDetect we can include private fields which are not accessible during deserialization otherwise.
Jackson Annotations - @JsonTypeInfo
Overview
@JsonTypeInfo annotation is used to indicate details of type information which is to be included in serialization and de-serialization.
Consider a case, where subclasses extends a base class and deserialization is done using base class.
class Shape { public String name; Shape(String name){ this.name = name; } } class Square extends Shape { public double length; Square(){ this(null,0.0); } Square(String name, double length){ super(name); this.length = length; } } class Circle extends Shape { public double radius; Circle(){ this(null,0.0); } Circle(String name, double radius) { super(name); this.radius = radius; } } ... String json = "{\"name\":\"CustomCircle\",\"radius\":1.0, \"type\":\"circle\"}"; Circle circle = new ObjectMapper().readerFor(Shape.class).readValue(json);
Now in order to achieve this functionality, we can use @JsonTypeName on the classes to define their type and @JsonTypeInfo to map the correct class during serialization −
@JsonTypeName("square") static class Square extends Shape { ... } @JsonTypeName("circle") static class Circle extends Shape { ... } ... @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = As.PROPERTY, property = "type") @JsonSubTypes({ @JsonSubTypes.Type(value = Square.class, name = "square"), @JsonSubTypes.Type(value = Circle.class, name = "circle") })
Example - Deserialization using @JsonTypeInfo
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonSubTypes; import com.fasterxml.jackson.annotation.JsonTypeInfo; import com.fasterxml.jackson.annotation.JsonTypeInfo.As; import com.fasterxml.jackson.annotation.JsonTypeName; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws IOException { Shape shape = new JacksonTester.Circle("CustomCircle", 1); String result = new ObjectMapper() .writerWithDefaultPrettyPrinter() .writeValueAsString(shape); System.out.println(result); String json = "{\"name\":\"CustomCircle\",\"radius\":1.0, \"type\":\"circle\"}"; Circle circle = new ObjectMapper().readerFor(Shape.class).readValue(json); System.out.println(circle.name); } @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = As.PROPERTY, property = "type") @JsonSubTypes({ @JsonSubTypes.Type(value = Square.class, name = "square"), @JsonSubTypes.Type(value = Circle.class, name = "circle") }) static class Shape { public String name; Shape(String name){ this.name = name; } } @JsonTypeName("square") static class Square extends Shape { public double length; Square(){ this(null,0.0); } Square(String name, double length){ super(name); this.length = length; } } @JsonTypeName("circle") static class Circle extends Shape { public double radius; Circle(){ this(null,0.0); } Circle(String name, double radius) { super(name); this.radius = radius; } } }
Output
Run the JacksonTester and verify the output −
{ "type" : "circle", "name" : "CustomCircle", "radius" : 1.0 } CustomCircle
Jackson Annotations - @JsonSubTypes
Overview
@JsonSubTypes annotation is used to indicate subtypes of types annotated.
Consider a case, where subclasses extends a base class and deserialization is done using base class.
class Shape { public String name; Shape(String name){ this.name = name; } } class Square extends Shape { public double length; Square(){ this(null,0.0); } Square(String name, double length){ super(name); this.length = length; } } class Circle extends Shape { public double radius; Circle(){ this(null,0.0); } Circle(String name, double radius) { super(name); this.radius = radius; } } ... String json = "{\"name\":\"CustomCircle\",\"radius\":1.0, \"type\":\"circle\"}"; Circle circle = new ObjectMapper().readerFor(Shape.class).readValue(json);
Now in order to achieve this functionality, we can use @JsonTypeName on the classes to define their type and @JsonTypeInfo to map the correct class during serialization. In @JsonTypeInfo, we're setting subtypes using @JsonSubTypes −
@JsonTypeName("square") static class Square extends Shape { ... } @JsonTypeName("circle") static class Circle extends Shape { ... } ... @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = As.PROPERTY, property = "type") @JsonSubTypes({ @JsonSubTypes.Type(value = Square.class, name = "square"), @JsonSubTypes.Type(value = Circle.class, name = "circle") })
Example - Deserialization using @JsonSubTypes
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonSubTypes; import com.fasterxml.jackson.annotation.JsonTypeInfo; import com.fasterxml.jackson.annotation.JsonTypeInfo.As; import com.fasterxml.jackson.annotation.JsonTypeName; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws IOException { Shape shape = new JacksonTester.Circle("CustomCircle", 1); String result = new ObjectMapper() .writerWithDefaultPrettyPrinter() .writeValueAsString(shape); System.out.println(result); String json = "{\"name\":\"CustomCircle\",\"radius\":1.0, \"type\":\"circle\"}"; Circle circle = new ObjectMapper().readerFor(Shape.class).readValue(json); System.out.println(circle.name); } @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = As.PROPERTY, property = "type") @JsonSubTypes({ @JsonSubTypes.Type(value = Square.class, name = "square"), @JsonSubTypes.Type(value = Circle.class, name = "circle") }) static class Shape { public String name; Shape(String name){ this.name = name; } } @JsonTypeName("square") static class Square extends Shape { public double length; Square(){ this(null,0.0); } Square(String name, double length){ super(name); this.length = length; } } @JsonTypeName("circle") static class Circle extends Shape { public double radius; Circle(){ this(null,0.0); } Circle(String name, double radius) { super(name); this.radius = radius; } } }
Output
Run the JacksonTester and verify the output −
{ "type" : "circle", "name" : "CustomCircle", "radius" : 1.0 } CustomCircle
Jackson Annotations - @JsonTypeName
Overview
@JsonTypeName annotation is used to set type names to be used for annotated class.
Consider a case, where subclasses extends a base class and deserialization is done using base class.
class Shape { public String name; Shape(String name){ this.name = name; } } class Square extends Shape { public double length; Square(){ this(null,0.0); } Square(String name, double length){ super(name); this.length = length; } } class Circle extends Shape { public double radius; Circle(){ this(null,0.0); } Circle(String name, double radius) { super(name); this.radius = radius; } } ... String json = "{\"name\":\"CustomCircle\",\"radius\":1.0, \"type\":\"circle\"}"; Circle circle = new ObjectMapper().readerFor(Shape.class).readValue(json);
Now in order to achieve this functionality, we can use @JsonTypeName on the classes to define their type and @JsonTypeInfo to map the correct class during serialization. In @JsonTypeInfo, we're setting subtypes using @JsonSubTypes −
@JsonTypeName("square") static class Square extends Shape { ... } @JsonTypeName("circle") static class Circle extends Shape { ... } ... @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = As.PROPERTY, property = "type") @JsonSubTypes({ @JsonSubTypes.Type(value = Square.class, name = "square"), @JsonSubTypes.Type(value = Circle.class, name = "circle") })
Example - Deserialization using @JsonTypeName
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonSubTypes; import com.fasterxml.jackson.annotation.JsonTypeInfo; import com.fasterxml.jackson.annotation.JsonTypeInfo.As; import com.fasterxml.jackson.annotation.JsonTypeName; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws IOException { Shape shape = new JacksonTester.Circle("CustomCircle", 1); String result = new ObjectMapper() .writerWithDefaultPrettyPrinter() .writeValueAsString(shape); System.out.println(result); String json = "{\"name\":\"CustomCircle\",\"radius\":1.0, \"type\":\"circle\"}"; Circle circle = new ObjectMapper().readerFor(Shape.class).readValue(json); System.out.println(circle.name); } @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = As.PROPERTY, property = "type") @JsonSubTypes({ @JsonSubTypes.Type(value = Square.class, name = "square"), @JsonSubTypes.Type(value = Circle.class, name = "circle") }) static class Shape { public String name; Shape(String name){ this.name = name; } } @JsonTypeName("square") static class Square extends Shape { public double length; Square(){ this(null,0.0); } Square(String name, double length){ super(name); this.length = length; } } @JsonTypeName("circle") static class Circle extends Shape { public double radius; Circle(){ this(null,0.0); } Circle(String name, double radius) { super(name); this.radius = radius; } } }
Output
Run the JacksonTester and verify the output −
{ "type" : "circle", "name" : "CustomCircle", "radius" : 1.0 } CustomCircle
Jackson Annotations - @JsonProperty
Overview
@JsonProperty annotation is used at mark a property of special type to be ignored.
Example - Deserialization without using @JsonProperty
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws IOException { ObjectMapper mapper = new ObjectMapper(); String json = "{\"id\" : 1}"; Student student = mapper.readerFor(Student.class).readValue(json); System.out.println(student.getTheId()); } } class Student { private int id; Student(){} Student(int id){ this.id = id; } public int getTheId() { return id; } public void setTheId(int id) { this.id = id; } }
Output
Run the JacksonTester and verify the output −
1
Example - Deserialization with @JsonProperty
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws IOException { ObjectMapper mapper = new ObjectMapper(); String json = "{\"id\" : 1}"; Student student = mapper.readerFor(Student.class).readValue(json); System.out.println(student.getTheId()); } } class Student { private int id; Student(){} Student(int id){ this.id = id; } @JsonProperty("id") public int getTheId() { return id; } @JsonProperty("id") public void setTheId(int id) { this.id = id; } }
Output
Run the JacksonTester and verify the output −
1
Here we can see, even without using @JsonProperty, Jackson is deserializing using the available setter method. Use of @JsonProperty is recommended where we've custom setter methods instead of standard setter methods.
Jackson Annotations - @JsonFormat
Overview
@JsonFormat annotation is used to specify format while serialization or de-serialization. It is mostly used with Date fields.
Example - Serialization without using @JsonFormat
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws IOException, ParseException { ObjectMapper mapper = new ObjectMapper(); SimpleDateFormat simpleDateFormat = new SimpleDateFormat("dd-MM-yyyy"); Date date = simpleDateFormat.parse("20-12-1984"); Student student = new Student(1, date); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } } class Student { public int id; public Date birthDate; Student(int id, Date birthDate){ this.id = id; this.birthDate = birthDate; } }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "birthDate" : 472329000000 }
Example - Serialization with @JsonFormat
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws IOException, ParseException { ObjectMapper mapper = new ObjectMapper(); SimpleDateFormat simpleDateFormat = new SimpleDateFormat("dd-MM-yyyy"); Date date = simpleDateFormat.parse("20-12-1984"); Student student = new Student(1, date); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } } class Student { public int id; @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd-MM-yyyy") public Date birthDate; Student(int id, Date birthDate){ this.id = id; this.birthDate = birthDate; } }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "birthDate" : "19-12-1984" }
Here we can see, without using @JsonFormat, Jackson is serializing the date to timestamp whereas using @JsonFormat annotation, we're specifying the format in which date is to be serialized.
Jackson Annotations - @JsonUnwrapped
Overview
@JsonUnwrapped annotation is used to unwrap values of objects during serialization or de-serialization.
Example - Serialization without using @JsonUnwrapped
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws IOException, ParseException{ ObjectMapper mapper = new ObjectMapper(); SimpleDateFormat simpleDateFormat = new SimpleDateFormat("dd-MM-yyyy"); Date date = simpleDateFormat.parse("20-12-1984"); Student.Name name = new Student.Name(); name.first = "Jane"; name.last = "Doe"; Student student = new Student(1, name); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } } class Student { public int id; public Name name; Student(int id, Name name){ this.id = id; this.name = name; } static class Name { public String first; public String last; } }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "name" : { "first" : "Jane", "last" : "Doe" } }
Example - Serialization with @JsonUnwrapped
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import com.fasterxml.jackson.annotation.JsonUnwrapped; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws IOException, ParseException{ ObjectMapper mapper = new ObjectMapper(); SimpleDateFormat simpleDateFormat = new SimpleDateFormat("dd-MM-yyyy"); Date date = simpleDateFormat.parse("20-12-1984"); Student.Name name = new Student.Name(); name.first = "Jane"; name.last = "Doe"; Student student = new Student(1, name); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } } class Student { public int id; @JsonUnwrapped public Name name; Student(int id, Name name){ this.id = id; this.name = name; } static class Name { public String first; public String last; } }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "first" : "Jane", "last" : "Doe" }
Here we can see, without using @JsonUnwrapped, Jackson is serializing the name object to a new JSON object whereas using @JsonUnwrapped annotation, we're able to unwrap name field and serialize them as other fields.
Jackson Annotations - @JsonView
Overview
@JsonView annotation is used to control values to be serialized or not.
How to use @JsonView
Define Views
class Views { static class Public {} static class Internal extends Public {} }
Annotate Properties with @JsonView
Here we've defined two scopes as Public and Internal. Now we'll control our serialization of values using @JsonView annotation.
class Student { @JsonView(Views.Public.class) public int id; @JsonView(Views.Public.class) public String name; @JsonView(Views.Internal.class) public int age; ... }
Serialize using required View defined above.
Now, during serialization, we can define using View, here Views.Public as which properties are to be serialized.
String jsonString = mapper .writerWithDefaultPrettyPrinter() .withView(Views.Public.class) .writeValueAsString(student);
Example - Serialization with @JsonView
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import com.fasterxml.jackson.annotation.JsonView; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws IOException, ParseException { ObjectMapper mapper = new ObjectMapper(); Student student = new Student(1, "Mark", 12); String jsonString = mapper .writerWithDefaultPrettyPrinter() .withView(Views.Public.class) .writeValueAsString(student); System.out.println(jsonString); } } class Student { @JsonView(Views.Public.class) public int id; @JsonView(Views.Public.class) public String name; @JsonView(Views.Internal.class) public int age; Student(int id, String name, int age) { this.id = id; this.name = name; this.age = age; } } class Views { static class Public {} static class Internal extends Public {} }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "name" : "Mark" }
Here we can see, using @JsonView annotation, we're able to control serialization of properties.
Jackson Annotations - @JsonManagedReference
Overview
@JsonManagedReferences and @JsonBackReferences are used to display objects with parent child relationship. @JsonManagedReferences is used to refer to parent object and @JsonBackReferences is used to mark child objects.
Creating Parent-Child Relationship
Annotate Parent
Here we're defining Student object as owner of the book and annotating with @JsonManagedReference.
class Book { public int id; public String name; ... @JsonManagedReference public Student owner; }
Annotate Child
Here we're defining List<Book> object as child of the student and annotating it using @JsonBackReference.
class Student { public int rollNo; public String name; @JsonBackReference public List<Book> books; ... }
Example - Serialization with @JsonManagedReference
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import java.util.ArrayList; import java.util.List; import com.fasterxml.jackson.annotation.JsonBackReference; import com.fasterxml.jackson.annotation.JsonManagedReference; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws IOException, ParseException { ObjectMapper mapper = new ObjectMapper(); Student student = new Student(1, "Mark"); Book book1 = new Book(1,"Learn HTML", student); Book book2 = new Book(1,"Learn JAVA", student); student.addBook(book1); student.addBook(book2); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(book1); System.out.println(jsonString); } } class Student { public int rollNo; public String name; @JsonBackReference public List<Book> books; Student(int rollNo, String name){ this.rollNo = rollNo; this.name = name; this.books = new ArrayList<Book>(); } public void addBook(Book book){ books.add(book); } } class Book { public int id; public String name; Book(int id, String name, Student owner){ this.id = id; this.name = name; this.owner = owner; } @JsonManagedReference public Student owner; }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "name" : "Learn HTML", "owner" : { "rollNo" : 1, "name" : "Mark" } }
Here we can see, using @JsonManagedReference and @JsonBackReferences annotations, we're able to define parent-child relationship.
Jackson Annotations - @JsonBackReferences
Overview
@JsonManagedReferences and @JsonBackReferences are used to display objects with parent child relationship. @JsonManagedReferences is used to refer to parent object and @JsonBackReferences is used to mark child objects.
Creating Parent-Child Relationship
Annotate Parent
Here we're defining Student object as owner of the book and annotating with @JsonManagedReference.
class Book { public int id; public String name; ... @JsonManagedReference public Student owner; }
Annotate Child
Here we're defining List<Book> object as child of the student and annotating it using @JsonBackReference.
class Student { public int rollNo; public String name; @JsonBackReference public List<Book> books; ... }
Example - Serialization with @JsonBackReferences
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import java.util.ArrayList; import java.util.List; import com.fasterxml.jackson.annotation.JsonBackReference; import com.fasterxml.jackson.annotation.JsonManagedReference; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws IOException, ParseException { ObjectMapper mapper = new ObjectMapper(); Student student = new Student(1, "Mark"); Book book1 = new Book(1,"Learn HTML", student); Book book2 = new Book(1,"Learn JAVA", student); student.addBook(book1); student.addBook(book2); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(book1); System.out.println(jsonString); } } class Student { public int rollNo; public String name; @JsonBackReference public List<Book> books; Student(int rollNo, String name){ this.rollNo = rollNo; this.name = name; this.books = new ArrayList<Book>(); } public void addBook(Book book){ books.add(book); } } class Book { public int id; public String name; Book(int id, String name, Student owner){ this.id = id; this.name = name; this.owner = owner; } @JsonManagedReference public Student owner; }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "name" : "Learn HTML", "owner" : { "rollNo" : 1, "name" : "Mark" } }
Here we can see, using JsonManagedReference and @JsonBackReferences annotations, we're able to define parent-child relationship.
Jackson Annotations - @JsonIdentityInfo
Overview
@JsonIdentityInfo is used when objects have parent child relationship. @JsonIdentityInfo is used to indicate that object identity will be used during serialization/de-serialization.
Creating Identity Info
Annotate Parent Class
Here we're defining Student object as owner of the book and annotating with @JsonIdentityInfo.
@JsonIdentityInfo( generator = ObjectIdGenerators.PropertyGenerator.class, property = "id") class Student { ... }
Annotate Child Class
Here we're defining Book as child object and annotating with @JsonIdentityInfo.
@JsonIdentityInfo( generator = ObjectIdGenerators.PropertyGenerator.class, property = "id") class Book{ ... }
Example - Serialization with @JsonIdentityInfo
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import java.util.ArrayList; import java.util.List; import com.fasterxml.jackson.annotation.JsonIdentityInfo; import com.fasterxml.jackson.annotation.ObjectIdGenerators; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws IOException, ParseException{ ObjectMapper mapper = new ObjectMapper(); Student student = new Student(1,13, "Mark"); Book book1 = new Book(1,"Learn HTML", student); Book book2 = new Book(2,"Learn JAVA", student); student.addBook(book1); student.addBook(book2); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(book1); System.out.println(jsonString); } } @JsonIdentityInfo( generator = ObjectIdGenerators.PropertyGenerator.class, property = "id") class Student { public int id; public int rollNo; public String name; public List<Book> books; Student(int id, int rollNo, String name){ this.id = id; this.rollNo = rollNo; this.name = name; this.books = new ArrayList<Book>(); } public void addBook(Book book){ books.add(book); } } @JsonIdentityInfo( generator = ObjectIdGenerators.PropertyGenerator.class, property = "id") class Book{ public int id; public String name; Book(int id, String name, Student owner){ this.id = id; this.name = name; this.owner = owner; } public Student owner; }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "name" : "Learn HTML", "owner" : { "id" : 1, "rollNo" : 13, "name" : "Mark", "books" : [ 1, { "id" : 2, "name" : "Learn JAVA", "owner" : 1 } ] } }
Here we can see, using JsonIdentityInfo to indicate object identify.
Jackson Annotations - @JsonFilter
Overview
@JsonIdentityInfo is used to apply filter during serialization/de-serialization like which properties are to be used or not.
Usage of @JsonFilter
Annotate Class with @JsonFilter
@JsonFilter("nameFilter") class Student { public int id; ... }
Create a Filter
FilterProvider filters = new SimpleFilterProvider() .addFilter( "nameFilter", SimpleBeanPropertyFilter.filterOutAllExcept("name"));
Apply the Filter
String jsonString = mapper.writer(filters) .withDefaultPrettyPrinter() .writeValueAsString(student);
Example - Serialization with @JsonFilter
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.text.ParseException; import com.fasterxml.jackson.annotation.JsonFilter; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.ser.FilterProvider; import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter; import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider; public class JacksonTester { public static void main(String args[]) throws IOException, ParseException { ObjectMapper mapper = new ObjectMapper(); Student student = new Student(1,13, "Mark"); FilterProvider filters = new SimpleFilterProvider() .addFilter( "nameFilter", SimpleBeanPropertyFilter.filterOutAllExcept("name")); String jsonString = mapper.writer(filters) .withDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } } @JsonFilter("nameFilter") class Student { public int id; public int rollNo; public String name; Student(int id, int rollNo, String name) { this.id = id; this.rollNo = rollNo; this.name = name; } }
Output
Run the JacksonTester and verify the output −
{ "name" : "Mark" }
Here we can see, using JsonFilter we're able to filter object properties.
Jackson Annotations - Custom Annotation
Overview
We can create custom annotation easily using @JacksonAnnotationsInside annotation.
Create a Custom Annotation
Create a Custom annotation which maintains property order and excludes null values during serialization.
@Retention(RetentionPolicy.RUNTIME) @JacksonAnnotationsInside @JsonInclude(value = Include.NON_NULL) @JsonPropertyOrder({ "rollNo", "id", "name" }) @interface CustomAnnotation {}
Apply the Custom Annotation
@CustomAnnotation class Student { ... }
Example - Serialization with Custom Annotation
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.text.ParseException; import com.fasterxml.jackson.annotation.JacksonAnnotationsInside; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.annotation.JsonInclude.Include; import com.fasterxml.jackson.annotation.JsonPropertyOrder; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) throws IOException, ParseException { ObjectMapper mapper = new ObjectMapper(); Student student = new Student(1,13, "Mark"); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } } @CustomAnnotation class Student { public int id; public int rollNo; public String name; public String otherDetails; Student(int id, int rollNo, String name){ this.id = id; this.rollNo = rollNo; this.name = name; } } @Retention(RetentionPolicy.RUNTIME) @JacksonAnnotationsInside @JsonInclude(value = Include.NON_NULL) @JsonPropertyOrder({ "rollNo", "id", "name" }) @interface CustomAnnotation {}
Output
Run the JacksonTester and verify the output −
{ "rollNo" : 13, "id" : 1, "name" : "Mark" }
Here we can see, using @JacksonAnnotationsInside to create a custom annotation and applied the same.
Jackson Annotations - Mixin Annotation
Overview
Mixin Annotation is a way to associate annotations without modifying the target class.
Create a class to be used as Mixin
Create a class where required annotation is applied.
@JsonIgnoreType class MixInForIgnoreType {}
Create a class where annotation is to be applied indirectly.
class Name { public String name; Name(String name){ this.name = name; } }
Apply the Mixin
ObjectMapper mapper = new ObjectMapper(); mapper.addMixIn(Name.class, MixInForIgnoreType.class);
Example - Serialization without Mixin Annotation
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) { try { ObjectMapper mapper = new ObjectMapper(); Student student = new Student(1,11,"1ab","Mark"); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { public int id; public String systemId; public int rollNo; public Name nameObj; Student(int id, int rollNo, String systemId, String name) { this.id = id; this.systemId = systemId; this.rollNo = rollNo; nameObj = new Name(name); } } class Name { public String name; Name(String name){ this.name = name; } }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "systemId" : "1ab", "rollNo" : 11, "nameObj" : { "name" : "Mark" } }
Example - Serialization with Mixin Annotation
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonIgnoreType; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]) { try { Student student = new Student(1,11,"1ab","Mark"); ObjectMapper mapper = new ObjectMapper(); mapper.addMixIn(Name.class, MixInForIgnoreType.class); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { public int id; public String systemId; public int rollNo; public Name nameObj; Student(int id, int rollNo, String systemId, String name) { this.id = id; this.systemId = systemId; this.rollNo = rollNo; nameObj = new Name(name); } } class Name { public String name; Name(String name){ this.name = name; } } @JsonIgnoreType class MixInForIgnoreType {}
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "systemId" : "1ab", "rollNo" : 11 }
Here we can see, using addMixin() method, we're able to apply annotations without modify the original class.
Jackson Annotations - Disable Annotation
Overview
We can disable jackson annotations using disable() function of ObjectMapper.
Disable Jackson Annotations
Using ObjectMapper.disble() method, we can easily disable the Jackson Annotations.
new ObjectMapper().disable(MapperFeature.USE_ANNOTATIONS);
Example - Serialization without disabling Annotation
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonIgnoreType; import com.fasterxml.jackson.databind.MapperFeature; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ try{ ObjectMapper mapper = new ObjectMapper(); Student student = new Student(1,11,"1ab","Mark"); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { public int id; public String systemId; public int rollNo; public Name nameObj; Student(int id, int rollNo, String systemId, String name){ this.id = id; this.systemId = systemId; this.rollNo = rollNo; nameObj = new Name(name); } } @JsonIgnoreType class Name { public String name; Name(String name){ this.name = name; } }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "systemId" : "1ab", "rollNo" : 11 }
Example - Serialization with disabled Annotation
JacksonTester.java
package com.tutorialspoint; import java.io.IOException; import com.fasterxml.jackson.annotation.JsonIgnoreType; import com.fasterxml.jackson.databind.MapperFeature; import com.fasterxml.jackson.databind.ObjectMapper; public class JacksonTester { public static void main(String args[]){ try{ Student student = new Student(1,11,"1ab","Mark"); ObjectMapper mapper = new ObjectMapper(); mapper.disable(MapperFeature.USE_ANNOTATIONS); String jsonString = mapper .writerWithDefaultPrettyPrinter() .writeValueAsString(student); System.out.println(jsonString); } catch (IOException e) { e.printStackTrace(); } } } class Student { public int id; public String systemId; public int rollNo; public Name nameObj; Student(int id, int rollNo, String systemId, String name){ this.id = id; this.systemId = systemId; this.rollNo = rollNo; nameObj = new Name(name); } } @JsonIgnoreType class Name { public String name; Name(String name){ this.name = name; } }
Output
Run the JacksonTester and verify the output −
{ "id" : 1, "systemId" : "1ab", "rollNo" : 11, "nameObj" : { "name" : "Mark" } }
Here we can see, using disable() method, we're able to disable jackson annotations to be processed.