Convertir JSON a XML Java usando Gson y JAXB con ejemplo

¿Qué es el JSON?

JSON es una abreviatura de Javascript Notación de objetos, que es una forma de datos que sigue una determinada regla que la mayoría de los lenguajes de programación actuales pueden leer. Podemos guardarlo fácilmente en un archivo o registro en la base de datos. El formato JSON utiliza pares clave-valor para describir los datos.

Siguiendo el ejemplo, definimos una cadena JSON que almacena información personal:

{
"username" : "guru99user",
"email" : "guru99user@mail.com"	
}

Entonces la sintaxis de JSON es muy simple. Cada información de datos tendrá dos partes: clave y valor que corresponden al nombre del campo y su valor en un determinado registro. Pero si miramos más a fondo, hay algunas cosas como esta:

• La cadena JSON está encerrada entre llaves {}.
• Las claves y valores de JSON deben estar entre comillas {“}.
• Si hay más datos (más pares clave => valor), usamos comas (,) para separar.
• Las claves JSON deben consistir en letras o números sin signo, _, y sin espacios; el primer carácter no debe ser un número.

¿Qué es XML?

XML significa eXtensible Markup Language, también llamado lenguaje de marcado extensible propuesto por el World Wide Web Consortium (https://www.w3.org/) para crear otros lenguajes de marcado. Este es un subconjunto simple que puede describir muchos tipos diferentes de datos, por lo que es muy útil para compartir datos entre sistemas.

Las etiquetas en XML a menudo no están predefinidas, pero se crean según las convenciones del usuario. XML introduce nuevas características basadas en las ventajas del HTML.

Hay algunas funciones de creación de XML más útiles en diversos sistemas y soluciones:

• XML es extensible: XML le permite crear sus propias etiquetas personalizadas para adaptarse a su aplicación.
• XML transporta datos, no los muestra: XML le permite almacenar datos independientemente de cómo se mostrarán.
• XML es un estándar común: XML fue desarrollado por el World Wide Web Consortium (W3C) y está disponible como estándar abierto.

XML se basa en una estructura de nodos anidados. Cada nodo tendrá una etiqueta de apertura y una etiqueta de cierre de la siguiente manera:

<node>content</node>

En el cual:

• es una etiqueta abierta, el nombre de esta etiqueta lo define usted.
• es una etiqueta cerrada, el nombre de esta etiqueta debe coincidir con el nombre de la etiqueta abierta.
• contenido es el contenido de esta etiqueta.

En la parte superior de cada archivo XML debe declarar una etiqueta para indicar la versión XML que está en uso. La sintaxis de la etiqueta de instrucción:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

¿Qué es Gson?

gson (https://github.com/google/gson) es una biblioteca de Java que permite a los usuarios convertir desde un Java objeto a cadena JSON y también convertir de una cadena JSON a Java objeto. Gson puede trabajar con arbitrario Java objetos, incluidos objetos existentes sin que usted tenga su código fuente.

Desde la versión 1.6, Gson introduce dos nuevas clases: JsonReader y JsonEscritor para proporcionar procesamiento de streaming en datos JSON.

• JsonEscritor – Streaming de escritura en JSON. La sintaxis para la implementación general es la siguiente. Creamos un JsonEscritor objeto. Para comenzar y terminar de crear una cadena JSON, usamos la función comenzarObjeto() y objeto final(). En medio de la ejecución de estas dos funciones, realizamos la escritura de datos con pares (clave => valor).

JsonWriter writer = new JsonWriter();
writer.beginObject();
writer.name("key").value("value");
writer.endObject();

• JsonReader – Lectura en streaming desde JSON. La sintaxis para la implementación general es la siguiente. Creamos un objeto JsonReader. Para comenzar y terminar de crear una cadena JSON, usamos las funciones beginObject() y endObject(). En medio de la ejecución de estas dos funciones, realizamos la lectura de datos con pares (clave => valor).

JsonReader reader = new JsonReader();
reader.beginObject();
while (reader.hasNext()) {
	String name = reader.nextName();
	if (name.equals("key")) {
		String value = reader.nextString();
	}
}
reader.endObject();

El procesamiento de transmisión de Gson es rápido. Sin embargo, debe manejar cada par (clave => valor) de procesamiento de datos JSON.

¿Qué es JAXB?

JAXB significa Java Architecnología para XML Binding, que es una biblioteca que utiliza anotaciones para convertir Java objetos a contenido XML y viceversa. Como JAXB se define mediante una especificación, podemos utilizar diferentes implementaciones para este estándar.

Con JAXB, a menudo utilizamos las siguientes anotaciones básicas, a saber:

• @XmlRootElement: Esta anotación especifica cuál es la etiqueta más externa del archivo XML y, por lo tanto, se declara encima de una clase.
• @XmlElementWrapper: Esta anotación crea un elemento XML contenedor alrededor de las colecciones.
• @XmlElement: Esta anotación utilizada para declarar un atributo del objeto es una etiqueta del archivo XML.
• @AtributoXml: Esta anotación también se utiliza para declarar un atributo del objeto que es una etiqueta del archivo XML.

La sintaxis para la implementación general es la siguiente. Primero, inicializaremos el JAXBContexto objeto con el Myobject objeto a convertir.

JAXBContext jaxbContext = JAXBContext.newInstance(MyObject.class);

En este JAXBContexto objeto, tiene un método para crear un objeto que convierte el contenido XML en un Java objeto, desarmador.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

En este JAXBContexto objeto, tiene un método para crear el objeto que convierte el Java oponerse al contenido XML que es Mariscal.

Marshaller marshallerObj = jaxbContext.createMarshaller();

¿Cómo convertir XML a JSON?

Implementamos el ejemplo de conversión XML – JSON en la plataforma:

• Abra JDK 8 para Ubuntu 18.04 x64.
• Eclipse IDE 2019-03 (4.11.0) x64 Java Desarrollo para Ubuntu.
• Hijo 2.8.5.

Paso 1) Crear proyecto.
Crear un nuevo Java Proyecto.

Paso 2) Establecer el nombre del proyecto.
Establecer el nombre del proyecto es XmlToJsonEjemplo.

