O Java 7 trouxe consigo diversas atualizações e novidades, uma delas é JSON Processor API
na especificação 353, com impacto não muito grande na rotina de desenvolvimento, por estar em background.

Mas assim como é importante compreender Servlet e um pouco de JSP para trabalhar com JSF, faz-se importante estudar esta API, que é largamente utilizada nos servidores JavaEE, por conseguinte nas aplicações que são executadas nele.

Um dica interessante, se você tem interesse em Java e quer estudar APIs, mas cree que são coisas enorme e, complicadas, esta enganado! Esta é uma pequena e simples, mas extremamente valiosa. A importância dessa tecnologia é evidente quando notamos o poder do JSON na troca de informações entre sistemas, também como se tornou padrão de formato das aplicação RESTful, mas também largamente utilizada na comunição respostas Ajax, por isso tão presente no JSF.

Crie um Maven project, escreva o pom.xml como esta abaixo:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>br</groupId>
    <artifactId>jsonParse</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>javax.json</groupId>
            <artifactId>javax.json-api</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish</groupId>
            <artifactId>javax.json</artifactId>
            <version>1.0.4</version>
        </dependency>
    </dependencies>
</project>

O código logo abaixo é uma exemplo de como gerar JSON em JavaEE:

import java.util.HashMap;
import java.util.Map;

import javax.json.Json;
import javax.json.JsonArray;
import javax.json.JsonArrayBuilder;
import javax.json.JsonBuilderFactory;
import javax.json.JsonObject;
import javax.json.JsonObjectBuilder;
import javax.json.JsonWriter;
import javax.json.stream.JsonGenerator;
import javax.json.stream.JsonGeneratorFactory;

public class SpecJsonP {
	public final static Map<String, Object> getProperties() {
		Map<String, Object> properties = new HashMap<String, Object>();
		// Apresentação do json de maneira não compactado
		properties.put(JsonGenerator.PRETTY_PRINTING, true);
		return properties;
	}

	/*
	 * Aqui ocorre uma visão baixa, uma vez que há construção do Json sem
	 * qualquer abstração, só há uma única camada, a camada de escrita
	 */
	public final static void JsonPGenerator() {
		// Gerador de Json, transforma os Models Json em String, ou seja, em
		// Json
		JsonGeneratorFactory jgf = Json.createGeneratorFactory(SpecJsonP
				.getProperties());

		/*
		 * O padrão de projetos adotados para gerar Json é build, portanto as
		 * funções retornam um objeto do mesmo tipo.
		 */
		// Descarrega a String na saída
		JsonGenerator jg = jgf.createGenerator(System.out);

		// Inicia a escrita de um Objeto Json
		jg.writeStartObject()

		/*
		 * Se houver a tentativa de utilizar writeStartObject(String
		 * paramString), será lançada a seguinte exceção Illegal method during
		 * JSON generation, not valid in current context IN_NONE, pois como
		 * sabemos o primeiro objecto de um Json deve ser anônimo, ou seja, sem
		 * nome. Descomente a linha abaixo e faça o teste.
		 */
		 //jg.writeStartObject("obj")

				// Escreve um atributo
				.write("attr", "atibuto")

				// Inicia a escrita de um Objeto
				.writeStartObject("obj")
				// Escreve um atributo
				.writeNull("attr")
				// Encerra escrita do Objeto
				.writeEnd()

				// Encerra escrita do Objeto
				.writeEnd()

				/*
				 * Se não houver chamada do método, a escrita pode não funcionar
				 * como devido. Imagine que gostaria de aproveitar a Saída ou
				 * mesmo o Generator o comportamento não seria o esperado.
				 */
				// Descarrega o Json, escreve
				.flush();
		// Encerra a escrita do Json
		jg.close();
	}

	/*
	 * Aqui há uma visão mais abstrata, com duas camadas. A primeira
	 * camada de construção dos objetos Json a outra escrita dos Json.
	 */
	public final static void JsonPBuilder() {
		// Construtor de Json
		JsonBuilderFactory jbf = Json.createBuilderFactory(SpecJsonP
				.getProperties());
		// Construção de objetos
		JsonObjectBuilder job = jbf.createObjectBuilder();

		// Adiciona Atributo
		job.add("attr", 1l);

		// Constrõe o objeto
		JsonObject jo = job.build();

		JsonArrayBuilder jab = jbf.createArrayBuilder();
		// Adicionar itens
		jab.add("123");
		jab.add(1);
		jab.add(1L);
		// Adicionar Objeto na lista
		jab.add(jo);

		// Constrõe o Array
		JsonArray ja = jab.build();

		JsonWriter jw1 = Json.createWriter(System.out);
		// Escrever no Array
		jw1.writeArray(ja);
		// Encerra a escrita
		jw1.close();

		// Modifica o Objeto Json
		jab.add(123);
		ja = jab.build();

		// Define um Stream de escrita
		try(JsonWriter jw = Json.createWriter(System.out)){
			// Escrever no Array
			jw.writeArray(ja);
		} // Encerra a escrita
	}

	public static void main(String[] args) {
        //Descomente um método por vez para testar
		//SpecJsonP.JsonPBuilder();
		//SpecJsonP.JsonPGenerator();
	}
}

Algumas dúvidas podem surgir:

Como gerar tipo Date em Json?

Na verdade classe Date é somente um long, que possui alguns cálculos. O que precisa fazer é invocar o
método getTime() este método retorna o long. Vale lembrar que nas definições de tipo JSON não há
tipo Date – mas existem a “classe” Date em javascript, tampouco haverá na API.

Qual a diferença em usar JsonGenerator e JsonWrite ?

JsonWrite é mais gerenciável, portanto trabalha com Stream, podendo escrever diversos Json na Stream. O outro funciona diretamente na escrita na saída. Se estudarmos a implementação da API provida pela equipe do Glassfish – servidor de referência da JavaEE 7, veremos que JsonGenerator compõe a classe JsonWrite.

Anúncios