Converti JSON in XML Java utilizzando Gson e JAXB

Cos'è JSON?

JSON è un'abbreviazione di JavaScript Object Notation (JSON) è un formato dati che segue regole comprensibili alla maggior parte dei linguaggi di programmazione. Possiamo facilmente salvarlo in un file o memorizzarlo in un database. Il formato JSON utilizza coppie chiave-valore per descrivere i dati.

Nell'esempio seguente, definiamo una stringa JSON che memorizza informazioni personali:

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

La sintassi di JSON è quindi molto semplice. Ogni elemento di dati è composto da due parti, una chiave e un valore, che corrispondono al nome del campo e al suo valore all'interno di un record. Analizzando più a fondo, si possono seguire alcune regole di questo tipo:

• La stringa JSON è racchiusa tra parentesi graffe {}.
• Le chiavi JSON devono essere racchiuse tra virgolette doppie, e anche i valori stringa devono essere racchiusi tra virgolette.
• Se i dati sono più numerosi (più coppie chiave => valore), utilizziamo le virgole (,) per separarli.
• Le chiavi JSON devono essere composte da lettere, numeri o dal carattere di sottolineatura, senza spazi, e il primo carattere non deve essere un numero.

Cos'è l'XML?

XML sta per eXtensible Markup Language, proposto dal World Wide Web Consortium (https://www.w3.org/) per creare altri linguaggi di markup. Si tratta di un semplice sottoinsieme in grado di descrivere molti tipi diversi di dati, quindi è molto utile per la condivisione di 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 utili funzionalità XML per 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 memorizzare i 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 annidati. Ogni nodo ha un tag di apertura e un tag di chiusura come segue:

<node>content</node>

In quale:

• è un tag aperto e il nome di questo tag viene definito da te.
• è un tag di chiusura e il nome di questo tag deve corrispondere al nome del tag di apertura.
• contenuto è il contenuto di questo tag.

All'inizio di ogni file XML è necessario dichiarare un tag per indicare la versione XML in uso. La sintassi del tag di istruzione è la seguente:

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

JSON vs XML: differenze principali

Entrambi i formati contengono dati strutturati e la tabella seguente mostra perché un progetto potrebbe dover passare da un formato all'altro.

Cos'è Gson?

Gson (https://github.com/google/gson) È una Java libreria che consente agli utenti di convertire un Java oggetto in una stringa JSON e anche per convertire una stringa JSON di nuovo in un Java oggetto. Gson può funzionare con arbitrario Java oggetti, inclusi oggetti esistenti di cui non si possiede il codice sorgente.

Dalla versione 1.6, Gson introduce due classi, JsonReader and jSONWriterper fornire l'elaborazione in streaming dei dati JSON.

• jSONWriter – Scrittura in streaming su JSON. Creiamo un jSONWriter oggetto. Per iniziare e terminare la creazione di un oggetto JSON, utilizziamo le funzioni inizioOggetto() and fineOggetto()Tra queste due chiamate, scriviamo i dati come coppie (chiave => valore).

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

• JsonReader – Lettura in streaming da JSON. Creiamo un oggetto JsonReader. Per iniziare e terminare la lettura di un oggetto JSON, utilizziamo le funzioni beginObject() e endObject(). Tra queste due chiamate, leggiamo i dati come 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 in streaming di Gson è veloce. Tuttavia, è necessario gestire manualmente ogni coppia (chiave => valore) 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 in contenuto XML e viceversa. Poiché JAXB è definito da una specifica, possiamo utilizzare diverse implementazioni di questo standard.

Con JAXB, utilizziamo spesso le seguenti annotazioni di base:

• @XmlRootElement: Questa annotazione specifica il tag più esterno del file XML e viene quindi dichiarata sopra una classe.
• @XmlElementWrapper: questa annotazione crea un elemento XML wrapper attorno alle raccolte.
• @XmlElement: Questa annotazione dichiara che una proprietà dell'oggetto diventa un tag figlio del file XML.
• @XmlAttribute: Questa annotazione dichiara che una proprietà dell'oggetto diventa un attributo del tag circostante.

L'implementazione generale è la seguente. Innanzitutto, inizializziamo il JAXBContesto oggetto con il Il mio oggetto classe da convertire.

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

Questo JAXBContesto l'oggetto ha un metodo che crea un oggetto che converte il contenuto XML in un Java oggetto, l Disorganizzatore.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

Lo stesso JAXBContesto l'oggetto ha anche un metodo che crea l'oggetto che converte un Java oggetto in contenuto XML, il Maresciallo.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Come convertire XML in JSON?

Implementiamo l'esempio di conversione da XML a JSON sulla seguente piattaforma. Le versioni riportate di seguito sono quelle utilizzate per gli screenshot. Versioni più recenti del JDK, Eclipsee Gson funzionano allo stesso modo, fatte salve le precisazioni relative a JAXB riportate sopra.

• OpenJDK 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 su XmlToJsonEsempio.

Passo 3) Crea una cartella.
Crea la cartella inserimento dati contenente i due file campione.xml and campione.json.

Definiamo innanzitutto il nostro XML con dipartimento, ruoloe persona proprietà.

L'architettura generale è la seguente: un dipartimento ha molti ruoli e un ruolo è ricoperto da molte persone. Il diagramma seguente illustra queste relazioni.

<?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 il JSON che esprime la stessa idea. Si noti che l'elenco piatto di persone diventa un array annidato all'interno di ciascun ruolo, che è esattamente la trasformazione eseguita dal codice di conversione.

{
	"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 gli oggetti.
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;
	}
}