Paso 3) Crea una carpeta.
crear una carpeta Entrada de datos que contiene dos archivos muestra.xml y muestra.json.

Primero definamos nuestro XML con de facturación, papel y persona propiedades.

La arquitectura general es: ; .

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<root>
	<department>
		<roles>
			<role id="1">
				<position>head</position>
				<salary>10k</salary>
			</role>
			<role id="2">
				<position>manager</position>
				<salary>8k</salary>
			</role>
			<role id="3">
				<position>employee</position>
				<salary>5k</salary>
			</role>
		</roles>
		<persons>
			<person id="1">
				<name>Red</name>
				<role>1</role>
			</person>
			<person id="2">
				<name>Green</name>
				<role>2</role>
			</person>
			<person id="3">
				<name>Blue</name>
				<role>2</role>
			</person>
			<person id="4">
				<name>Yellow</name>
				<role>3</role>
			</person>
			<person id="5">
				<name>Brown</name>
				<role>3</role>
			</person>
		</persons>
	</department>
</root>

En segundo lugar, definimos JSON con la misma idea:

{
	"roles": [
		{
			"id": "1",
			"position": "head",
			"salary": "10k",
			"persons": [
				{
					"id": "1",
					"name": "Red"
				}
			]
		},
		{
			"id": "2",
			"position": "manager",
			"salary": "8k",
			"persons": [
				{
					"id": "2",
					"name": "Green"
				},
				{
					"id": "3",
					"name": "Blue"
				}
			]
		},
		{
			"id": "3",
			"position": "employee",
			"salary": "5k",
			"persons": [
				{
					"id": "4",
					"name": "Yellow"
				},
				{
					"id": "5",
					"name": "Brown"
				}
			]
		}
	]	
}

Paso 4) Definir objeto.
Definir las clases de objetos correspondientes en el paquete. modelo.

• Rol.java:

@XmlRootElement(name = "role")
public class Role {
	private String id;
	private String position;
	private String salary;
	public Role() {
		super();
	}
	public Role(String id, String position, String salary) {
		super();
		this.id = id;
		this.position = position;
		this.salary = salary;
	}
	@XmlAttribute(name = "id")
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	@XmlElement(name = "position")
	public String getPosition() {
		return position;
	}
	public void setPosition(String position) {
		this.position = position;
	}
	@XmlElement(name = "salary")
	public String getSalary() {
		return salary;
	}
	public void setSalary(String salary) {
		this.salary = salary;
	}
}

