Anotaciones de Jackson - Guía rápida
@JsonAnyGetter permite que un método getter devuelva Map que luego se usa para serializar las propiedades adicionales de JSON de manera similar a otras propiedades.
Ejemplo sin @JsonAnyGetter
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);
}
}
Salida
{
"properties" : {
"RollNo" : "1",
"Name" : "Mark"
}
}
Ejemplo con @JsonAnyGetter
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);
}
}
Salida
{
"RollNo" : "1",
"Name" : "Mark"
}
@JsonGetter permite marcar un método específico como método getter.
Ejemplo sin @JsonGetter
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;
}
}
Salida
{
"studentName" : "Mark",
"rollNo" : 1
}
Ejemplo con @JsonGetter
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;
}
}
Salida
{
"name" : "Mark",
"rollNo" : 1
}
@JsonPropertyOrder permite conservar un orden específico mientras se serializa un objeto JSON.
Ejemplo sin @JsonPropertyOrder
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;
}
}
Salida
{
"name" : "Mark",
"rollNo" : 1
}
Ejemplo @JsonPropertyOrder
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;
}
}
Salida
{
"name" : "Mark",
"rollNo" : 1
}
@JsonRawValue permite serializar un texto sin escaparse o sin ningún tipo de decoración.
Ejemplo sin @JsonRawValue
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;
}
}
Salida
{
"name" : "Mark",
"rollNo" : 1,
"json" : {\"attr\":false}
}
Ejemplo con @JsonRawValue
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;
}
}
Salida
{
"name" : "Mark",
"rollNo" : 1,
"json" : {"attr":false}
}
@JsonValue permite serializar un objeto completo usando su único método.
Ejemplo @JsonValue
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 + " }";
}
}
Salida
"{ name : Mark }"
@JsonRootNamepermite tener un nodo raíz especificado sobre JSON. Necesitamos habilitar también el valor de raíz de ajuste.
Ejemplo @JsonRootName
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;
}
}
Salida
{
"student" : {
"name" : "Mark",
"rollNo" : 1
}
}
@JsonSerialize se usa para especificar un serializador personalizado para ordenar el objeto json.
Ejemplo con @JsonSerialize
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));
}
}
Salida
{
"name" : "Mark",
"rollNo" : 1,
"dateOfBirth" : "20-11-1984"
}
@JsonCreatorse utiliza para ajustar el constructor o el método de fábrica utilizado en la deserialización. Usaremos @JsonProperty también para lograr lo mismo. En el siguiente ejemplo, estamos haciendo coincidir un json con un formato diferente a nuestra clase definiendo los nombres de propiedad requeridos.
Ejemplo @JsonCreator
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;
}
}
Salida
1, Mark
@JacksonInjectse usa cuando se va a inyectar un valor de propiedad en lugar de analizarlo desde la entrada de Json. En el siguiente ejemplo, estamos insertando un valor en el objeto en lugar de analizar desde el Json.
Ejemplo @JacksonInject
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;
}
Salida
1, Mark
@JsonAnySetter permite que un método de establecimiento use Map, que luego se usa para deserializar las propiedades adicionales de JSON de manera similar a otras propiedades.
Ejemplo @JsonAnySetter
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);
}
}
Salida
Mark
1
@JsonSetter permite marcar un método específico como método de establecimiento.
Ejemplo @JsonSetter
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.name);
}
catch (IOException e) {
e.printStackTrace();
}
}
}
class Student {
public int rollNo;
public String name;
@JsonSetter("name")
public void setTheName(String name) {
this.name = name;
}
}
Salida
Marks
@JsonDeserialize se usa para especificar un deserializador personalizado para deshacer el orden del objeto json.
Ejemplo @JsonDeserialize
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(Class<Date> t) {
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;
}
}
Salida
Thu Dec 20 00:00:00 IST 1984
@JsonEnumDefaultValue se usa para deserializar un valor de enumeración desconocido usando un valor predeterminado.
Ejemplo @JsonEnumDefaultValue
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
}
Salida
UNKNOWN
@JsonIgnoreProperties se utiliza a nivel de clase para marcar una propiedad o lista de propiedades que se ignorarán.
Ejemplo: @JsonIgnoreProperties
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;
}
}
Salida
{
"rollNo" : 11,
"name" : "Mark"
}
@JsonIgnore se utiliza a nivel de campo para marcar una propiedad o lista de propiedades que se ignorarán.
Ejemplo: @JsonIgnore
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;
}
}
Salida
{
"id" : 1,
"rollNo" : 11,
"name" : "Mark"
}
@JsonIgnoreType se utiliza para marcar una propiedad de tipo especial para ignorarla.
Ejemplo: @JsonIgnoreType
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;
@JsonIgnore
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;
}
}
}
Salida
{
"id" : 1,
"systemId" : "1ab",
"rollNo" : 11
}
@JsonInclude se utiliza para excluir propiedades que tienen valores nulos / vacíos o predeterminados.
Ejemplo: @JsonInclude
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;
}
}
Salida
{
"id" : 1
}
@JsonAutoDetect se puede utilizar para incluir propiedades a las que no se puede acceder de otro modo.
Ejemplo: @JsonAutoDetect
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;
}
}
Salida
{
"id" : 1,
"name" : "Mark"
}
@JsonTypeInfo se utiliza para indicar detalles de la información de tipo que se incluirá en la serialización y deserialización.
Ejemplo: @JsonTypeInfo
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;
}
}
}
Salida
{
"type" : "circle",
"name" : "CustomCircle",
"radius" : 1.0
}
CustomCircle
@JsonSubTypes se utiliza para indicar subtipos de tipos anotados.
Ejemplo: @JsonSubTypes
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;
}
}
}
Salida
{
"type" : "circle",
"name" : "CustomCircle",
"radius" : 1.0
}
CustomCircle
@JsonTypeName se utiliza para establecer los nombres de los tipos que se utilizarán para la clase anotada.
Ejemplo: @JsonTypeName
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;
}
}
}
Salida
{
"type" : "circle",
"name" : "CustomCircle",
"radius" : 1.0
}
CustomCircle
@JsonProperty se usa para marcar el método getter / setter no estándar que se usará con respecto a la propiedad json.
Ejemplo: @JsonProperty
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;
}
}
Salida
1
@JsonFormatse utiliza para especificar el formato durante la serialización o deserialización. Se utiliza principalmente con campos de fecha.
Ejemplo: @JsonFormat
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;
}
}
Salida
{
"id" : 1,
"birthDate" : "19-12-1984"
}
@JsonUnwrapped se utiliza para desenvolver valores de objetos durante la serialización o deserialización.
Ejemplo: @JsonUnwrapped
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;
}
}
Salida
{
"id" : 1,
"first" : "Jane",
"last" : "Doe"
}
@JsonView se utiliza para controlar los valores que se van a serializar o no.
Ejemplo: @JsonView
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 {}
}
Salida
{
"id" : 1,
"name" : "Mark"
}
@JsonManagedReferences y JsonBackReferences se utilizan para mostrar objetos con relación padre-hijo. @JsonManagedReferences se utiliza para referirse al objeto principal y @JsonBackReferences se utiliza para marcar objetos secundarios.
Ejemplo: @JsonManagedReferences
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;
}
Salida
{
"id" : 1,
"name" : "Learn HTML",
"owner" : {
"rollNo" : 1,
"name" : "Mark"
}
}
@JsonManagedReferences y JsonBackReferences se utilizan para mostrar objetos con relación padre-hijo. @JsonManagedReferences se utiliza para referirse al objeto principal y @JsonBackReferences se utiliza para marcar objetos secundarios.
Ejemplo: @JsonBackReferences
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;
}
Salida
{
"id" : 1,
"name" : "Learn HTML",
"owner" : {
"rollNo" : 1,
"name" : "Mark"
}
}
@JsonIdentityInfo se usa cuando los objetos tienen una relación padre-hijo. @JsonIdentityInfo se usa para indicar que la identidad del objeto se usará durante la serialización / deserialización.
Ejemplo: @JsonIdentityInfo
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;
}
Salida
{
"id" : 1,
"name" : "Learn HTML",
"owner" : {
"id" : 1,
"rollNo" : 13,
"name" : "Mark",
"books" : [
1, {
"id" : 2,
"name" : "Learn JAVA",
"owner" : 1
}
]
}
}
@JsonFilter se usa para aplicar filtros durante la serialización / deserialización, como qué propiedades se deben usar o no.
Ejemplo: @JsonFilter
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;
}
}
Salida
{
"name" : "Mark"
}
Podemos crear una anotación personalizada fácilmente usando la anotación @JacksonAnnotationsInside.
Ejemplo: anotación personalizada
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 {}
Salida
{
"rollNo" : 13,
"id" : 1,
"name" : "Mark"
}
Mixin Annotation es una forma de asociar anotaciones sin modificar la clase de destino. Vea el ejemplo a continuación:
Ejemplo: anotación Mixin
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[]) {
ObjectMapper mapper = new ObjectMapper();
try {
Student student = new Student(1,11,"1ab","Mark");
String jsonString = mapper
.writerWithDefaultPrettyPrinter()
.writeValueAsString(student);
System.out.println(jsonString);
ObjectMapper mapper1 = new ObjectMapper();
mapper1.addMixIn(Name.class, MixInForIgnoreType.class);
jsonString = mapper1
.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 {}
Salida
{
"id" : 1,
"systemId" : "1ab",
"rollNo" : 11,
"nameObj" : {
"name" : "Mark"
}
}
{
"id" : 1,
"systemId" : "1ab",
"rollNo" : 11
}
Podemos deshabilitar las anotaciones de Jackson usando la función disable () de ObjectMapper.
Ejemplo: deshabilitar la anotación
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[]){
ObjectMapper mapper = new ObjectMapper();
try{
Student student = new Student(1,11,"1ab","Mark");
String jsonString = mapper
.writerWithDefaultPrettyPrinter()
.writeValueAsString(student);
System.out.println(jsonString);
ObjectMapper mapper1 = new ObjectMapper();
mapper1.disable(MapperFeature.USE_ANNOTATIONS);
jsonString = mapper1
.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;
}
}
Salida
{
"id" : 1,
"systemId" : "1ab",
"rollNo" : 11
}
{
"id" : 1,
"systemId" : "1ab",
"rollNo" : 11,
"nameObj" : {
"name" : "Mark"
}
}