Department.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 nel Java Costruisci percorso.

Se il progetto utilizza Maven Anziché aggiungere manualmente un file jar, le stesse librerie vengono dichiarate come dipendenze. La versione 2.8.5 è indicata qui per corrispondere agli screenshot, e qualsiasi versione successiva di Gson funziona in modo identico per questo esempio:

<dependencies>
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.8.5</version>
    </dependency>

    <!-- required on Java 11 and later -->
    <dependency>
        <groupId>jakarta.xml.bind</groupId>
        <artifactId>jakarta.xml.bind-api</artifactId>
    </dependency>
    <dependency>
        <groupId>org.glassfish.jaxb</groupId>
        <artifactId>jaxb-runtime</artifactId>
    </dependency>
</dependencies>

Converti messaggio XML in Java oggetti che utilizzano JAXB

Innanzitutto, definiamo le classi performanti nel pacchetto INSTALLAZIONE.

Nella prima fase del primo processo, utilizziamo la tecnica di unmarshalling di JAXB.

La deserializzazione fornisce a un'applicazione client la capacità di convertire i dati XML in dati derivati ​​da JAXB Java oggetti.

Definiamo la funzione getObjectFromXmlFile per deserializzare il nostro file XML in un Java oggetto. Questa funzione è definita nella 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;
	}
}

Richiamiamo il codice sopra nella 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();

A questo punto il file XML è diventato tre Java oggetti in memoria. Il passaggio successivo li scrive in formato JSON.

convertire Java oggetti al messaggio JSON utilizzando Gson

In questa fase definiamo la funzione writeDataToJsonFile per scrivere dati nel file JSON. Questa funzione è definita nella classe JsonService.

Nota che per scrivere un elenco di oggetti JSON, utilizziamo le funzioni inizioArray() and endArray()Tra queste due chiamate, scriviamo ciascun oggetto 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) {
	}
}

Richiamiamo il codice sopra nella classe XmlToJsonService.

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

Questo è il primo processo. Il ciclo interno associa ogni persona all'ID del ruolo corrente, ed è così che l'elenco di persone in formato XML si trasforma in un array JSON annidato.

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 nella classe JsonService.

Nota che per leggere un elenco di oggetti JSON, utilizziamo le funzioni inizioArray() and endArray()Tra queste due chiamate, leggiamo ciascun oggetto 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) {

	}
}

Richiamiamo il codice sopra nella classe XmlToJsonService.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

convertire Java oggetti al messaggio XML utilizzando JAXB

In questa fase, utilizziamo la tecnica di marshalling di JAXB.

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

Definiamo la funzione analizzareOggettoInXml per radunare il Java oggetto in un messaggio XML. Questa funzione è definita nella 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");
	}
}

Richiamiamo il codice sopra nella 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. Il file generato corrisponde al sample.xml originale, il che conferma che il processo di scambio ha preservato tutti i valori.

Come convertire JSON in XML in Java senza una classe modello?

L'approccio sopra descritto è la scelta giusta quando la struttura è nota e stabile, perché le classi annotate documentano la contract. Quando la struttura è sconosciuta o cambia spesso, un convertitore generico è più veloce.

Migliori org.json La libreria esegue la conversione in due righe, senza alcuna classe modello:

import org.json.JSONObject;
import org.json.XML;

public class QuickConverter {

    public static void main(String[] args) {
        String str = "{\"username\":\"guru99user\",\"email\":\"guru99user@mail.com\"}";

        JSONObject json = new JSONObject(str);
        String xml = XML.toString(json);

        System.out.println(xml);
    }
}

Produzione:

<username>guru99user</username><email>guru99user@mail.com</email>

Si noti che il percorso generico non produce alcun elemento radice e nessun attributo, quindi XML.toString(json, "root") è normalmente richiesto. La tabella seguente mette a confronto i due approcci.

JAXB legge i dati XML e Gson li scrive in JSON, e il percorso inverso utilizza Gson per leggere JSON dati mentre JAXB li riscrive in XML. Per approfondire, rivedere XML fondamenti, il più ampio Java lezionee Jasper Reports, che utilizza entrambi i formati come fonti di dati per i report.

DOMANDE FREQUENTI