• Persona.java:

@XmlRootElement(name = "person")
public class Person {
	private String id;
	private String name;
	private String role;
	public Person() {
		super();
	}
	public Person(String id, String name, String role) {
		super();
		this.id = id;
		this.name = name;
		this.role = role;
	}
	@XmlAttribute(name = "id")
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	@XmlElement(name = "name")
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	@XmlElement(name = "role")
	public String getRole() {
		return role;
	}
	public void setRole(String role) {
		this.role = role;
	}
}

• Departamento.java:

@XmlRootElement(name = "department")
public class Department {
	private List<Role> roles;
	private List<Person> persons;
	public Department() {
		super();
	}
	public Department(List<Role> roles, List<Person> persons) {
		super();
		this.roles = roles;
		this.persons = persons;
	}
	@XmlElementWrapper(name = "roles")
	@XmlElement(name = "role")
	public List<Role> getRoles() {
		return roles;
	}
	public void setRoles(List<Role> roles) {
		this.roles = roles;
	}
	@XmlElementWrapper(name = "persons")
	@XmlElement(name = "person")
	public List<Person> getPersons() {
		return persons;
	}
	public void setPersons(List<Person> persons) {
		this.persons = persons;
	}
}

XMLModel.java:

@XmlRootElement(name = "root")
public class XMLModel {

	private Department department;

	public XMLModel() {
		super();
	}

	public XMLModel(Department department) {
		super();
		this.department = department;
	}

	@XmlElement(name = "department")
	public Department getDepartment() {
		return department;
	}

	public void setDepartment(Department department) {
		this.department = department;
	}

}

Paso 5) Configurar biblioteca.
Agregar y configurar la biblioteca Gson 2.8.5 en Java Construir camino.

Convertir mensaje XML a Java objetos usando JAXB

En primer lugar, definimos realizar clasificado en paquete. TRANSPORTE GRATUITO.

En el primer paso del primer proceso, utilizamos la técnica Un-marshalling de JAXB.

Un-marshalling proporciona a una aplicación cliente la capacidad de convertir datos XML en datos derivados de JAXB. Java objetos.

Definimos función obtenerObjetoDeArchivoXml para descomponer nuestro archivo XML en un Java objeto. Esta función está definida en la clase. Servicio XML.

public XMLModel getObjectFromXmlFile(String filePath) {
	try {
		File file = new File(filePath);
		JAXBContext jaxbContext = JAXBContext.newInstance(XMLModel.class);

		Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
		XMLModel root = (XMLModel) jaxbUnmarshaller.unmarshal(file);

		return root;
	} catch (JAXBException e) {
		e.printStackTrace();
		return null;
	}
}

Llamamos al código anterior en clase. Servicio XmlToJson.

XMLService xmlService = new XMLService();
XMLModel xmlModel = xmlService.getObjectFromXmlFile(filePathIn);

Department department = xmlModel.getDepartment();
List<Role> roles = department.getRoles();
List<Person> persons = department.getPersons();

Luego pasamos al siguiente paso.

Convertir Java objetos al mensaje JSON usando Gson

En este paso definimos la función escribirDataToJsonFile para escribir datos en el archivo JSON. Esta función está definida en la clase. Servicio Json.

Tenga en cuenta que para escribir una lista de cadenas JSON, usamos la función comenzarmatriz() y matriz final(). Entre estas dos funciones, escribimos cada cadena JSON.

public void writeDataToJsonFile(String filePath, List<Role> roles, List<Person> persons) {
	try {
		JsonWriter writer = new JsonWriter(new FileWriter(filePath));
		writer.setIndent("    ");
		writer.beginObject();
		writer.name("roles");
		writer.beginArray();
		for (Role role : roles) {
			writer.beginObject();
			writer.name("id").value(role.getId());
			writer.name("position").value(role.getPosition());
			writer.name("salary").value(role.getSalary());
			writer.name("persons");
			writer.beginArray();
			for (Person person : persons) {
				if (person.getRole().equalsIgnoreCase(role.getId())) {
					writer.beginObject();
					writer.name("id").value(person.getId());
					writer.name("name").value(person.getName());
					writer.endObject();
				}
			}
			writer.endArray();
			writer.endObject();
		}
		writer.endArray();
		writer.endObject();
		writer.close();
	} catch (IOException e) {
	}
}

