JSON in XML in Java konvertieren mit Gson & JAXB – Schritt-für-Schritt-Anleitung

Was ist JSON?

JSON (JavaScript Object Notation) ist ein leichtgewichtiges, sprachunabhängiges Datenformat, das Schlüssel-Wert-Paare verwendet. Es wird häufig für Datenaustausch eingesetzt und lässt sich einfach in Dateien oder Datenbanken speichern.

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

Wesentliche Merkmale:

• In geschweifte Klammern {} eingeschlossen.
• Schlüssel und Zeichenkettenwerte sind in Anführungszeichen gesetzt.
• Paare werden durch Kommas getrennt.
• Schlüssel verwenden Buchstaben, Ziffern, Unterstriche; keine führenden Ziffern oder Leerzeichen.

Was ist XML?

XML (eXtensible Markup Language) ist ein W3C-Standard für strukturierte Daten. Im Gegensatz zu HTML ist XML ein reines Datenformat – ohne visuelle Darstellung. Es erlaubt benutzerdefinierte Tags und eignet sich ideal für den plattformübergreifenden Datenaustausch.

Typische Knotenstruktur:

<knoten>inhalt</knoten>

Am Anfang einer XML-Datei muss die Version deklariert werden:

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

Was ist Gson?

Gson ist eine Java-Bibliothek, die Java-Objekte in JSON serialisiert und JSON wieder in Java-Objekte deserialisiert. Seit Version 1.6 unterstützt sie auch Streaming über JsonReader und JsonWriter.

Beispiel für einen Streaming-Writer:

JsonWriter writer = new JsonWriter(new FileWriter(dateiPfad));
writer.beginObject();
writer.name("schluessel").value("wert");
writer.endObject();
writer.close();

Was ist JAXB?

JAXB (Java Architecture for XML Binding) ordnet Java-Klassen mittels Annotationen XML zu. Es unterstützt Marshalling (Java → XML) und Unmarshalling (XML → Java).

Häufige Annotationen:

• @XmlRootElement – definiert das Stammelement der XML.
• @XmlElementWrapper – umschließt Sammlungen.
• @XmlElement – ordnet ein Feld einem XML-Element zu.
• @XmlAttribute – ordnet ein Feld einem XML-Attribut zu.

Projekt-Setup

1. Erstellen Sie ein Java-Projekt in Ihrer IDE (z. B. Eclipse).
2. Benennen Sie es XmlToJsonExample.
3. Fügen Sie einen Ordner data/input mit sample.xml und sample.json hinzu.
4. Binden Sie Gson 2.8.5 in den Build-Pfad ein.
5. Fügen Sie die JAXB-API hinzu (normalerweise ab Java 8 enthalten).

Beispieldaten

XML-Darstellung einer Abteilung mit Rollen und Personen:

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

Äquivalente JSON-Struktur:

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

Java-Modellklassen

Definieren Sie die folgenden POJOs im Paket model:

/* Role.java */
@XmlRootElement(name = "role")
public class Role {
    private String id, position, salary;
    // Getter, Setter mit @XmlAttribute/@XmlElement Annotationen
}

/* Person.java */
@XmlRootElement(name = "person")
public class Person {
    private String id, name, role;
    // Getter, Setter mit @XmlAttribute/@XmlElement Annotationen
}

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

/* XMLModel.java */
@XmlRootElement(name = "root")
public class XMLModel {
    private Department department;
    // Getter/Setter mit @XmlElement
}

XML in Java-Objekte unmarshallen (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);
}

Java-Objekte in XML marshallen (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));
}

Java-Objekte in JSON serialisieren (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();
}

JSON in Java-Objekte deserialisieren (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();
                            break;
                    }
                }
                roles.add(r);
                reader.endObject();
            }
            reader.endArray();
        }
    }
    reader.endObject();
    reader.close();
}

Vollständiger Konvertierungs-Workflow

1. sample.xml mit JAXB in XMLModel unmarshallen.
2. Die resultierenden Java-Objekte mit Gson in sample.json serialisieren.
3. sample.json zurück in Java-Objekte deserialisieren.
4. Diese Objekte in eine neue XML-Datei marshallen.

Fazit

Diese Anleitung demonstriert eine saubere, zweistufige Konvertierungspipeline: JAXB kümmert sich um XML ↔ Java, während Gson JSON ↔ Java handhabt. Durch die Kombination dieser Bibliotheken können Entwickler Daten zuverlässig zwischen Formaten in Java-Anwendungen transformieren.