Converta JSON em XML Java usando Gson e JAXB com exemplo

O que é JSON?

JSON é uma abreviatura 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 registro no banco de dados. O formato JSON usa pares de valores-chave para descrever os dados.

A seguirwing No 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 objeto Java em uma string JSON e também converter de uma string JSON em um objeto Java. 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 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 objetos Java em 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, costumamos usar o seguintewing 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 objeto Java, Desempacotador.

Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();

Neste curso Contexto JAXB objeto, ele possui um método para criar o objeto que converte o objeto Java no 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) Desenvolvimento Java x64 para Ubuntu.
  • Gson 2.8.5.

Passo 1) Criar projeto.
Crie um novo projeto Java.

Crie um novo projeto Java.
Crie um novo projeto Java.

Passo 2) Defina o nome do projeto.
Definir o nome do projeto como XmlToJsonExemplo.

Definir nome do projeto

Defina o nome do projeto.

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

Criar dados de pasta

Crie dados/entrada de pasta.

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

O general architecnologia é: ; .

Relacionamentos de objetos

Relacionamentos de objetos.

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

Definir classes de objetos

Defina classes de objetos.

  • 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.
Adicione e configure a biblioteca Gson 2.8.5 no Java Build Path.

Configurar biblioteca Gson

Adicione a biblioteca Gson 2.8.5 ao Java Build Path

Adicione a biblioteca Gson 2.8.5 ao Java Build Path.

Converter mensagem XML em objetos Java usando JAXB

Primeiramente, definimos o desempenho classificado no pacote serviço.

Definir aulas performáticas

Defina classes performáticas.

Na primeira etapa do primeiro processo, utilizamos a técnica Un-marshalling do JAXB.

O desempacotamento fornece a um aplicativo cliente a capacidade de converter dados XML em objetos Java derivados de JAXB.

Nós definimos função getObjectFromXmlFile para desempacotar nosso arquivo XML de volta para um objeto Java. 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 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 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 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 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 objetos Java em mensagem XML usando JAXB

Nesta etapa, utilizamos a técnica Marshalling de JAXB.

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