Llamamos al código anterior en clase. Servicio XmlToJson.

JsonService jsonService = new JsonService();
jsonService.writeDataToJsonFile(filePathOut, roles, persons);

Ese es el primer proceso.

Convertir mensaje JSON a Java objetos usando Gson

En el primer paso del segundo proceso, definimos la función obtener datos de archivo Json para leer datos del archivo JSON. Esta función está definida en la clase. Servicio Json.

Tenga en cuenta que para leer una lista de cadenas JSON, usamos la función comenzarmatriz() y matriz final(). Entre estas dos funciones, leemos cada cadena JSON.

public void getDataFromJsonFile(String filePath, List<Role> roles, List<Person> persons) {
	try {
		JsonReader reader = new JsonReader(new FileReader(filePath));
		reader.beginObject();
		while (reader.hasNext()) {
			String nameRoot = reader.nextName();
			if (nameRoot.equals("roles")) {
				reader.beginArray();
				while (reader.hasNext()) {
					reader.beginObject();
					Role role = new Role();
					while (reader.hasNext()) {
						String nameRole = reader.nextName();
						if (nameRole.equals("id")) {
							role.setId(reader.nextString());
						} else if (nameRole.equals("position")) 
					        { role.setPosition(reader.nextString());
						} else if (nameRole.equals("salary")) {
						  role.setSalary(reader.nextString());
						} else if (nameRole.equals("persons")) {
							reader.beginArray();
							while (reader.hasNext()) {
								reader.beginObject();

Person person = new Person();

						person.setRole(role.getId());

						while (reader.hasNext()) {
						String namePerson = reader.nextName();

							if (namePerson.equals("id")) {
						person.setId(reader.nextString());
						} else if (namePerson.equals("name")) {
						person.setName(reader.nextString());
							}
						}
								persons.add(person);
								reader.endObject();
							}
							reader.endArray();
						}
					}
					roles.add(role);
					reader.endObject();
				}
				reader.endArray();
			}
		}
		reader.endObject();
		reader.close();
	} catch (IOException e) {

	}
}

Llamamos al código anterior en clase. Servicio XmlToJson.

JsonService jsonService = new JsonService();
List<Role> roles = new ArrayList<>();
List<Person> persons = new ArrayList<>();

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

Luego pasamos al siguiente paso.

Convertir Java objetos al mensaje XML usando JAXB

En este paso utilizamos la técnica Marshalling de JAXB.

Marshalling proporciona a una aplicación cliente la capacidad de convertir un JAXB derivado Java árbol de objetos en datos XML.

Definimos la función parseObjectToXm para marshall Java objeto al mensaje XML. Esta función está definida en la clase.

XMLService.
public void parseObjectToXml(String filePath, XMLModel xmlModel) {
	try {
		JAXBContext contextObj = JAXBContext.newInstance(XMLModel.class);

		Marshaller marshallerObj = contextObj.createMarshaller();
		marshallerObj.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

		marshallerObj.marshal(xmlModel, new FileOutputStream(filePath));
	} catch (JAXBException je) {
		System.out.println("JAXBException");
	} catch (IOException ie) {
		System.out.println("IOException");
	}
}

Llamamos al código anterior en clase. Servicio XmlToJson.

XMLService xmlService = new XMLService();
XMLModel xmlModel = new XMLModel();

Department department = new Department();
department.setRoles(roles);
department.setPersons(persons);

xmlModel.setDepartment(department);

xmlService.parseObjectToXml(filePathOut, xmlModel);

Ese es el segundo proceso.

Conclusión

En este tutorial, aprendimos brevemente una forma en que JAXB puede leer datos XML y Gson los escribe en JSON. Por el contrario, también vimos la forma en que Gson leyó JSON datos y JAXB los escriben en XML.