Conversão entre JSON e XML em Java

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (3)  (0)

Veja neste artigo como converter textos de XML para JSON e de JSON para XML em programas Java utilizando o pacote org.json. Estes formatos são largamente utilizados na representação e armazenamento de dados atualmente.

1. Introdução

JSON e XML representam duas importantes linguagens para a representação e troca de informaçõhes em aplicações Web. Nos dias atuais, é cada vez mais comum encontrar sistemas que, por uma ou outra razão, precisam trabalhar com ambos os formatos. Esta necessidade motivou o surgimento de programas utilitários que realizam a conversão de informações de XML para JSON e vice-versa.

Este artigo apresenta a classe “XML”, um programa utilitário do pacote “org.json” que possibilita a conversão entre os dois formatos na linguagem Java. Além de descrever a forma de utilização da classe, o artigo discute algumas diferenças conceituais entre XML e JSON que podem atrapalhar a vida dos desenvolvedores que precisam lidar com ambas as linguagens.

2. O Pacote “org.json”

A biblioteca “org.json” permite o processamento de JSON em programas Java. Em nossos dois últimos artigos, apresentamos as instruções detalhadas para obtenção e instalação da biblioteca e também mostramos uma série de exemplos de utilização da mesma em programas Java. O artigo que aborda a instalação da biblioteca pode ser consultado através do link: http://www.devmedia.com.br/trabalhando-com-json-em-java-o-pacote-org-json/25480.

De qualquer forma, não custa nada repetirmos de forma resumida o processo de instalação. Inicialmente, você deve acessar o site www.json.org/java e baixar todos os arquivos Java que estão relacionados na página. Se você usa uma IDE como o Eclipse ou Netbeans, basta criar um package chamado “org.json” em seu projeto e copiar os arquivos Java que você baixou para dentro deste package. Se você não utiliza nenhuma IDE, crie uma pasta para servir como pasta do projeto (por exemplo: C:\TESTE). Dentro desta pasta, crie uma pasta chamada org. Dentro da pasta org, crie uma pasta chamada json. A estrutura completa é mostrada na Figura 1. Copie todos os arquivos Java que você baixou para dentro da subpasta json.

Estrutura de pastas

Figura 1: Estrutura de pastas

3. A Classe XML

A classe “XML” (programa “XML.java”) fornece métodos estáticos que possibilitam a conversão de um documento (texto) XML para um JSONObject (tipo que armazena informações JSON na “org.json”) e para a conversão de um JSONObject para um documento XML. A classe XML deve ser utilizada em conjunto com a classe “XMLTokener” e também com as classes que formam o núcleo do pacote “org.json”: “JSONObject”, “JSONArray”, “JSONStringer”, “JSONWriter”, “JSONTokener”, “JSONException” e “JSONString”. Ou seja, você precisa de todas essas classes em seu ambiente para poder usar a classe “XML”.

Para explicarmos a forma de utilização da classe, faremos uso de exemplos envolvendo o arquivo “paises.xml”, mostrado na Listagem 1.

Listagem 1: paises.xml

<?xml version="1.0"?>
<paises>
   <pais sigla="BR">
       <nome>Brasil</nome>
       <populacao>196.655.014</populacao>
   </pais>
   <pais sigla="AR">
       <nome>Argentina</nome>
       <populacao>40.764.561</populacao>
   </pais>
</paises>

Inicialmente, apresentamos na Listagem 2 um programa que utiliza a classe XML para converter o documento XML de países para um objeto JSON. Em primeiro lugar, o XML é montado em uma variável do tipo String. Em seguida, o seu conteúdo é importando para uma variável do tipo JSONObject do pacote “org.json”. A partir daí, basta utilizar o método toString() para gerar uma string JSON contendo as informações dos países.

Listagem 2: Programa para Conversão de XML para JSON

import org.json.*;

public class Json2XML {

	public static void main(String[] args) throws JSONException {
		
		//--------------------------------------
		// (1) monta "paises.xml" em uma string
		//--------------------------------------
				
		String xmlString = "<?xml version=\"1.0\"?>" + 
					"<paises>" + 
						"<pais sigla=\"BR\">" + 
							"<nome>Brasil</nome>" + 
							"<populacao>196655014</populacao>" + 
						"</pais>" + 
						"<pais sigla=\"AR\">" + 
							"<nome>Argentina</nome>" + 
							"<populacao>40764561</populacao>" + 
						"</pais>" + 
					"</paises>";
		
		//--------------------------------------------------------------
		// (2) cria um JSONObject a partir do arquivo XML
		//     com o uso do método estático "toJSONObject" da classe XML
		//---------------------------------------------------------------
		
		JSONObject paisesJson = XML.toJSONObject(xmlString);
		
		//----------------------------------------------------------------
		// (3) gera e imprime a string JSON, com o uso do método toString() 
		//-----------------------------------------------------------------
		
		System.out.println(paisesJson.toString());
		
	}
}

O resultado da execução do programa é apresentado na Listagem 3.

Listagem 3: Resultado da Conversão de “países.xml” para JSON

{"paises":
{"pais":
[
{"populacao":196655014,"sigla":"BR","nome":"Brasil"},
{"populacao":40764561,"sigla":"AR","nome":"Argentina"}
]
}
}

