Convertir JSON a XML en Java con Gson y JAXB – Guía Paso a Paso

¿Qué es JSON?

JSON (JavaScript Object Notation) es un formato de datos ligero e independiente del lenguaje que utiliza pares clave-valor. Es ampliamente adoptado para el intercambio de datos y se almacena fácilmente en archivos o bases de datos.

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

Características clave:

• Delimitado por llaves {}.
• Las claves y los valores de tipo cadena van entre comillas.
• Los pares se separan por comas.
• Las claves usan letras, dígitos y guión bajo; no pueden empezar con dígito ni contener espacios.

¿Qué es XML?

XML (eXtensible Markup Language) es un estándar del W3C para datos estructurados. A diferencia de HTML, XML es puramente un formato de datos —sin renderizado visual—. Permite etiquetas personalizadas, lo que lo hace ideal para el intercambio de datos entre sistemas.

Estructura típica de nodo:

<nodo>contenido</nodo>

Al inicio de un archivo XML debe declararse la versión:

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

¿Qué es Gson?

Gson es una biblioteca Java que serializa objetos Java a JSON y deserializa JSON de vuelta a objetos Java. Desde la v1.6 también soporta streaming mediante JsonReader y JsonWriter.

Ejemplo de escritor streaming:

JsonWriter writer = new JsonWriter(new FileWriter(rutaArchivo));
writer.beginObject();
writer.name("clave").value("valor");
writer.endObject();
writer.close();

¿Qué es JAXB?

JAXB (Java Architecture for XML Binding) mapea clases Java a XML mediante anotaciones. Soporta marshalling (Java → XML) y unmarshalling (XML → Java).

Anotaciones comunes:

• @XmlRootElement – define el elemento raíz XML.
• @XmlElementWrapper – envuelve colecciones.
• @XmlElement – mapea un campo a un elemento XML.
• @XmlAttribute – mapea un campo a un atributo XML.

Configuración del Proyecto

1. Crear un proyecto Java en su IDE (ej. Eclipse).
2. Nombrarlo XmlToJsonExample.
3. Añadir una carpeta data/input con sample.xml y sample.json.
4. Incluir Gson 2.8.5 en el classpath.
5. Añadir la API JAXB (normalmente incluida en Java 8).

Datos de Ejemplo

Representación XML de un departamento con roles y personas:

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

Estructura JSON equivalente:

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

Clases Modelo en Java

Defina los siguientes POJOs en el paquete model:

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

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

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

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

Unmarshalling XML a Objetos 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 Objetos Java a 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));
}

Serializar Objetos Java a 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();
}

Deserializar JSON a Objetos 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();
}

Flujo Completo de Conversión

1. Unmarshal sample.xml a XMLModel usando JAXB.
2. Serializar los objetos Java resultantes a sample.json con Gson.
3. Deserializar sample.json de vuelta a objetos Java.
4. Marshal esos objetos a un nuevo archivo XML.

Conclusión

Esta guía demuestra un pipeline de conversión limpio en dos pasos: JAXB maneja XML ↔ Java, mientras que Gson maneja JSON ↔ Java. Combinando estas bibliotecas, los desarrolladores pueden transformar datos entre formatos de forma fiable en aplicaciones Java.