Convertir JSON en XML Java utilisation de Gson et JAXB

Qu'est-ce que JSON?

JSON est une abréviation de JavaJSON (Script Object Notation) est un format de données conforme à des règles lisibles par la plupart des langages de programmation. Il est facile de l'enregistrer dans un fichier ou de le stocker dans une base de données. Le format JSON utilise des paires clé-valeur pour décrire les données.

Dans l'exemple suivant, nous définissons une chaîne JSON qui stocke des informations personnelles :

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

La syntaxe de JSON est donc très simple. Chaque donnée comporte deux parties : une clé et une valeur, qui correspondent au nom du champ et à sa valeur dans un enregistrement. En y regardant de plus près, on trouve quelques règles comme celles-ci :

• La chaîne JSON est entourée d'accolades {}.
• Les clés JSON doivent être placées entre guillemets doubles, et les valeurs de type chaîne de caractères doivent également être entre guillemets.
• S'il y a plus de données (plus de paires clé => valeur), nous utilisons des virgules (,) pour les séparer.
• Les clés JSON doivent utiliser des lettres simples, des chiffres ou le caractère de soulignement, sans espaces, et le premier caractère ne doit pas être un chiffre.

Qu'est-ce que XML?

XML signifie eXtensible Markup Language, proposé par le World Wide Web Consortium (https://www.w3.org/) pour créer d'autres langages de balisage. Il s'agit d'un sous-ensemble simple capable de décrire de nombreux types de données différents, ce qui le rend très utile pour le partage de données entre systèmes.

Les balises en XML ne sont souvent pas prédéfinies, mais elles sont créées selon les conventions utilisateur. XML introduit de nouvelles fonctionnalités basées sur les avantages du HTML.

Il existe des fonctionnalités XML utiles pour divers systèmes et solutions :

• XML est extensible : XML vous permet de créer vos propres balises personnalisées en fonction de votre application.
• Le XML transporte des données, il ne les affiche pas : le XML permet de stocker des données indépendamment de la manière dont elles seront affichées.
• XML est un standard commun : XML a été développé par le World Wide Web Consortium (W3C) et est disponible en tant que standard ouvert.

XML est construit sur une structure de nœuds imbriqués. Chaque nœud possède une balise ouvrante et une balise fermante, comme suit :

<node>content</node>

Dans lequel:

• est une balise ouverte, et c'est vous qui définissez le nom de cette balise.
• est une balise de fermeture, et le nom de cette balise doit correspondre au nom de la balise d'ouverture.
• contenu est le contenu de cette balise.

En haut de chaque fichier XML, vous devez déclarer une balise indiquant la version XML utilisée. La syntaxe de cette balise est la suivante :

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

JSON vs XML : Principales différences

Les deux formats contiennent des données structurées, et le tableau ci-dessous indique pourquoi un projet peut nécessiter de passer de l'un à l'autre.

Qu’est-ce que Gson ?

Gson (https://github.com/google/gson) est un Java bibliothèque qui permet aux utilisateurs de convertir un Java un objet vers une chaîne JSON, et également reconvertir une chaîne JSON en un objet Java objet. Gson peut travailler avec arbitraire Java objets, y compris des objets existants dont vous ne possédez pas le code source.

Depuis la version 1.6, Gson introduit deux classes, JsonReader et JsonWriter, pour assurer le traitement en flux continu des données JSON.

• JsonWriter – Écriture en flux continu au format JSON. Nous créons un JsonWriter objet. Pour créer et terminer un objet JSON, nous utilisons les fonctions commencerObject() et objetfin()Entre ces deux appels, nous écrivons les données sous forme de paires (clé => valeur).

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

• JsonReader – Lecture en flux continu depuis un objet JSON. Nous créons un objet JsonReader. Pour démarrer et terminer la lecture d'un objet JSON, nous utilisons les fonctions beginObject() et endObject(). Entre ces deux appels, nous lisons les données sous forme de paires clé-valeur.

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

Le traitement de flux Gson est rapide. Cependant, vous devez traiter vous-même chaque paire (clé => valeur) de données JSON.

Qu'est-ce que JAXB ?

JAXB signifie Java Architecture pour XML Binding, qui est une bibliothèque qui utilise des annotations pour convertir Java JAXB permet de convertir des objets en contenu XML et inversement. Comme JAXB est défini par une spécification, différentes implémentations de cette norme peuvent être utilisées.

Avec JAXB, nous utilisons souvent les annotations de base suivantes :

• @XmlRootElementCette annotation spécifie la balise la plus externe du fichier XML et est donc déclarée au-dessus d'une classe.
• @XmlElementWrapper: Cette annotation crée un élément XML wrapper autour des collections.
• @XmlElementCette annotation déclare qu'une propriété de l'objet devient une balise enfant du fichier XML.
• @XmlAttributeCette annotation déclare qu'une propriété de l'objet devient un attribut de la balise englobante.

La mise en œuvre générale est la suivante. Premièrement, nous initialisons le JAXBContexte objet avec le MonObjet classe à convertir.

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

Ce JAXBContexte L'objet possède une méthode qui crée un objet convertissant le contenu XML en un Java l'objet, l' Démarécheur.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

Le même JAXBContexte L'objet possède également une méthode qui crée l'objet qui convertit un Java objet dans le contenu XML, le maréchal.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Comment convertir XML en JSON ?

Nous illustrons la conversion XML vers JSON sur la plateforme suivante. Les versions ci-dessous sont celles utilisées pour les captures d'écran. Les versions plus récentes du JDK, Eclipse, et Gson fonctionnent de la même manière, sous réserve de la note JAXB ci-dessus.

• OpenJDK 8 pour Ubuntu 18.04 x64.
• Eclipse IDE 2019-03 (4.11.0) x64 Java Développement pour Ubuntu.
• Gson 2.8.5.

Étape 1) Créer un projet.
Créer un nouveau Java .

Étape 2) Définir le nom du projet.
Définissez le nom du projet sur XmlVersJsonExemple.

