Converter JSON em XML Java usando Gson e JAXB

O que é JSON?

JSON é uma abreviação de JavaA Notação de Objetos de Script (Script Object Notation - JSON) é um formato de dados que segue regras que a maioria das linguagens de programação consegue ler. Podemos salvá-la facilmente em um arquivo ou armazená-la em um banco de dados. O formato JSON utiliza pares de chave-valor para descrever os dados.

No exemplo a seguir, definimos uma string JSON que armazena informações pessoais:

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

A sintaxe do JSON é muito simples. Cada item de dados possui duas partes: uma chave e um valor, que correspondem ao nome do campo e ao seu valor em um registro. Analisando mais a fundo, existem algumas regras como esta:

• A string JSON é colocada entre chaves {}.
• As chaves do JSON devem estar entre aspas duplas, e os valores de string também devem ser colocados entre aspas.
• Se houver mais dados (mais pares chave => valor), usamos vírgulas (,) para separá-los.
• As chaves JSON devem usar letras, números ou o caractere de sublinhado, sem espaços, e o primeiro caractere não deve ser um número.

O que é XML?

XML significa Linguagem de Marcação Extensível, proposta pelo Consórcio World Wide Web (https://www.w3.org/) para criar outras linguagens de marcação. Este é um subconjunto simples que pode descrever muitos tipos diferentes de dados, sendo muito útil para compartilhar 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 algumas funcionalidades XML úteis para diversos sistemas e soluções:

• XML é extensível: XML permite que você crie suas próprias tags personalizadas para se adequar à sua aplicação.
• O XML transporta dados, não os exibe: o 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.

O XML é construído sobre uma estrutura de nós aninhados. Cada nó possui uma tag de abertura e uma tag de fechamento, conforme descrito a seguir:

<node>content</node>

No qual:

• É uma tag aberta, e o nome dessa tag é definido por você.
• é uma tag de fechamento, e o nome dessa tag deve corresponder ao nome da tag de abertura.
• o conteúdo é o conteúdo desta tag.

No início de cada arquivo XML, você deve declarar uma tag para indicar a versão do XML em uso. A sintaxe da tag de instrução é a seguinte:

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

JSON vs XML: Principais Diferenças

Ambos os formatos contêm dados estruturados, e a tabela abaixo mostra por que um projeto pode precisar migrar entre eles.

O que é Gson?

Gson (https://github.com/google/gson) É um Java biblioteca que permite aos usuários converter um Java converter um objeto em uma string JSON e também converter uma string JSON de volta para um objeto. Java objeto. Gson pode trabalhar com arbitrários Java objetos, incluindo objetos existentes cujo código-fonte você não possui.

Desde a versão 1.6, o Gson introduz duas classes, JsonReader e JsonWriter, para fornecer processamento de fluxo contínuo de dados JSON.

• JsonWriter – Gravação em fluxo contínuo para JSON. Criamos um JsonWriter objeto. Para iniciar e finalizar a criação de um objeto JSON, utilizamos as funções. começarObject() e fimObject()Entre essas duas chamadas, escrevemos os dados em pares (chave => valor).

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

• JsonReader – Leitura em fluxo contínuo de JSON. Criamos um objeto JsonReader. Para iniciar e finalizar a leitura de um objeto JSON, usamos as funções beginObject() e endObject(). Entre essas duas chamadas, lemos os dados em 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 fluxos de dados do Gson é rápido. No entanto, você precisa manipular cada par (chave => valor) dos dados JSON manualmente.

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 por uma especificação, podemos usar diferentes implementações desse padrão.

Com o JAXB, costumamos usar as seguintes anotações básicas:

• @XmlRootElementEsta anotação especifica a tag mais externa do arquivo XML e, portanto, é declarada acima de uma classe.
• @XmlElementWrapper: esta anotação cria um elemento XML wrapper em torno das coleções.
• @XmlElementEsta anotação declara que uma propriedade do objeto se torna uma tag filha do arquivo XML.
• @XmlAttributeEsta anotação declara que uma propriedade do objeto se torna um atributo da tag que a envolve.

A implementação geral é a seguinte. Primeiro, inicializamos o Contexto JAXB objeto com o Meuobjeto classe a ser convertida.

JAXBContext jaxbContext = JAXBContext.newInstance(MyObject.class);

Este Contexto JAXB O objeto possui um método que cria um objeto que converte conteúdo XML em um Java objeto, o Desempacotador.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

O mesmo Contexto JAXB O objeto também possui um método que cria o objeto que converte um Java objeto em conteúdo XML, o Marechal.

Marshaller marshallerObj = jaxbContext.createMarshaller();

Como converter XML para JSON?

Implementamos o exemplo de conversão de XML para JSON na seguinte plataforma. As versões abaixo são as utilizadas nas capturas de tela. Versões mais recentes do JDK, Eclipse, e o Gson funcionam da mesma maneira, sujeitos à observação do JAXB acima.

• OpenJDK 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.
Defina o nome do projeto para XmlToJsonExemplo.

Passo 3) Crie uma pasta
Crie a pasta dados/entrada contendo os dois arquivos amostra.xml e amostra.json.

Vamos primeiro definir nosso XML com departamento, papel e pessoa propriedades.

A arquitetura geral é a seguinte: um departamento tem várias funções, e uma função tem várias pessoas. O diagrama abaixo mostra essas relações.

<?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 o JSON que expressa a mesma ideia. Observe que a lista simples de pessoas se transforma em um array aninhado dentro de cada função, que é exatamente a transformação realizada pelo código de conversão.

{
	"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 objetos.
Defina as classes de objetos correspondentes no pacote. modelo.

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;
	}

}

