Converti JSON in XML Java utilizzando Gson e JAXB con l'esempio

Cos'è JSON?

JSON è un'abbreviazione di Javascript Object Notation, che è una forma di dati che segue una certa regola per cui la maggior parte dei linguaggi di programmazione sono attualmente leggibili. Possiamo facilmente salvarli in un file o in un record nel database. Il formato JSON usa coppie chiave-valore per descrivere i dati.

Seguendo l'esempio, definiamo una stringa JSON che memorizza informazioni personali:

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

Quindi la sintassi di JSON è molto semplice. Ogni informazione sui dati avrà due parti: chiave e valore che corrispondono al nome del campo e al suo valore in un determinato record. Ma guardando ulteriormente, ci sono alcune cose come queste:

• La stringa JSON è racchiusa tra parentesi graffe {}.
• Le chiavi e i valori di JSON devono essere racchiusi tra virgolette {“}.
• Se sono presenti più dati (più coppie chiave => valore), utilizziamo le virgole (,) per separarli.
• Le chiavi JSON devono essere lettere o numeri senza segno, _ e senza spazi, il primo carattere non deve essere impostato su numeri.

Cos'è l'XML?

XML sta per eXtensible Markup Language chiamato anche linguaggio di markup estensibile proposto dal World Wide Web Consortium (https://www.w3.org/) per creare altri linguaggi di markup. Si tratta di un semplice sottoinsieme che può descrivere molti tipi diversi di dati, quindi è molto utile nella condivisione dei dati tra sistemi.

I tag in XML spesso non sono predefiniti, ma vengono creati in base alle convenzioni dell'utente. XML introduce nuove funzionalità basate sui vantaggi dell'HTML.

Esistono alcune funzionalità più utili per la creazione di XML in diversi sistemi e soluzioni:

• XML è estensibile: XML ti consente di creare tag personalizzati per adattarli alla tua applicazione.
• XML trasporta i dati, non li visualizza: XML consente di archiviare dati indipendentemente da come verranno visualizzati.
• XML è uno standard comune: XML è stato sviluppato dal World Wide Web Consortium (W3C) ed è disponibile come standard aperto.

XML è costruito su una struttura di nodi nidificati. Ogni nodo avrà un tag di apertura e un tag di chiusura come segue:

<node>content</node>

In quale:

• è un tag aperto, il nome di questo tag è definito da te.
• è un tag chiuso, il nome di questo tag deve corrispondere al nome del tag aperto.
• contenuto è il contenuto di questo tag.

Nella parte superiore di ogni file XML è necessario dichiarare un tag per indicare la versione XML in uso. La sintassi del tag istruzione:

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

Cos'è Gson?

Gson (https://github.com/google/gson) è una libreria Java che consente agli utenti di convertire da un Java oggetto in stringa JSON e anche conversione da una stringa JSON in Java oggetto. Gson può funzionare con arbitrario Java oggetti inclusi oggetti esistenti senza che tu abbia il loro codice sorgente.

Dalla versione 1.6, Gson introduce due nuove classi: JsonReader e Scrittore Json per fornire l'elaborazione dello streaming sui dati JSON.

• Scrittore Json – Scrittura in streaming su JSON. La sintassi per l'implementazione generale è la seguente. Creiamo un Scrittore Json oggetto. Per iniziare e terminare la creazione di una stringa JSON, utilizziamo la funzione inizioOggetto() e fineOggetto(). Durante l'esecuzione di queste due funzioni, eseguiamo la scrittura dei dati con coppie (chiave => valore).

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

• JsonReader – Lettura in streaming da JSON. La sintassi per l'implementazione generale è la seguente. Creiamo un oggetto JsonReader. Per iniziare e terminare la creazione di una stringa JSON, utilizziamo le funzioni BeginObject() e endObject(). Durante l'esecuzione di queste due funzioni, eseguiamo la lettura dei dati con coppie (chiave => valore).

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

L'elaborazione dello streaming Gson è veloce. Tuttavia è necessario gestire ciascuna coppia (chiave => valore) di elaborazione dei dati JSON.

Cos'è JAXB?

JAXB sta per Java Architecture per XML Binding, che è una libreria che utilizza le annotazioni per la conversione Java oggetti al contenuto XML e viceversa. Poiché JAXB è definito tramite una specifica, possiamo utilizzare diverse implementazioni per questo standard.

Con JAXB, spesso utilizziamo le seguenti annotazioni di base, vale a dire:

• @XmlRootElement: Questa annotazione specifica qual è il tag più esterno del file XML e quindi viene dichiarato all'inizio di una classe.
• @XmlElementWrapper: questa annotazione crea un elemento XML wrapper attorno alle raccolte.
• @XmlElement: Questa annotazione utilizzata per dichiarare un attributo dell'oggetto è un tag del file XML.
• @XmlAttribute: Questa annotazione utilizzata anche per dichiarare un attributo dell'oggetto è un tag del file XML.

La sintassi per l'implementazione generale è la seguente. Per prima cosa inizializzeremo il file JAXBContesto oggetto con il Il mio oggetto oggetto da convertire.

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

In questa JAXBContesto object, ha un metodo per creare un oggetto che converte il contenuto XML in un file Java oggetto, Disorganizzatore.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

In questa JAXBContesto oggetto, ha un metodo per creare l'oggetto che converte il file Java oggetto al contenuto XML che è Maresciallo.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Come convertire XML in JSON?

Implementiamo l'esempio di conversione XML – JSON sulla piattaforma:

• Apri JDK 8 per Ubuntu 18.04 x64.
• Eclipse IDE 2019-03 (4.11.0) x64 Java Sviluppo per Ubuntu.
• Gson 2.8.5.

Passo 1) Crea progetto.
Crea un nuovo Java Progetto.

Passo 2) Imposta il nome del progetto.
Imposta il nome del progetto è XmlToJsonEsempio.