Observe que, no resultado gerado, a ordem dos campos JSON não está igual à ordem das tags originalmente dispostas no documento XML. No XML, primeiro temos o atributo “sigla”, depois a tag “nome” e depois a tag “população”. Mas no JSON a ordem ficou diferente: primeiro “populacao”, depois “sigla” e depois “nome”.

Por que será? O que ocorre é que, no que diz respeito à ordem de disposição das informações, existe uma pequena diferença conceitual entre os formatos JSON e XML. Na linguagem XML a ordem das tags e do conteúdo é importante. Se dois documentos possuem as mesmas tags e o mesmo conteúdo, porém, em posições diferentes, eles são considerados documentos diferentes. Por exemplo, para a XML os documentos: verdevermelho e vermelhoverde são diferentes embora ambos possuam as mesmas tags e o mesmo conteúdo (mas no primeiro “verde” vem antes de “vermelho” e no segundo “verde” vem depois do “vermelho”, então isso basta para eles serem considerados diferentes na XML).

No caso do JSON é diferente. Um objeto JSON é definido como “uma coleção não ordenada de pares nome/valor”. Dessa forma, para o JSON, tanto faz a posição dos campos dentro de um objeto. Mas é importante registrar que no caso dos Arrays JSON, aí sim a posição é considerada (um array JSON é definido como uma “coleção ordenada de valores”). Por isso que, no exemplo apresentado, Brasil veio antes de Argentina: as posições dos países foram preservadas em relação ao XML original, já que a tag foi transformada em um array “pais” na string JSON.

Para concluir nosso artigo, agora é hora de apresentar o “vice-versa”, ou seja, vamos mostrar como podemos converter um dado no formato JSON para XML. Para tal, basta utilizar o método toString() da classe XML. No programa da Listagem 4, estendemos o programa mostrado anteriormente, para mostrar como o documento “países.xml” é primeiro convertido para JSON e depois convertido novamente para XML.

Listagem 4:Conversão de JSON para XML

import org.json.*;

public class Json2XML {

	public static void main(String[] args) throws JSONException {
		
		//--------------------------------------
		// (1) monta "paises.xml" em uma string
		//--------------------------------------
				
		String xmlString = "<?xml version=\"1.0\"?>" + 
					"<paises>" + 
						"<pais sigla=\"BR\">" + 
							"<nome>Brasil</nome>" + 
							"<populacao>196655014</populacao>" + 
						"</pais>" + 
						"<pais sigla=\"AR\">" + 
							"<nome>Argentina</nome>" + 
							"<populacao>40764561</populacao>" + 
						"</pais>" + 
					"</paises>";
		
		//--------------------------------------------------------------
		// (2) cria um JSONObject a partir do arquivo XML
		//     com o uso do método estático "toJSONObject" da classe XML
		//---------------------------------------------------------------
		
		JSONObject paisesJson = XML.toJSONObject(xmlString);
		
		//--------------------------------------------------------------
		// (3) gera uma string JSON e imprime 
		//---------------------------------------------------------------
		
		System.out.println(paisesJson.toString());

		//--------------------------------------------------------------
		// (4) gera um objeto JSON a partir de paisesJson.toString() 
		//---------------------------------------------------------------
		
		JSONObject novoPaisesJSON = new JSONObject(paisesJson.toString());
		
		//--------------------------------------------------------------------------
		// (5) gera um texto XML a partir desse novo objeto e imprime o seu conteúdo 
		//---------------------------------------------------------------------------
		
		String xmlStr2 = XML.toString(novoPaisesJSON);

		System.out.println(xmlStr2);
	}
}

O XML final é mostrado na Listagem 5.

Listagem 5: Resultado da Conversão de JSON para XML

<paises>
	<pais>
		<populacao>196655014</populacao>
		<sigla>BR</sigla>
		<nome>Brasil</nome>
	</pais>
	<pais>
		<populacao>40764561</populacao>
		<sigla>AR</sigla>
		<nome>Argentina</nome>
	</pais>
</paises>

Apesar de simples, o exemplo mostra algumas coisas interessantes. Em primeiro lugar quando fazemos uma conversão XML-JSON-XML, a ordem das tags pode ser trocada pela classe “XML”, conforme já havíamos mencionado. Isso pode se tornar um problemão caso você esteja trabalhando com validação por DTD ou XML Schema.

Mas este não é o único problema. Outra coisa que ocorre é que, pelo fato de JSON não trabalhar com o conceito de atributo, você pode observar que a “sigla” - que era um atributo no XML original - acabou se transformando em uma tag no XML final.

Ambos os problemas apresentados deveriam, de alguma forma, ser tratados por um utilitário de conversão XML-JSON, mas infelizmente a classe “XML” do pacote “org.json” possui essa limitação.

4. Conclusões e Comentários Finais

Esse artigo apresentou um programa utilitário para conversão de XML para JSON e JSON para XML em Java. O programa é simples de utilizar e bastante útil em diversas situações práticas. No entanto, o desenvolvedor deverá estar atento para os problemas envolvendo a conversão de atributos e a ordem de disposição das informações.

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?