JSON: Manipulação de Estruturas Complexas na Linguagem 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
 (5)  (0)

Veja neste artigo como lidar com mensagens JSON que possuem estrutura complexa (arrays, hierarquias e informações opcionais) na linguagem Java com o uso da biblioteca “org.json”

1. Introdução

No artigo que se encontra publicado no seguinte link: http://www.devmedia.com.br/trabalhando-com-json-em-java-o-pacote-org-json/25480, foi apresentada a biblioteca “org.json” que permite o processamento de JSON em programas Java. As instruções detalhadas para obtenção e configuração da biblioteca foram mostradas, assim como uma série de exemplos de utilização da mesma em programas Java.

Neste artigo, vamos utilizar a biblioteca “org.json”, porém com uma abordagem um pouco mais avançada. O objetivo é apresentar um programa Java capaz de manipular um objeto JSON com estrutura complexa. Definimos como objeto complexo aquele que possui uma ou mais dentre as seguintes características:

  • Arrays;
  • Hierarquias (ou Objetos dentro de Objetos);
  • Informações Opcionais.

2. Um Exemplo de Estrutura Complexa


O pequeno banco de dados “devmovies.json”, mostrado na Listagem 1, é um exemplo de estrutura complexa no formato JSON. Trata-se de um banco de dados sobre cinema que armazena as informações referentes a dois filmes hipotéticos: “Os Arquivos Json” e “Sexta-feira 13: JSON Vive”.

Listagem 1: devmovies.json

{
	"devmovies":
		{
		"filme":
			[
			{
				"id":1,
				"titulo":"Os Arquivos JSON ",
				"ano":1998,
				"resumo":"A história dos arquivos muito leves",
				"generos":["Ação","Sci-fi","Drama"],
				"elenco":["Gillian Triggerson","David Markupovny"]
			},
			{
				"id":2,
				"titulo":"Sexta-feira 13: JSON vive",
				"ano":1986,				
				"generos":["Ação","Horror"],
				"elenco":["Ann Labelvalue Pair", "Jennifer Json", "John Java"]
			}
			]
		}
}

No exemplo da Listagem 1, “devmovies” é um objeto cujo conteúdo é um outro objeto, denominado “filme”. Ou seja, logo no início do arquivo JSON temos um tipo de hierarquia simples. O objeto “filme”, por sua vez, é um array onde cada elemento representa um filme. Os dados armazenados para os filmes são: “id” (inteiro), “título” (String), “ano” (inteiro), “resumo” (informação opcional do tipo String – veja que o segundo filme não possui um resumo cadastrado), classificação dos gêneros do filme (o array de String “generos”) e elenco (array de String “elenco”).


3. Processando a Estrutura “devmovies.json”

O programa da Listagem 2 utiliza o pacote “org.json” para processar o banco de dados “devmovies.json”. Resumidamente o programa funciona da seguinte forma. Em primeiro lugar, montamos o banco de dados em uma variável do tipo String. Em seguida, importamos o seu conteúdo para uma variável do tipo JSONObject do pacote “org.json”. A partir daí, o programa mostra como podemos utilizar os métodos get() e opt() para recuperar as informações armazenadas neste JSONObject. Utilizamos o método get() para recuperar dados de campos obrigatórios e o método opt() para recuperar dados de campos opcionais (em nosso exemplo, o único campo opcional é “resumo”). É importante que você observe a forma utilizada pelo programa para manipular arrays, já que esta estrutura é bastante utilizada em textos JSON. Os comentários dentro do programa explicam mais detalhes sobre o funcionamento das linhas de código.

Listagem 2: Trabalhando com um objeto JSON complexo

import org.json.*;

public class JSONComplexo {

	public static void main(String[] args) throws JSONException {
		
		//entrada: string json com dados dos filmes
		String jsonStr = "{" +
				"\"devmovies\":" + 
				"{" +
				"\"filme\":" +
					"[" +
					"{" +
						"\"id\":1," +
						"\"titulo\":\"Os Arquivos JSON\"," +
						"\"ano\":1998," +
						"\"resumo\":\"A história dos arquivos muito leves\"," +
						"\"generos\":[\"Ação\",\"Sci-fi\",\"Drama\"]," + 
						"\"elenco\":[\"Gillian Triggerson\",\"David Markupovny\"]" +
					"}," +
					"{" +
						"\"id\":2," +
						"\"titulo\":\"Sexta-feira 13: JSON Vive\"," +
						"\"ano\":1986," +				
						"\"generos\":[\"Ação\",\"Horror\"]," +
						"\"elenco\":[\"Ann Labelvalue Pair\", \"Jennifer Json\", \"John Java\"]" +
					"}" +
					"]" +
				"}" +
		"}";

		//------------------------------------------------------
		// (1) importa a string para um JSONObject
		//------------------------------------------------------

		JSONObject devMovies = new JSONObject(jsonStr);
		
		//-------------------------------------------------------------
		// (2) trabalha o conteúdo do JSONObject
		//     imprimindo os dados dos filmes, a partir do objeto devMovies
		//------------------------------------------------------------------
		
		//obtém o objeto "devmovies"
		JSONObject filmes = devMovies.getJSONObject("devmovies");
		
		//obtém o array contendo todos os filmes de "devmovies"
		JSONArray arrFilmes = filmes.getJSONArray("filme");
		
		//monta laço que percorre o array e imprime os dados de cada filme
		for (int i=0; i < arrFilmes.length(); i++) {
			
			//recupera filme de índice "i" no array 
			JSONObject f = arrFilmes.getJSONObject(i);
			
			System.out.println("id: " + f.getInt("id"));
			System.out.println("titulo: " + f.getString("titulo"));
			System.out.println("ano: " + f.getInt("ano"));
			//como o campo "resumo" é opcional, é preciso usar o método "opt()"
			//se o valor "-" for omitido, a palavra "null" é impressa no segundo filme
			System.out.println("resumo: " + f.optString("resumo","-"));

			//gêneros
			JSONArray arrGeneros = f.getJSONArray("generos");
			for (int k=0; k < arrGeneros.length(); k++) {
				System.out.println("genero " + (k+1) + ": " + arrGeneros.getString(k));
			}
			
			//elenco
			System.out.println("elenco: ");
			JSONArray arrAtores = f.getJSONArray("elenco");
			for (int j=0; j < arrAtores.length(); j++) {
				System.out.println("\t" + arrAtores.getString(j));
			}
			
			System.out.println();
		}
		
	}
	
}

Para executar o programa, basta gravá-lo com o nome “JSONComplexo.java”. O resultado da execução é mostrado na Figura 1.

Resultado da Execução do Programa

Figura 1: Resultado da Execução do Programa

4. Conclusões e Comentários Finais

Este artigo abordou a manipulação de dados complexos no formato JSON em programas Java. O exemplo apresentado mostrou que a tarefa é, até certo ponto, simples com o uso da biblioteca “org.json” (ao menos, é bem mais simples do que manipular XML com uso das API’s SAX ou DOM!).

A única ressalva é que você precisa conhecer a estrutura do arquivo JSON que você irá processar, para que possa criar seu programa adequadamente. Considerando nosso exemplo, você precisa saber que existe um campo “devmovies”, e dentro dele um campo “filme”, e por aí vai. Lembre-se que, ao contrário do que ocorre com a XML, em JSON não dispomos de um esquema de validação que fornece informações de metadados do documento (papel desempenhado pela DTD e pelo XML Schema no mundo XML).

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