Convertir JSON en XML en Java avec Gson et JAXB - Guide étape par étape

Qu'est-ce que le JSON ?

JSON (JavaScript Object Notation) est un format de données léger, indépendant du langage, qui utilise des paires clé-valeur. Il est largement adopté pour l'échange de données et se stocke facilement dans des fichiers ou bases de données.

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

Caractéristiques principales :

• Encadré par des accolades {}.
• Les clés et valeurs textuelles sont entre guillemets.
• Les paires sont séparées par des virgules.
• Les clés utilisent lettres, chiffres, underscore ; pas de chiffre initial ni d'espace.

Qu'est-ce que le XML ?

XML (eXtensible Markup Language) est un standard W3C pour les données structurées. Contrairement au HTML, le XML est un pur format de données — sans rendu visuel. Il permet des balises personnalisées, ce qui le rend idéal pour l'échange de données entre systèmes.

Structure typique d'un nœud :

<noeud>contenu</noeud>

Au début d'un fichier XML, on doit déclarer la version :

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

Qu'est-ce que Gson ?

Gson est une bibliothèque Java qui sérialise des objets Java en JSON et désérialise du JSON vers des objets Java. Depuis la v1.6, elle supporte aussi le streaming via JsonReader et JsonWriter.

Exemple d'un writer en streaming :

JsonWriter writer = new JsonWriter(new FileWriter(cheminFichier));
writer.beginObject();
writer.name("clé").value("valeur");
writer.endObject();
writer.close();

Qu'est-ce que JAXB ?

JAXB (Java Architecture for XML Binding) mappe des classes Java vers du XML via des annotations. Il supporte le marshalling (Java → XML) et l'unmarshalling (XML → Java).

Annotations courantes :

• @XmlRootElement – définit l'élément racine XML.
• @XmlElementWrapper – encapsule les collections.
• @XmlElement – mappe un champ vers un élément XML.
• @XmlAttribute – mappe un champ vers un attribut XML.

Configuration du projet

1. Créez un projet Java dans votre IDE (ex. Eclipse).
2. Nommez-le XmlToJsonExample.
3. Ajoutez un dossier data/input contenant sample.xml et sample.json.
4. Incluez Gson 2.8.5 dans le classpath.
5. Ajoutez l'API JAXB (généralement fournie avec Java 8).

Données d'exemple

Représentation XML d'un département avec rôles et personnes :

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

Structure JSON équivalente :

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

Classes modèle Java

Définissez les POJOs suivants dans le package model :

/* Role.java */
@XmlRootElement(name = "role")
public class Role {
    private String id, position, salary;
    // getters, setters avec annotations @XmlAttribute/@XmlElement
}

/* Person.java */
@XmlRootElement(name = "person")
public class Person {
    private String id, name, role;
    // getters, setters avec annotations @XmlAttribute/@XmlElement
}

/* Department.java */
@XmlRootElement(name = "department")
public class Department {
    private List<Role> roles;
    private List<Person> persons;
    // getters/setters avec @XmlElementWrapper/@XmlElement
}

/* XMLModel.java */
@XmlRootElement(name = "root")
public class XMLModel {
    private Department department;
    // getter/setter avec @XmlElement
}

Unmarshalling XML vers objets Java (JAXB)

public XMLModel getObjectFromXmlFile(String path) throws JAXBException {
    File file = new File(path);
    JAXBContext ctx = JAXBContext.newInstance(XMLModel.class);
    Unmarshaller um = ctx.createUnmarshaller();
    return (XMLModel) um.unmarshal(file);
}

Marshalling objets Java vers XML (JAXB)

public void parseObjectToXml(String path, XMLModel model) throws JAXBException, IOException {
    JAXBContext ctx = JAXBContext.newInstance(XMLModel.class);
    Marshaller m = ctx.createMarshaller();
    m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
    m.marshal(model, new FileOutputStream(path));
}

Sérialisation objets Java vers JSON (Gson)

public void writeDataToJsonFile(String path, List<Role> roles, List<Person> persons) throws IOException {
    JsonWriter writer = new JsonWriter(new FileWriter(path));
    writer.setIndent(" ");
    writer.beginObject();
    writer.name("roles").beginArray();
    for (Role r : roles) {
        writer.beginObject();
        writer.name("id").value(r.getId());
        writer.name("position").value(r.getPosition());
        writer.name("salary").value(r.getSalary());
        writer.name("persons").beginArray();
        for (Person p : persons)
            if (p.getRole().equals(r.getId())) {
                writer.beginObject();
                writer.name("id").value(p.getId());
                writer.name("name").value(p.getName());
                writer.endObject();
            }
        writer.endArray();
        writer.endObject();
    }
    writer.endArray();
    writer.endObject();
    writer.close();
}

Désérialisation JSON vers objets Java (Gson)

public void getDataFromJsonFile(String path, List<Role> roles, List<Person> persons) throws IOException {
    JsonReader reader = new JsonReader(new FileReader(path));
    reader.beginObject();
    while (reader.hasNext()) {
        String rootName = reader.nextName();
        if ("roles".equals(rootName)) {
            reader.beginArray();
            while (reader.hasNext()) {
                reader.beginObject();
                Role r = new Role();
                while (reader.hasNext()) {
                    String key = reader.nextName();
                    switch (key) {
                        case "id": r.setId(reader.nextString()); break;
                        case "position": r.setPosition(reader.nextString()); break;
                        case "salary": r.setSalary(reader.nextString()); break;
                        case "persons":
                            reader.beginArray();
                            while (reader.hasNext()) {
                                reader.beginObject();
                                Person p = new Person();
                                p.setRole(r.getId());
                                while (reader.hasNext()) {
                                    String pKey = reader.nextName();
                                    if ("id".equals(pKey)) p.setId(reader.nextString());
                                    else if ("name".equals(pKey)) p.setName(reader.nextString());
                                }
                                persons.add(p);
                                reader.endObject();
                            }
                            reader.endArray();
                    }
                }
                roles.add(r);
                reader.endObject();
            }
            reader.endArray();
        }
    }
    reader.endObject();
    reader.close();
}

Flux de conversion complet

1. Unmarshal sample.xml en XMLModel avec JAXB.
2. Sérialiser les objets Java résultants vers sample.json avec Gson.
3. Désérialiser sample.json vers des objets Java.
4. Marshaller ces objets dans un nouveau fichier XML.

Conclusion

Ce guide montre un pipeline de conversion propre en deux étapes : JAXB gère XML ↔ Java, tandis que Gson gère JSON ↔ Java. En combinant ces bibliothèques, les développeurs peuvent transformer fiablement les données entre formats dans les applications Java.