Passo 5) Configure a biblioteca.
Adicione e configure a biblioteca Gson 2.8.5 no Java Construir caminho.

Se o projeto usar Maven Em vez de um arquivo JAR adicionado manualmente, as mesmas bibliotecas são declaradas como dependências. A versão 2.8.5 está fixada aqui para corresponder às capturas de tela, e qualquer versão posterior do Gson funciona de forma idêntica para este exemplo:

<dependencies>
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.8.5</version>
    </dependency>

    <!-- required on Java 11 and later -->
    <dependency>
        <groupId>jakarta.xml.bind</groupId>
        <artifactId>jakarta.xml.bind-api</artifactId>
    </dependency>
    <dependency>
        <groupId>org.glassfish.jaxb</groupId>
        <artifactId>jaxb-runtime</artifactId>
    </dependency>
</dependencies>

Converter mensagem XML em Java objetos usando JAXB

Primeiramente, definimos as classes de execução no pacote. serviço.

Na primeira etapa do primeiro processo, utilizamos a técnica de desempacotamento do JAXB.

A desserialização permite que um aplicativo cliente converta dados XML em dados derivados do JAXB. Java objetos.

Definimos a função getObjectFromXmlFile para desserializar 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();

Neste ponto, o arquivo XML tornou-se três Java objetos na memória. O próximo passo os grava como JSON.

Converter Java objetos para mensagem JSON usando Gson

Nesta etapa, definimos a função. writeDataToJsonFile Para escrever dados no arquivo JSON. Esta função está definida na classe. JsonService.

Observe que, para escrever uma lista de objetos JSON, usamos as funções. começarArray() e fimArray()Entre essas duas chamadas, escrevemos cada objeto 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. O loop interno compara cada pessoa com o ID da função atual, e é assim que a lista de pessoas em XML se transforma em um array JSON aninhado.

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 está definida na classe JsonService.

Observe que, para ler uma lista de objetos JSON, usamos as funções. começarArray() e fimArray()Entre essas duas chamadas, lemos cada objeto 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);

Converter Java objetos para mensagem XML usando JAXB

Nesta etapa, utilizamos a técnica de serialização do JAXB.

O Marshalling fornece a um aplicativo cliente a capacidade de converter um objeto derivado de JAXB. Java árvore de objetos em dados XML.

Definimos a função parseObjectToXml para reunir o Java objeto para uma mensagem XML. Esta função é definida na classe Serviço XML.

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. O arquivo gerado corresponde ao sample.xml original, o que confirma que a comunicação completa preservou todos os valores.

Como converter JSON para XML em Java Sem uma classe de modelo?

A abordagem acima é a escolha certa quando a estrutura é conhecida e estável, porque as classes anotadas documentam a condição.tracQuando a estrutura é desconhecida ou muda com frequência, um conversor genérico é mais rápido.

O org.json A biblioteca realiza a conversão em duas linhas, sem nenhuma classe de modelo:

import org.json.JSONObject;
import org.json.XML;

public class QuickConverter {

    public static void main(String[] args) {
        String str = "{\"username\":\"guru99user\",\"email\":\"guru99user@mail.com\"}";

        JSONObject json = new JSONObject(str);
        String xml = XML.toString(json);

        System.out.println(xml);
    }
}

Saída:

<username>guru99user</username><email>guru99user@mail.com</email>

Note que a rota genérica não produz nenhum elemento raiz nem atributos, portanto XML.toString(json, "root") Normalmente é necessário. A tabela abaixo compara as duas abordagens lado a lado.

O JAXB lê dados XML e o Gson os grava em JSON, e o caminho inverso usa o Gson para ler. JSON dados enquanto o JAXB os grava de volta em XML. Para saber mais, revise XML fundamentos, o mais amplo Java tutorial e Relatórios Jasper, que utiliza ambos os formatos como fontes de dados para relatórios.

Perguntas Frequentes