Converter JSON para XML Java usando Gson e JAXB com Exemplo
O que é JSON?
JSON é uma abreviação de Javascript Object Notation, que é uma forma de dados que segue uma certa regra de que a maioria das linguagens de programação são atualmente legíveis. Podemos salvá-lo facilmente em um arquivo ou registrá-lo no banco de dados. O formato JSON usa pares de valores-chave para descrever dados.
Seguindo o exemplo, definimos uma string JSON que armazena informações pessoais:
{
"username" : "guru99user",
"email" : "[email protected]"
}
Portanto, a sintaxe do JSON é muito simples. Cada informação de dados terá duas partes:chave e valor que correspondem ao nome do campo e seu valor em um determinado registro. Mas, olhando mais longe, existem algumas coisas como esta:
- A string JSON é delimitada por chaves {}.
- As chaves e valores de JSON devem estar entre aspas {“}.
- Se houver mais dados (mais pares de chave => valor), usamos vírgulas (,) para separar.
- As chaves JSON devem ser letras ou números sem sinal, _ e sem espaços. O primeiro caractere não deve ser definido como números.
Neste tutorial, você aprenderá-
- O que é JSON?
- O que é XML?
- O que é Gson?
- O que é JAXB?
- Como converter XML para JSON?
- Converter mensagem XML em objetos Java usando JAXB
- Converter objetos Java em mensagens JSON usando Gson
- Converter mensagem JSON em objetos Java usando Gson
- Converter objetos Java em mensagens XML usando JAXB
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:
- O XML é extensível:o XML permite que você crie suas próprias tags personalizadas para se adequar ao seu aplicativo.
- O XML carrega dados, não os exibe:o XML permite que você armazene dados independentemente de como eles serão exibidos.
- O XML é um padrão comum:o 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ó aninhado. Cada nó terá uma tag de abertura e uma tag de fechamento da seguinte forma:
<node>content</node>
Em que:
é uma tag aberta, o nome desta tag é definido por você. - é uma tag fechada, o nome dessa tag deve corresponder ao nome da tag aberta.
- conteúdo é o conteúdo desta tag.
Na parte superior 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 objeto Java para uma string JSON e também converter de uma string JSON para um objeto Java. O Gson pode trabalhar com objetos Java arbitrários, incluindo objetos existentes, sem que você tenha seu código-fonte.
Desde a versão 1.6, Gson apresenta duas novas classes – JsonReader e JsonWriter para fornecer processamento de streaming em dados JSON.
- JsonWriter – Gravação de streaming para JSON. A sintaxe para implementação geral é a seguinte. Criamos um JsonWriter objeto. Para iniciar e terminar a criação de uma string JSON, usamos a função beginObject() e endObject() . No meio da execução dessas duas funções, realizamos a escrita de dados com pares (chave => valor).
JsonWriter writer = new JsonWriter();
writer.beginObject();
writer.name("key").value("value");
writer.endObject();
- JsonReader – Streaming de leitura 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 a função beginObject() e endObject(). No meio da execução dessas duas funções, realizamos a leitura de 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 Gson é rápido. No entanto, você precisa lidar com cada par (chave => valor) de processamento de dados JSON.
O que é JAXB?
JAXB significa Java Architecture for XML Binding, que é uma biblioteca que usa anotações para converter objetos Java em conteúdo XML e vice-versa. Como o JAXB é definido por meio 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 externa do arquivo XML e, portanto, é 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 JAXBContext objeto com o MeuObjeto objeto a ser convertido.
JAXBContext jaxbContext = JAXBContext.newInstance(MyObject.class);
Neste JAXBContext objeto, ele tem um método para criar um objeto que converte o conteúdo XML em um objeto Java, Unmarshaller .
Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
Neste JAXBContext objeto, ele tem um método para criar o objeto que converte o objeto Java para o conteúdo XML que é Marshaller .
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 Desenvolvimento Java para Ubuntu.
- Gson 2.8.5.
Etapa 1 . Criar projeto.
Criar um novo projeto Java.
Etapa 2 . Defina o nome do projeto.
Definir o nome do projeto é XmlToJsonExample .
Etapa 3 . Crie uma pasta.
Crie a pasta dados/entrada contendo dois arquivos sample.xml e amostra.json .
Vamos primeiro definir nosso XML com departamento , função 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 com 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"
}
]
}
]
}
Etapa 4 . Defina o objeto.
Defina as classes de objeto correspondentes no pacote model .
- Role.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;
}
}
- Person.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;
}
}
Etapa 5 . Configure a biblioteca.
Adicione e configure a biblioteca Gson 2.8.5 no Java Build Path.
Converter mensagem XML em objetos Java usando JAXB
Em primeiro lugar, definimos o desempenho classificado no pacote serviço .
Na primeira etapa do primeiro processo, utilizamos a técnica Un-marshalling de JAXB.
O desempacotamento fornece a um aplicativo cliente a capacidade de converter dados XML em objetos Java derivados de JAXB.
Definimos a função getObjectFromXmlFile para un-marshal nosso arquivo XML de volta para um objeto Java. Esta função é definida na classe XMLService .
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 objetos Java em 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 beginArray() e endArray() . 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 objetos Java 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 beginArray() e endArray() . 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 em JAVA é convertido usando JSONObject json =new JSONObject(str); String 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 objetos Java em mensagem XML usando JAXB
Nesta etapa, utilizamos a técnica Marshalling de JAXB.
O Marshalling fornece a um aplicativo cliente a capacidade de converter uma árvore de objetos Java derivada de JAXB em dados XML.
Definimos a função parseObjectToXm para empacotar o objeto Java para a 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 JAXB pode ler dados XML e Gson gravá-los em JSON. Pelo contrário, também vimos a maneira como o Gson lê os dados JSON e o JAXB os grava em XML.
Java
- Classe e objeto C++ com exemplo
- Java Hello World:Como escrever seu primeiro programa Java com exemplo
- Método String Length () em Java:como encontrar com exemplo
- Método Java String charAt() com exemplo
- String Java contém() Método | Verificar substring com exemplo
- Java String EndsWith() Método com Exemplo
- Java BufferedReader:Como Ler Arquivo em Java com Exemplo
- Série Fibonacci em Java usando o programa de recursão e loops
- Algoritmo de ordenação por inserção em Java com exemplo de programa
- Classificação de seleção no programa Java com exemplo