JSON es un formato de archivo estándar abierto y un formato de intercambio de datos más fácil y útil para que los humanos transmitan datos. La mayoría de las aplicaciones muestran datos JSON y, por lo tanto, hoy en día JSON se ha convertido en el medio obligatorio para transmitir datos. Aquí conoceremos cómo convertir Map a JSON y, para Map, tomemos HashMap como un conjunto de datos de entrada.
Instalación:
Paso 1: para las partes de Java relacionadas con la consola, necesitamos las descargas de jar de los enlaces que se proporcionan a continuación. Descargue los frascos, extráigalos y colóquelos en la ruta de compilación de un proyecto
http://www.java2s.com/Code/Jar/j/Downloadjacksonannotations212jar.htm
http://www.java2s.com/Code/Jar/c/Downloadcomfasterxmljacksondatabindjar.htm
Paso 2(A): Para los proyectos de Maven, se necesita la siguiente dependencia en el ‘ archivo pom.xml’.
<dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.9.6</version> </dependency>
Paso 2(B): Para proyectos Gradle , es el siguiente:
dependencies
{
// a dependency on Jackson Databind
implementation 'com.fasterxml.jackson.core:jackson-databind:2.8.9'
}
Implementación:
Veamos un ejemplo de HashMap de datos. La ventaja de HashMap es almacenar los datos en pares de clave y valor de forma no sincronizada.
Vamos a tener studentId,studentFirstName,studentLastName,studentStream y studentMarks como los elementos clave de HashMap. Usando com.fasterxml.jackson.databind.ObjectMapper, estamos convirtiendo HashMap en JSON. Veamos una aplicación Java simple. ObjectMapper es la principal clase esencial en la biblioteca Jackson que ayuda a leer y escribir JSON, ya sea hacia y desde POJO básicos (Plain Old Java Objects) o desde HashMap que contiene pares clave/valor.
Aquí usaremos un método llamado ‘writeValueAsString()’ en el código y que se puede usar para serializar cualquier valor de Java como una string. Aquí estamos pasando HashMap de datos como objetos, y los serializa como strings. Como se usa ObjectMapper, escribe una string JSON.
Ejemplo 1:
Java
// Java Program to Convert Map to JSON to HashMap
// Importing required basic libraries
// Importing required classes from com.fasterxml.jackson
// package
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.util.HashMap;
// Main class
// MapToJSONExample
public class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating an object of HashMap class
// Declaring object of String and Object type
HashMap<String, Object> studentHashmap
= new HashMap<String, Object>();
// Let us hold studentHashmap containing
// 1. studentId
// 2. studentFirstName
// 3. studentLastName
// 4. studentStream
// 5. studentMarks
// Custom input entries
studentHashmap.put("studentId", 1);
studentHashmap.put("studentFirstName", "AAA");
studentHashmap.put("studentLastName", "BBB");
studentHashmap.put("studentStream", "PCMB");
studentHashmap.put("studentMarks", "480");
// ObjectMapper object is a reusable object.
// ObjectMapper is the main essential class in
// Jackson library which helps for reading and
// writing JSON, either to and from basic POJOs
// (Plain Old Java Objects) or from HashMap
// containing key/value pairs.
ObjectMapper mapper = new ObjectMapper();
// Try block to check fo exceptions
try {
// Convert studentHashmap to JSON
// In method writeValueAsString(Object object),
// we are using this method in the code and that
// can be used to serialize any Java value as a
// String. Here we are passing HashMap of data
// as object and it serializes them as string .
// As ObjectMapper is used, it writes JSON
// string
String studentJson
= mapper.writeValueAsString(studentHashmap);
// Print JSON output
System.out.println(studentJson);
}
// There are possibilities of following exceptions,
// so catch block to handle the exceptions
catch (JsonGenerationException e) {
// Printing the exception along with line number
// using the printStackTrace() method
e.printStackTrace();
}
// Catch block 2
catch (JsonMappingException e) {
e.printStackTrace();
}
// Catch block 3
// Catching generic input output exceptions
catch (IOException e) {
e.printStackTrace();
}
}
}
Producción:
Pasando al siguiente ejemplo. En este ejemplo, veamos cómo los datos JSON se convierten en mapas mediante ObjectMapper. Usaremos readValue() aquí que deserializará el contenido JSON en un tipo que no sea contenedor. Aquí, en este ejemplo, como clase de mapa, el contenido JSON se deserializa.
readValue(JsonParser p, Class<T> valueType)
Ejemplo 2:
Java
// Java Program to Convert Map to JSON to HashMap
// Importing utility and input output classes
// Importing ObjectMapper class
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.util.Map;
// Main class
// To convert JSON to Map
public class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating an object of ObjectMapper class
// in the main() method
ObjectMapper mapper = new ObjectMapper();
// Custom string data in JSON
String studentJsonData
= "{\"studentId\":\"1\", \"studentFirstName\":\"AAA\",\"studentLastName\":\"BBB\",\"studentStream\":\"PCMB\",\"studentMarks\":\"480\"}";
// Try block to handle the exceptions
try {
// Convert JSON string to Map
// This method deserializes JSON content into a
// non-container type. In our example as a Map
// class, JSON content is deserialized.
Map<String, String> studentMapData
= mapper.readValue(studentJsonData,
Map.class);
System.out.println(studentMapData);
}
// Catch block to handle the exceptions
catch (IOException e) {
// Display and print the exceptions along with
// line number using printStackTrace() method
e.printStackTrace();
}
}
}
Producción:
Explicación de salida:
Aquí, como hemos visto en el ejemplo 1 y el ejemplo 2, tiene la posibilidad de producir JsonMappingException que puede ocurrir cuando «No se puede construir una instancia de»/»No hay un constructor adecuado»/»El nombre raíz no coincide con lo esperado»/»No se encontró un serializador para la clase ” etc. Entonces, siempre que haya una conversión de HashMap a JSON o JSON a HashMap, existen posibilidades de la excepción anterior y, por lo tanto, debemos manejarla. Aparte de eso, JsonGenerationException y IOException también son posibles, y debemos manejarlo.
Pasando al siguiente ejemplo, consideremos un ejemplo un poco complejo y proporcionemos los resultados a través de JunitTestCase. Aquí estamos deserializando contenido JSON en la clase POJO
Ejemplo 3(A): clases POJO, a saber, Automobiles.java que contienen 3 atributos, a saber, color/tipo/nombre
Java
// Java Program illustratiing Simple POJO class only
// containing 3 attributes namely color/type/name
public class Automobiles {
// Any kind of automobiles can have these attributes and
// for simplicity let us keep this
private String color;
private String type;
private String name;
// Constructor 1
// Default constructor of this class
public Automobiles() {}
// Constructor 2
// Parameterized constructor of this class
public Automobiles(final String color,
final String type, final String name)
{
// This keyword refers to current instance itself
this.color = color;
this.type = type;
this.name = name;
}
// Method 1
public String getName() { return name; }
// Method 2
public void setName(String name) { this.name = name; }
// Method 3
public String getColor() { return color; }
// Method 4
public void setColor(final String color)
{
this.color = color;
}
// Method 5
public String getType() { return type; }
// Method 6
public void setType(final String type)
{
this.type = type;
}
}
Ahora escribamos JunitTestCases y verifiquemos cómo funciona DeserializationFeature en el siguiente ejemplo de la siguiente manera:
Ejemplo 3(B):
Java
// Java Program to Convert Map to JSON to HashMap
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.Test;
public class
SerializationDeserializationFeatureUnitTestExample {
final String EXAMPLE_JSON
= "{ \"color\" : \"Black\", \"type\" : \"BMW\" }";
final String JSON_CAR
= "{ \"color\" : \"Red\", \"type\" : \"Honda WRV\", \"year\" : \"2018\" }";
final String JSON_ARRAY
= "[{ \"color\" : \"Blue\", \"type\" : \"Sedan\",\"name\" : \"Honda City\" }, { \"color\" : \"Red\", \"type\" : \"Hatchback\",\"name\" : \"Santro\" }]";
@Test
public void
whenFailOnUnkownPropertiesFalse_thanJsonReadCorrectly()
throws Exception
{
// ObjectMapper is the main essential class in
// Jackson library which helps for reading and
// writing JSON, and in this example it is from POJO
// class that is our Automobiles class
final ObjectMapper objectMapper
= new ObjectMapper();
// Reason for setting
// DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES
// to false is that it will tell Jackson to ignore
// unknown attributes in all deserializations where
// that object mapper is used.
objectMapper.configure(
DeserializationFeature
.FAIL_ON_UNKNOWN_PROPERTIES,
false);
// readValue(JsonParser p, Class<T> valueType) -
// This method deserializes JSON content into a
// non-container type. In our example it is
// Automobiles class, JSON content is deserialized.
final Automobiles automobiles
= objectMapper.readValue(JSON_CAR,
Automobiles.class);
assertNotNull(automobiles);
}
@Test
public void
whenUseJavaArrayForJsonArrayTrue_thanJsonReadAsArray()
throws Exception
{
final ObjectMapper objectMapper
= new ObjectMapper();
// Reason for setting
// DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES
// to true is that it will tell Jackson to consider
// attributes in all deserializations where that
// object mapper is used.
objectMapper.configure(
DeserializationFeature
.USE_JAVA_ARRAY_FOR_JSON_ARRAY,
true);
final Automobiles[] automobiles
= objectMapper.readValue(JSON_ARRAY,
Automobiles[].class);
for (final Automobiles car : automobiles) {
assertNotNull(car);
}
assertTrue(
automobiles[1].getName().equalsIgnoreCase(
"Santro"));
assertTrue(
automobiles[0].getType().equalsIgnoreCase(
"Sedan"));
}
}
Salida: después de ejecutar estos JUnits
Conclusión: La construcción de Map to JSON y la forma inversa de JSON to Map son los mecanismos estándar seguidos en la industria del software. Son muy útiles en muchos lugares de proyectos de software.
Publicación traducida automáticamente
Artículo escrito por priyarajtt y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA