Convertir JSON en XML Java en utilisant Gson et JAXB avec l'exemple

Qu'est-ce que JSON ?

JSON est une abréviation de Javascript Object Notation, qui est une forme de données qui suit une certaine règle selon laquelle la plupart des langages de programmation sont actuellement lisibles. Nous pouvons facilement l'enregistrer dans un fichier ou enregistrer dans la base de données. Le format JSON utilise des paires clé-valeur pour décrire les données.

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

{
"username" : "guru99user",
"email" : "[email protected]"	
}

La syntaxe de JSON est donc très simple. Chaque information de données aura deux parties :clé et valeur qui correspondent au nom du champ et à sa valeur dans un certain enregistrement. Mais en regardant plus loin, il y a quelques choses comme ça :

• La chaîne JSON est entourée d'accolades {}.
• Les clés et les valeurs de JSON doivent être placées 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 être des lettres ou des chiffres non signés, _, et aucun espace, le premier caractère ne doit pas être défini sur des chiffres.

Dans ce tutoriel, vous apprendrez-

• Qu'est-ce que JSON ?
• Qu'est-ce que XML ?
• Qu'est-ce que Gson ?
• Qu'est-ce que JAXB ?
• Comment convertir XML en JSON ?
• Convertir un message XML en objets Java à l'aide de JAXB
• Convertir des objets Java en message JSON à l'aide de Gson
• Convertir un message JSON en objets Java à l'aide de Gson
• Convertir des objets Java en message XML à l'aide de JAXB

Qu'est-ce que XML ?

XML signifie eXtensible Markup Language également appelé le langage de balisage extensible 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 qui peut décrire de nombreux types de données différents, il est donc très utile pour partager des données entre les systèmes.

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

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

• XML est extensible :XML vous permet de créer vos propres balises personnalisées en fonction de votre application.
• XML transporte des données, sans les afficher :XML vous permet de stocker des données indépendamment de la manière dont elles seront affichées.
• XML est une norme commune :XML a été développé par le World Wide Web Consortium (W3C) et est disponible en tant que norme ouverte.

XML est construit sur une structure de nœuds imbriqués. Chaque nœud aura une balise d'ouverture et une balise de fermeture comme suit :

<node>content</node>

Dans lequel :

• est une balise ouverte, le nom de cette balise est défini par vous.
• est une balise fermée, le nom de cette balise doit correspondre au nom de la balise ouverte.
• contenu est le contenu de cette balise.

En haut de chaque fichier XML, vous devez déclarer une balise pour indiquer la version XML utilisée. La syntaxe de la balise d'instruction :

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

Qu'est-ce que Gson ?

Gson (https://github.com/google/gson) est une bibliothèque Java qui permet aux utilisateurs de convertir un objet Java en chaîne JSON et également de convertir une chaîne JSON en objet Java. Gson peut travailler avec des objets Java arbitraires, y compris des objets existants sans que vous ayez leur code source.

Depuis la version 1.6, Gson introduit deux nouvelles classes - JsonReader et JsonWriter pour fournir un traitement en continu sur les données JSON.

• JsonWriter – Ecriture en continu sur JSON. La syntaxe pour l'implémentation générale est la suivante. Nous créons un JsonWriter objet. Pour commencer et terminer la création d'une chaîne JSON, nous utilisons la fonction beginObject() et endObject() . Au milieu de l'exécution de ces deux fonctions, nous effectuons l'écriture de données avec des paires (clé => valeur).

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

• JsonReader – Streaming lu à partir de JSON. La syntaxe pour l'implémentation générale est la suivante. Nous créons un objet JsonReader. Pour commencer et terminer la création d'une chaîne JSON, nous utilisons les fonctions beginObject() et endObject(). Au milieu de l'exécution de ces deux fonctions, nous effectuons la lecture de données avec des 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 du streaming Gson est rapide. Cependant, vous devez gérer chaque paire (clé => valeur) de traitement des données JSON.

Qu'est-ce que JAXB ?

JAXB signifie Java Architecture for XML Binding, qui est une bibliothèque qui utilise des annotations pour convertir des objets Java en contenu XML et vice versa. Comme JAXB est défini via une spécification, nous pouvons utiliser différentes implémentations pour cette norme.

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

• @XmlRootElement  :Cette annotation spécifie quelle est la balise la plus externe du fichier XML et, par conséquent, elle est déclarée au-dessus d'une classe.
• @XmlElementWrapper  :Cette annotation crée un élément XML wrapper autour des collections.
• @XmlElement :Cette annotation utilisée pour déclarer un attribut de l'objet est une balise du fichier XML.
• @XmlAttribute :Cette annotation également utilisée pour déclarer un attribut de l'objet est une balise du fichier XML.

La syntaxe pour l'implémentation générale est la suivante. Tout d'abord, nous allons initialiser le JAXBContext objet avec MyObject objet à convertir.

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

Dans ce JAXBContext objet, il a une méthode pour créer un objet qui convertit le contenu XML en un objet Java, Unmarshaller .

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

Dans ce JAXBContext objet, il a une méthode pour créer l'objet qui convertit l'objet Java en contenu XML qui est Marshaller .

Marshaller marshallerObj = jaxbContext.createMarshaller();

Comment convertir XML en JSON ?

Nous implémentons l'exemple de conversion XML – JSON sur la plateforme :

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

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

Étape 2 . Définir le nom du projet.
Définir le nom du projet est XmlToJsonExample .

Étape 3 . Créez un dossier.
Créez un dossier data/input contenant deux fichiers sample.xml et sample.json .

Définissons d'abord notre XML avec departement , rôle et personne propriétés.

L'architecture générale est :; .

<?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 JSON en ayant la même idée :

{
	"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 l'objet.
Définir 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;
	}

}

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

}

• Service.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 . Configurer la bibliothèque.
Ajouter et configurer la bibliothèque Gson 2.8.5 dans Java Build Path.

Convertir un message XML en objets Java à l'aide de JAXB

Tout d'abord, nous définissons les performances classées dans le package service .

Lors de la première étape du premier processus, nous utilisons la technique Un-marshalling de JAXB.

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

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

Nous appelons le code ci-dessus dans la 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();

Ensuite, nous passons à l'étape suivante.

Convertir des objets Java en message JSON à l'aide de Gson

A 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 de chaînes JSON, nous utilisons la fonction beginArray() et endArray() . Entre ces deux fonctions, nous écrivons chaque chaîne 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 XmlToJsonService .

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

C'est le premier processus.

Convertir un message JSON en objets Java à l'aide de 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 de chaînes JSON, nous utilisons la fonction beginArray() et endArray() . Entre ces deux fonctions, nous lisons chaque chaîne 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 XmlToJsonService .

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

jsonService.getDataFromJsonFile(filePathIn, roles, persons);

Comment convertir Json en XML Java ?

JSON vers XML en JAVA est converti en utilisant JSONObject json =new JSONObject(str); Chaîne xml =XML . Si vous avez un fichier dtd valide ou le fichier xml, il est très facile de transformer json en xml et aussi xml en json.

Ensuite, nous passons à l'étape suivante.

Convertir des objets Java en message XML à l'aide de JAXB

A cette étape, nous utilisons la technique Marshalling de JAXB.

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

Nous définissons la fonction parseObjectToXm pour rassembler l'objet Java en message XML. Cette fonction est définie dans la 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");
	}
}

Nous appelons le code ci-dessus dans la 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);

C'est le deuxième processus.

Conclusion

Dans ce didacticiel, nous avons brièvement appris une manière dont JAXB peut lire des données XML et Gson les écrit dans JSON. Au contraire, nous avons également vu la façon dont Gson lit les données JSON et JAXB les écrit en XML.

Programme Java pour vérifier le nombre premier Programme pour imprimer un nombre premier de 1 à 100 en Java