Introducción al marco de Jackson

En una fría noche de primavera, finalmente alcancé el nivel 33. Frotándome las manos de programador, ya me estaba preparando para abarcar todo el campo de la serialización y deserialización JSON, pero, lamentablemente, no entendí nada. No recordaba el texto de la conferencia, pero los problemas se resolvieron de alguna manera intuitiva. En este sentido, decidí profundizar en el marco de Jackson y descubrir qué es este JSON. Intentaré presentar todos mis conocimientos de forma práctica y concisa en formato de hoja de referencia (tanto para mí como para los lectores). Anotaciones del viaje a Jackson. Lo primero que encontramos en el camino hacia JSON es la anotación @JsonAutoDetect. A primera vista, es un resumen sencillo, pero al autor le llevó más tiempo descifrarlo. El resumen tiene 5 métodos que necesitamos:

• fieldVisibility (): serializa solo campos con el modificador de acceso especificado
• getterVisibility()/setterVisibility() - serializa campos cuyo getter/setter tiene el modificador de acceso especificado
• isGetterVisibility() - implementación separada para captadores booleanos

Es importante comprender que los métodos funcionan de forma disyuntiva. Aquellos. si el campo coincide con al menos uno de los parámetros especificados en la anotación, se incluirá en JSON. Intente responder qué generará este código si creamos una instancia usando un constructor sin parámetros:

@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.PUBLIC_ONLY,
        getterVisibility        = JsonAutoDetect.Visibility.PUBLIC_ONLY,
        setterVisibility        = JsonAutoDetect.Visibility.PUBLIC_ONLY,
        isGetterVisibility      = JsonAutoDetect.Visibility.PROTECTED_AND_PUBLIC)
public class HeadClass {
    public String name;
    private Map<String, String> properties;
    public Queue<String> queue;
    protected List<String> list;
    private int age;
    private int number;
    private boolean isHead;

    protected HeadClass(int age) {
        this.age = age;
    }

    public HeadClass() {}

    Map<String, String> getProperties() {
        return properties;
    }

    protected boolean isHead() {
        return isHead;
    }

    protected void setProperties(Map<String, String> properties) {
        this.properties = properties;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

¿Qué pasa si eliminamos isGetterVisibility? Los cuatro métodos enumerados configuraron el proceso de serialización. El quinto, a su vez, regula el proceso de deserialización:

• CreatorVisibility() es el método más difícil de entender. Funciona con constructores y con métodos de fábrica (métodos que crean un objeto cuando se llama). Veamos un ejemplo:

@JsonAutoDetect(creatorVisibility = JsonAutoDetect.Visibility.PROTECTED_AND_PUBLIC)
public class HeadClass {
    public String name;
    public int id;

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

    protected HeadClass(String name) {
        this.name = name;
        this.id = 123;
    }

    protected HeadClass(int id) {
        this.id = id;
        this.name = "Yes!";
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public static void main(String[] args) throws Exception {
    ObjectMapper mapper = new ObjectMapper();
    String forDeserialize = "{\"name\":\"No!\",\"id\":123}";
    StringReader reader = new StringReader(forDeserialize);

    HeadClass headClass1 = (HeadClass) mapper.readValue(reader, HeadClass.class);
}

¡Nota importante sobre el mecanismo de deserialización! Cuando intentamos crear un objeto a partir de JSON, se buscará el constructor de la clase requerida con el mismo conjunto de parámetros que en el objeto JSON. En el ejemplo anterior, nuestro objeto JSON consta de dos parámetros: nombre, identificación. Adivina a qué constructor llamará. Y sí, si compilamos este código arrojará un error, ¿por qué? Porque hemos limitado la visibilidad del constructor (solo son visibles los constructores con el modificador público protegido). Si eliminas CreatorVisibility, funcionará. Surge la pregunta. ¿Qué es @JsonProperty en el constructor? Creo que hablaré de esto en la siguiente parte del artículo. PD : Señores, me gustaría mucho recibir al menos alguna respuesta sobre el artículo. Me pregunto si este tema tiene demanda y si vale la pena continuar, porque hay muchos temas y todos son muy interesantes. También me gustaría considerar anotaciones como @JsonView, @JsonMangedReference, @JsonBackReference, @JsonUnwrapped, etc. Gracias :)