Passo 3) Crea una cartella.
Crea cartella inserimento dati contenente due file campione.xml e campione.json.

Per prima cosa definiamo il nostro XML con dipartimento, ruolo e persona proprietà.

L'architettura generale è: ; .

<?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>

In secondo luogo, definiamo JSON avendo la stessa 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"
				}
			]
		}
	]	
}

Passo 4) Definire oggetto.
Definire le classi di oggetti corrispondenti nel pacchetto modello.

• Ruolo.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;
	}
}

• Dipartimento.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;
	}

}

Passo 5) Configura la libreria.
Aggiungi e configura la libreria Gson 2.8.5 in Java Costruisci percorso.

Converti messaggio XML in Java oggetti che utilizzano JAXB

Innanzitutto, definiamo l'esecuzione classificata nel pacchetto servizio.

Nella prima fase del primo processo utilizziamo la tecnica Un-marshalling di JAXB.

L'annullamento del marshalling fornisce a un'applicazione client la capacità di convertire i dati XML in derivati ​​JAXB Java oggetti.

Definiamo funzione getObjectFromXmlFile per annullare il marshalling del nostro file XML in a Java oggetto. Questa funzione è definita in classe XMLService.

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;
	}
}

Chiamiamo il codice sopra in classe XmlToJsonService.

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

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

Quindi andiamo al passaggio successivo.

convertire Java oggetti al messaggio JSON utilizzando Gson

A questo punto definiamo la funzione writeDataToJsonFile per scrivere i dati nel file JSON. Questa funzione è definita in classe JsonService.

Tieni presente che per scrivere un elenco di stringhe JSON utilizziamo la funzione inizioArray() e endArray(). Tra queste due funzioni, scriviamo ciascuna stringa 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) {
	}
}

Chiameremo il codice sopra in classe XmlToJsonService.

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

Questo è il primo processo.

Converti il ​​messaggio JSON in Java oggetti che utilizzano Gson

Nella prima fase del secondo processo, definiamo la funzione getDataFromJsonFile per leggere i dati dal file JSON. Questa funzione è definita in classe JsonService.

Tieni presente che per leggere un elenco di stringhe JSON utilizziamo la funzione inizioArray() e endArray(). Tra queste due funzioni, leggiamo ciascuna stringa 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) {

	}
}

Chiameremo il codice sopra in classe XmlToJsonService.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

Quindi andiamo al passaggio successivo.

convertire Java oggetti al messaggio XML utilizzando JAXB

In questa fase utilizziamo la tecnica Marshalling di JAXB.

Il marshalling fornisce a un'applicazione client la possibilità di convertire un derivato JAXB Java albero degli oggetti in dati XML.

Definiamo la funzione parseObjectToXm su marshall Java oggetto al messaggio XML. Questa funzione è definita in classe

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");
	}
}

Chiameremo il codice sopra in classe XmlToJsonService.

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);

Questo è il secondo processo.

Conclusione

In questo tutorial, abbiamo brevemente imparato un modo in cui JAXB può leggere i dati XML e Gson scriverli in JSON. Al contrario, abbiamo visto anche il modo in cui leggeva Gson JSON data e JAXB lo scrivono in XML.