Étape 3) Créez un dossier.
Créer le dossier entrée de données contenant les deux fichiers exemple.xml et exemple.json.

Définissons d'abord notre XML avec département, rôle de l' et personne .

L'architecture générale est la suivante : un département comprend plusieurs rôles, et un rôle implique plusieurs personnes. Le diagramme ci-dessous illustre ces relations.

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

Deuxièmement, nous définissons le JSON qui exprime la même idée. Remarquez que la liste plate de personnes devient un tableau imbriqué dans chaque rôle, ce qui correspond exactement à la transformation effectuée par le code de conversion.

{
	"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"
				}
			]
		}
	]
}

Étape 4) Définir les objets.
Définissez les classes d'objets correspondantes dans le package modèle.

Rôle.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;
	}
}

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

Département.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;
	}

}

Étape 5) Mettre en place la bibliothèque.
Ajoutez et configurez la bibliothèque Gson 2.8.5 dans le Java Construire un chemin.

Si le projet utilise Maven Au lieu d'ajouter manuellement un fichier JAR, les mêmes bibliothèques sont déclarées comme dépendances. La version 2.8.5 est utilisée ici pour correspondre aux captures d'écran, et toute version ultérieure de Gson fonctionne de manière identique pour cet exemple :

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

Convertir un message XML en Java objets utilisant JAXB

Tout d'abord, nous définissons les classes performantes du package service.

Dans la première étape du premier processus, nous utilisons la technique de désérialisation de JAXB.

La désérialisation permet à une application cliente de convertir des données XML en données dérivées de JAXB. Java objets.

Nous définissons la fonction getObjectFromXmlFile pour désérialiser notre fichier XML en un Java objet. Cette fonction est définie dans la classe Service 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;
	}
}

Nous appelons le code ci-dessus dans la classe XmlVersJsonService.

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

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

À ce stade, le fichier XML est devenu trois Java Les objets sont stockés en mémoire. L'étape suivante consiste à les écrire au format JSON.

Convertir Java objets dans un message JSON en utilisant Gson

À cette étape, nous définissons la fonction writeDataToJsonFile pour écrire des données dans le fichier JSON. Cette fonction est définie dans la classe JsonService.

Notez que pour écrire une liste d'objets JSON, nous utilisons les fonctions commencerArray() et finArray()Entre ces deux appels, nous écrivons chaque objet 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) {
	}
}

Nous appelons le code ci-dessus dans la classe XmlVersJsonService.

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

Voici la première étape. La boucle interne compare chaque personne à l'identifiant de rôle actuel, ce qui permet de transformer la liste XML plate de personnes en un tableau JSON imbriqué.

Convertir le message JSON en Java objets utilisant Gson

À la première étape du deuxième processus, nous définissons la fonction getDataFromJsonFile pour lire les données du fichier JSON. Cette fonction est définie dans la classe JsonService.

Notez que pour lire une liste d'objets JSON, nous utilisons les fonctions commencerArray() et finArray()Entre ces deux appels, nous lisons chaque objet 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) {

	}
}

Nous appelons le code ci-dessus dans la classe XmlVersJsonService.

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

Convertir Java objets en message XML en utilisant JAXB

À cette étape, nous utilisons la technique de sérialisation de JAXB.

Le marshaling permet à une application cliente de convertir un flux JAXB dérivé Java arborescence d'objets en données XML.

Nous définissons la fonction analyserObjectToXml pour rassembler le Java objet vers un message XML. Cette fonction est définie dans la classe Service XML.

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

Nous appelons le code ci-dessus dans la classe XmlVersJsonService.

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

Il s'agit de la deuxième étape. Le fichier généré correspond au fichier sample.xml d'origine, ce qui confirme que l'aller-retour a préservé toutes les valeurs.

Comment convertir du JSON en XML ? Java sans classe de modèle ?

L'approche décrite ci-dessus est le bon choix lorsque la structure est connue et stable, car les classes annotées documentent la configuration.tract. Lorsque la structure est inconnue ou change souvent, un convertisseur générique est plus rapide.

Le org.json La bibliothèque effectue la conversion en deux lignes, sans aucune classe de modèle :

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

Sortie :

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

Notez que la route générique ne produit ni élément racine ni attributs, donc XML.toString(json, "root") est généralement nécessaire. Le tableau ci-dessous compare les deux approches.

JAXB lit des données XML et Gson les écrit au format JSON, et le processus inverse utilise Gson pour lire les données. JSON Les données sont traitées par JAXB, qui les réécrit au format XML. Pour en savoir plus, consultez la section « Consulter ». XML fondamentaux, le plus large Java tutoriel et JasperRapports, qui utilise les deux formats comme sources de données de rapport.

FAQ