Converter JSON para XML em Java com Gson e JAXB – Guia Passo a Passo

O que é JSON?

JSON (JavaScript Object Notation) é um formato de dados leve, independente de linguagem, que usa pares chave-valor. É amplamente adotado para intercâmbio de dados e é facilmente armazenado em arquivos ou bancos de dados.

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

Características principais:

• Delimitado por chaves {}.
• Chaves e valores string são entre aspas.
• Pares são separados por vírgulas.
• Chaves usam letras, dígitos, underscore; sem dígitos iniciais ou espaços.

O que é XML?

XML (eXtensible Markup Language) é um padrão W3C para dados estruturados. Diferente do HTML, XML é puramente um formato de dados — sem renderização visual. Permite tags personalizadas, tornando-o ideal para intercâmbio de dados entre sistemas.

Estrutura típica de nó:

<node>conteúdo</node>

No topo de um arquivo XML você deve declarar a versão:

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

O que é Gson?

Gson é uma biblioteca Java que serializa objetos Java para JSON e deserializa JSON de volta para objetos Java. Desde v1.6 também suporta streaming via JsonReader e JsonWriter.

Exemplo de writer streaming:

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

O que é JAXB?

JAXB (Java Architecture for XML Binding) mapeia classes Java para XML usando anotações. Suporta marshalling (Java → XML) e unmarshalling (XML → Java).

Anotações comuns:

• @XmlRootElement – define o elemento raiz XML.
• @XmlElementWrapper – envolve coleções.
• @XmlElement – mapeia um campo para um elemento XML.
• @XmlAttribute – mapeia um campo para um atributo XML.

Configuração do Projeto

1. Crie um projeto Java na sua IDE (ex: Eclipse).
2. Nomeie-o XmlToJsonExample.
3. Adicione uma pasta data/input contendo sample.xml e sample.json.
4. Inclua Gson 2.8.5 no build path.
5. Adicione a API JAXB (geralmente incluída com Java 8).

Dados de Exemplo

Representação XML de um departamento com funções e pessoas:

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

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

Classes Modelo Java

Defina os seguintes POJOs no pacote model:

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

/* Person.java */
@XmlRootElement(name = "person")
public class Person {
    private String id, name, role;
    // getters, setters com anotações @XmlAttribute/@XmlElement
}

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

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

Deserializando XML para 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);
}

Serializando Objetos Java para 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));
}

Serializando Objetos Java para 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();
}

Deserializando JSON para 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();
}

Fluxo Completo de Conversão

1. Deserializar sample.xml em XMLModel usando JAXB.
2. Serializar os objetos Java resultantes para sample.json com Gson.
3. Deserializar sample.json de volta em objetos Java.
4. Serializar esses objetos em um novo arquivo XML.

Conclusão

Este guia demonstra um pipeline de conversão limpo de duas etapas: JAXB lida com XML ↔ Java, enquanto Gson lida com JSON ↔ Java. Combinando essas bibliotecas, desenvolvedores podem transformar dados entre formatos de forma confiável em aplicações Java.