Serialización en JSON

"¡Hola, amigo!"

"¡Hola, Ellie!"

"Como ya te han presentado JSON, hablemos más sobre eso hoy".

"Está bien. ¿Dónde se suele usar?"

"Así es como suele funcionar. Alguien (el cliente) solicita datos de un programa Java (el servidor). El programa crea objetos Java y los llena con información de la base de datos. Luego los convierte a un formato que el solicitante (el cliente) ) puede entender, como JSON, y los devuelve".

"Déjame decirte cómo trabajar con JSON en Java. Básicamente, solo necesitamos hacer dos cosas: serializar objetos Java en formato JSON y deserializar objetos Java del formato JSON".

"En otras palabras, JSON es un estándar para enviar mensajes/datos de un programa a otro. Hay muchos estándares como ese. Pero si el programa está escrito en JavaScript, generalmente intenta usar JSON".

"OK estoy listo."

"Genial. Entonces comencemos".

"Como ya sabe, Java tiene herramientas de serialización estándar incorporadas. Pero no son compatibles con JSON. Por lo tanto, si necesita serializar un objeto en JSON, puede usar uno de los marcos populares (bibliotecas) que saben cómo hacer esto."

"¿Cuál es la diferencia entre estos diferentes marcos?"

"Por lo general, difieren en su nivel de complejidad: hay marcos que solo pueden hacer lo básico, pero son muy pequeños y simples. Y hay marcos grandes y complejos que pueden hacer mucho más".

"Jackson es uno de los marcos más populares. Lo usaremos como ejemplo cuando veamos cómo trabajar con JSON".

"Primero, debe descargar este marco y agregarlo a su proyecto. Debe hacerlo directamente en IntelliJ IDEA. Puede descargar el marco usando este enlace ".

"Hecho."

"Genial. Sigamos, entonces."

"Convertir un objeto Java en JSON es tan fácil como serializarlo. Para hacer esto, hay una clase especial ObjectMapper (com.fasterxml.jackson.databind.ObjectMapper)".

"Déjame mostrarte un ejemplo práctico y luego lo analizaremos:"

public static void main(String[] args) throws IOException
{
 // Create an object to be serialized into JSON
 Cat cat = new Cat();
 cat.name = "Missy";
 cat.age = 5;
 cat.weight = 4;

 // Write the result of the serialization to a StringWriter
 StringWriter writer = new StringWriter();

 // This is the Jackson object that performs the serialization
 ObjectMapper mapper = new ObjectMapper();

 // And here's the serialization itself: the first argument is where, and the second is what
 mapper.writeValue(writer, cat);

 // Convert everything written to the StringWriter into a String
 String result = writer.toString();
 System.out.println(result);
}

@JsonAutoDetect
class Cat
{
 public String name;
 public int age;
 public int weight;
Cat(){}
}

{"name":"Missy", "age":5, "weight":4}

"Así es como funciona:"

"En las líneas 4-7, creamos un objeto Cat y lo llenamos con datos".

"En la línea 10, creamos un objeto Writer donde escribiremos una representación de cadena JSON del objeto".

"En la línea 13, creamos un objeto ObjectMapper que realizará toda la serialización".

"En la línea 16, escribimos la representación JSON del objeto gato en escritor ".

"En las líneas 19-20, mostramos el resultado en la pantalla".

"Todo parece bastante simple. No es más difícil que la serialización nativa en Java".

"¿Cómo sería la deserialización?"

"Es casi lo mismo, solo que más corto:"

public static void main(String[] args) throws IOException
{
 String jsonString = "{ \"name\":\"Missy\", \"age\":5, \"weight\":4}";
 StringReader reader = new StringReader(jsonString);

 ObjectMapper mapper = new ObjectMapper();

 Cat cat = mapper.readValue(reader, Cat.class);
}

@JsonAutoDetect
class Cat
{
 public String name;
 public int age;
 public int weight;

 Cat() { }
}

"Es aún más fácil. Tomamos ObjectMapper y le pasamos una cadena o un StringReader con JSON, así como la clase del objeto que se va a deserializar . Luego llamamos al método readValue y, como salida, obtenemos un objeto Java listo para usar con todos los datos".

"Bueno, eso es exactamente como la deserialización en Java".

"Casi. Hay varios requisitos impuestos a los objetos serializados o deserializados de JSON:"

" 1)  los campos deben ser visibles: deben ser públicos o tener captadores y definidores"

" 2)  debe haber un constructor predeterminado (uno sin parámetros)"

"Ya veo. Eso no es demasiado sorprendente. Pero Java serializó todo, incluso los campos privados".

"Bueno, eso fue Java. Tiene acceso a datos ocultos. No puedes esconderte de ti mismo".

"Hay un tercer aspecto aquí. Espero que hayas notado la anotación @JsonAutoDetect en la clase Cat".

"Sí. Estaba a punto de preguntar qué era".

"Es una anotación: información de limpieza para el marco de Jackson. Al usar las anotaciones correctas, tiene un control bastante flexible sobre los resultados de la serialización en JSON".

"¡Genial! ¿Qué tipo de anotaciones hay?"

"Aquí están algunos ejemplos:"

"¡Qué interesante! ¿Hay más?"

"Hay muchos. Pero no los cubriremos ahora. Ahora reelaboremos un poco nuestro primer ejemplo:"

public static void main(String[] args) throws IOException
{
 Cat cat = new Cat();
 cat.name = "Missy";
 cat.age = 5;
 cat.weight = 4;

 StringWriter writer = new StringWriter();

 ObjectMapper mapper = new ObjectMapper();

 mapper.writeValue(writer, cat);

 String result = writer.toString();
 System.out.println(result);
}

@JsonAutoDetect
class Cat
{
 @JsonProperty("alias")
 public String name;
 public int age;
 @JsonIgnore
 public int weight;

 Cat() {
 }
}

{"age":5, "alias":"Missy"}

"El código sigue siendo el mismo, pero cambié las anotaciones: especifiqué otro nombre para el campo de nombre: alias. También marqué el campo de peso como Ignorar, lo que provocó que el objeto JSON cambiara".

"Es bueno que puedas personalizar todo así. Creo que definitivamente lo encontraré útil".

"¿Y la deserialización entenderá cómo trabajar con esto? Al deserializar de JSON a un objeto Java, ¿el valor del campo de alias se escribirá en el campo de nombre del objeto Cat?"

"Sí, la deserialización funcionará como debería. Es inteligente".

"¿Por qué no estar feliz entonces?"

"Gracias por esta interesante lección, Ellie".