Converter JSON em XML Java usando Gson e JAXB com exemplo
James Hartmann
O que é JSON?
JSON é uma abreviação de Javascript Object Notation, que é uma forma de dados que segue uma certa regra que a maioria das linguagens de programação são legíveis atualmente. Podemos facilmente salvá-lo em um arquivo ou registro no banco de dados. O formato JSON usa pares de chave-valor para descrever dados.
Seguindo o exemplo, definimos uma string JSON que armazena informações pessoais:
{
"username" : "guru99user",
"email" : "guru99user@mail.com"
}
Portanto, a sintaxe do JSON é muito simples. Cada informação de dado terá duas partes: chave e valor que correspondem ao nome do campo e seu valor em determinado registro. Mas olhando mais a fundo, existem algumas coisas como esta:
- A string JSON é colocada entre chaves {}.
- As chaves e valores do JSON devem ser colocados entre aspas {“}.
- Se houver mais dados (mais pares chave => valor), usamos vírgulas (,) para separar.
- As chaves JSON devem conter letras ou números sem sinal, _, e sem espaços; o primeiro caractere não deve ser definido como números.
O que é XML?
XML significa eXtensible Markup Language, também chamada de linguagem de marcação extensível proposta pelo World Wide Web Consortium (https://www.w3.org/) para criar outras linguagens de marcação. Este é um subconjunto simples que pode descrever muitos tipos diferentes de dados, por isso é muito útil no compartilhamento de dados entre sistemas.
As tags em XML geralmente não são predefinidas, mas são criadas de acordo com as convenções do usuário. XML introduz novos recursos baseados nas vantagens do HTML.
Existem alguns recursos de criação de XML mais úteis em diversos sistemas e soluções:
- XML é extensível: XML permite que você crie suas próprias tags personalizadas para se adequar à sua aplicação.
- XML carrega dados, não os exibe: XML permite armazenar dados independentemente de como eles serão exibidos.
- XML é um padrão comum: XML foi desenvolvido pelo World Wide Web Consortium (W3C) e está disponível como um padrão aberto.
XML é construído em uma estrutura de nós aninhados. Cada nó terá uma tag de abertura e uma tag de fechamento da seguinte forma:
<node>content</node>
No qual:
- é uma tag aberta, o nome desta tag é definido por você.
- é uma tag fechada, o nome desta tag deve corresponder ao nome da tag aberta.
- conteúdo é o conteúdo desta tag.
No topo de cada arquivo XML você deve declarar uma tag para indicar a versão do XML que está em uso. A sintaxe da tag de instrução:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
O que é Gson?
Gson (https://github.com/google/gson) é uma biblioteca Java que permite aos usuários converter de um Java objeto para string JSON e também converter de uma string JSON para Java objeto. Gson pode trabalhar com arbitrários Java objetos, incluindo objetos existentes, sem que você tenha seu código-fonte.
Desde a versão 1.6, Gson apresenta duas novas classes – JsonReader e JsonWriterGenericName para fornecer processamento de streaming em dados JSON.
- JsonWriterGenericName – Streaming de gravação em JSON. A sintaxe para implementação geral é a seguinte. Nós criamos um JsonWriterGenericName objeto. Para iniciar e terminar a criação de uma string JSON, usamos a função começarObject() e fimObject(). No meio da execução dessas duas funções, realizamos a escrita dos dados com pares (chave => valor).
JsonWriter writer = new JsonWriter();
writer.beginObject();
writer.name("key").value("value");
writer.endObject();
- JsonReader – Streaming lido de JSON. A sintaxe para implementação geral é a seguinte. Criamos um objeto JsonReader. Para iniciar e terminar a criação de uma string JSON, usamos as funções beginObject() e endObject(). No meio da execução dessas duas funções, realizamos a leitura dos dados com pares (chave => valor).
JsonReader reader = new JsonReader();
reader.beginObject();
while (reader.hasNext()) {
String name = reader.nextName();
if (name.equals("key")) {
String value = reader.nextString();
}
}
reader.endObject();
O processamento de streaming do Gson é rápido. No entanto, você precisa lidar com cada par (chave => valor) de processamento de dados JSON.
O que é JAXB?
JAXB significa Java Archiarquitetura para XML Binding, que é uma biblioteca que usa anotações para converter Java objetos para conteúdo XML e vice-versa. Como o JAXB é definido através de uma especificação, podemos usar diferentes implementações para este padrão.
Com JAXB, geralmente usamos as seguintes anotações básicas, a saber:
- @XmlRootElement: esta anotação especifica qual é a tag mais externa do arquivo XML e, portanto, ela é declarada no topo de uma classe.
- @XmlElementWrapper: esta anotação cria um elemento XML wrapper em torno das coleções.
- @XmlElement: Esta anotação usada para declarar um atributo do objeto é uma tag do arquivo XML.
- @XmlAttribute: Esta anotação também usada para declarar um atributo do objeto é uma tag do arquivo XML.
A sintaxe para implementação geral é a seguinte. Primeiro, inicializaremos o Contexto JAXB objeto com o Meuobjeto objeto a ser convertido.
JAXBContext jaxbContext = JAXBContext.newInstance(MyObject.class);
Neste curso Contexto JAXB objeto, possui um método para criar um objeto que converte o conteúdo XML em um Java objeto, Desempacotador.
Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
Neste curso Contexto JAXB objeto, possui um método para criar o objeto que converte o Java objeto ao conteúdo XML que é Marechal.
Marshaller marshallerObj = jaxbContext.createMarshaller();
Como converter XML para JSON?
Implementamos o exemplo de conversão XML – JSON na plataforma:
- Abra o JDK 8 para Ubuntu 18.04 x64.
- Eclipse IDE 2019-03 (4.11.0) x64 Java Desenvolvimento para Ubuntu.
- Gson 2.8.5.
Passo 1) Criar projeto.
Crie um novo Java Projeto.
Passo 2) Defina o nome do projeto.
Definir o nome do projeto como XmlToJsonExemplo.
Passo 3) Crie uma pasta
Criar pasta dados/entrada contendo dois arquivos amostra.xml e amostra.json.
Vamos primeiro definir nosso XML com departamento, papel e pessoa propriedades.
A arquitetura geral é: ; .
<?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>
Em segundo lugar, definimos JSON tendo a mesma ideia:
{
"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"
}
]
}
]
}
Passo 4) Defina objeto.
Defina classes de objetos correspondentes no pacote modelo.
- Função.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;
}
}
- Pessoa.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;
}
}
- Departamento.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;
}
}
Passo 5) Configurar biblioteca.
Adicionar e configurar a biblioteca Gson 2.8.5 em Java Construir caminho.
Converter mensagem XML em Java objetos usando JAXB
Primeiramente, definimos o desempenho classificado no pacote serviço.
Na primeira etapa do primeiro processo, utilizamos a técnica Un-marshalling do JAXB.
Un-marshalling fornece a um aplicativo cliente a capacidade de converter dados XML em dados derivados de JAXB Java objetos.
Nós definimos função getObjectFromXmlFile para desempacotar nosso arquivo XML de volta para um Java objeto. Esta função é definida na classe Serviço XML.
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;
}
}
Chamamos o código acima na 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();
Então vamos para o próximo passo.
Converter Java objetos para mensagem JSON usando Gson
Nesta etapa, definimos a função writeDataToJsonFile para gravar dados no arquivo JSON. Esta função é definida na classe JsonService.
Observe que para escrever uma lista de strings JSON, usamos a função começarArray() e fimArray(). Entre essas duas funções, escrevemos cada string 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) {
}
}
Chamamos o código acima na classe XmlToJsonService.
JsonService jsonService = new JsonService(); jsonService.writeDataToJsonFile(filePathOut, roles, persons);
Esse é o primeiro processo.
Converter mensagem JSON em Java objetos usando Gson
Na primeira etapa do segundo processo, definimos a função getDataFromJsonFile para ler dados do arquivo JSON. Esta função é definida na classe JsonService.
Observe que para ler uma lista de strings JSON, usamos a função começarArray() e fimArray(). Entre essas duas funções, lemos cada string 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) {
}
}
Chamamos o código acima na classe XmlToJsonService.
JsonService jsonService = new JsonService(); List<Role> roles = new ArrayList<>(); List<Person> persons = new ArrayList<>(); jsonService.getDataFromJsonFile(filePathIn, roles, persons);
Como converter Json para XML Java?
JSON para XML in JAVA é convertido usando JSONObject json = new JSONObject(str); Corda xml=XML. Se você tiver um arquivo dtd válido ou o arquivo xml, é muito fácil transformar json em xml e também xml em json.
Então vamos para o próximo passo.
Converter Java objetos para mensagem XML usando JAXB
Nesta etapa, utilizamos a técnica Marshalling de JAXB.
Marshalling fornece a um aplicativo cliente a capacidade de converter um derivado de JAXB Java árvore de objetos em dados XML.
Definimos a função parseObjectToXm para marshall Java objeto para mensagem XML. Esta função é definida na 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");
}
}
Chamamos o código acima na 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);
Esse é o segundo processo.
Conclusão
Neste tutorial, aprendemos brevemente uma maneira pela qual o JAXB pode ler dados XML e o Gson gravá-los em JSON. Pelo contrário, também vimos a forma como Gson lia JSON data e JAXB gravam-nos em XML.
