JSON

JSON Simples e Prático, Parte II

Fala pessoal!

Seguindo a ideia do post anterior sobre JSON, hoje vamos a um exemplo mais palpável, real e divertido: Simular uma integração com o famoso Facebook!

O Facebook, assim como diversos sistemas, disponibiliza acesso aos seus recursos através de alguns métodos. A este conjunto de métodos, damos o nome de API.
Como visto no artigo anterior, JSON é um documento com uma estrutura bem bacana de se trabalhar.

Veja o JSON que o Facebook retorna quando chamamos certo método:

{
   "id": "19292868552",
   "name": "Facebook Platform",
   "likes": 4190683,
   "category": "Product/service",
   "is_published": true,
   "website": "http://developers.facebook.com",
   "username": "platform",
   "founded": "2007",
   "mission": "To make the web more open and social.",
   "talking_about_count": 98577
}

Interessante não? Muito fácil de ler e encontrar os dados que precisamos. Temos o id, name, likes e muitas outras informações.

Agora imagine que a nossa aplicação precisa buscar os dados de um post específico que foi colocado no Facebook. Podemos imaginar também que precisaríamos persistir esses dados em um banco pra futuras comparações, pesquisas, etc.

No nosso caso usaremos este post para estudo: www.facebook.com/98423808305.

Nao vou prolongar sobre a API do Facebook, mas para usá-la podemos usar o Graph API que o Facebook disponibiliza. Aqui temos o core da API, onde podemos ter diversos métodos para as diversas chamadas que precisamos. Caso você precise desenvolver uma app para o Face, este será o local mais odiado visitado por você! = )

Agora que você já sabe sobre a existência do Graph API, vamos usá-la!

Para o nosso exemplo vamos usar a seguinte URL:
https://graph.facebook.com/98423808305

Repare que ao clicar na URL, já temos o retorno em JSON! Isso mesmo, simples assim! Para o nosso projeto vamos precisar do Id e dos dados do From (Name e Category).

A primeira classe que criaremos é muito simples, somente para conseguirmos fazer uma chamada GET na url acima e receber o seu retorno.


package br.com.artigo.json;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;

public class Http {

    public String chamaUrl(String url) throws IOException {
      URL facebook = new URL(url);
      BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(facebook.openStream()));

      String retornoJson;

      StringBuilder builder = new StringBuilder();
      while ((retornoJson = bufferedReader.readLine()) != null)
        builder.append(retornoJson);

      bufferedReader.close();

      return builder.toString();
    }
}

A segunda classe criada será um POJO que conterá as informações que precisamos (id, name e category) vindas do facebook. Repare que esta classe facilmente poderia ser persistida, bastando inserir as anotações do JPA por exemplo! = )

package br.com.artigo.json;

public class Facebook {

	private String id;

	private String name;

	private String category;

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getCategory() {
		return category;
	}

	public void setCategory(String category) {
		this.category = category;
	}

	@Override
	public String toString() {
		return "Facebook [id=" + id + ", name=" + name + ", category="
				+ category + "]";
	}

}

A terceira classe é a ArtigoJson que será a classe principal. Ela usará a classe Http para fazer a chamada simples da API e trabalhará com o retorno JSON.

package br.com.artigo.json;

import java.io.IOException;
import java.util.Map;
import net.sf.json.JSONObject;

public class ArtigoJson {

	private static final String HTTPS_GRAPH_FACEBOOK = "https://graph.facebook.com/98423808305";

	@SuppressWarnings("unchecked")
	public static void main(String[] args) throws IOException {
		//Retorno JSON
		JSONObject object = chamadaHttp();
		System.out.println(object);

		//Retorno dos dados que precisamos
		String id = (String) object.get("id");
		Map map = (Map) object.get("from"); //Que interessante! Um cast para um Map!
		String name = map.get("name");
		String category = map.get("category");

		//Populando o objeto facebook para persistencia
		Facebook facebook = new Facebook();
		facebook.setId(id);
		facebook.setName(name);
		facebook.setCategory(category);

		//Impressão do objeto
		System.out.println(facebook);
	}

	private static JSONObject chamadaHttp() throws IOException {
		Http http = new Http();
		String retornoJson = http.chamaUrl(HTTPS_GRAPH_FACEBOOK);
		JSONObject objetoJson = JSONObject.fromObject(retornoJson);

		return objetoJson;
	}
}

Ao fazer a chamada, podemos ver um trecho do retorno:

{"id":"98423808305",
   "from":
      {"name":"Coca-Cola","category":"Food/beverages","id":"40796308305"}
}

Olha que simples! Temos neste trecho as informações que precisamos! = )
Como no artigo anterior, podemos fazer uma chamada usando uma chave. Repare que fizemos a primeira chamada usando a chave id:

//Retorno dos dados que precisamos
String id = (String) object.get("id");

Mas o mais interessante nas chamadas é o cast para um Map!

Map map = (Map) object.get("from");

Agora podemos obter os nossos dados pelo próprio Map e popular o nosso objeto facebook!

É isso pessoal! Artigo bem simples para o pessoal que está começando, somente pra mostrar uma das formas de utilização do JSON.

Você também pode encontrar este código no meu Gist Público.

Até mais!

JSON Simples e Prático, Parte I

Fala pessoal!

Esta semana percebi que muitos ainda não conhecem ou continuam na dúvida sobre o que é JSON e resolvi contribuir com mais um artigo.

Afinal, o que é JSON?
JSON é basicamente um formato leve de troca de informações/dados entre sistemas. Mas JSON significa JavaScript Object Notation, ou seja, só posso usar com JavaScript correto? Na verdade não e alguns ainda caem nesta armadilha.

O JSON além de ser um formato leve para troca de dados é também muito simples de ler. Mas quando dizemos que algo é simples, é interessante compará-lo com algo mais complexo para entendermos tal simplicidade não é? Neste caso podemos comparar o JSON com o formato XML.

Vamos visualizar esta diferença?

  <?xml version="1.0" encoding="UTF-8"?>
    <id>1</id>
    <nome>Alexandre Gama</nome>
    <endereco>R. Qualquer</endereco>
  {"id":1,"nome":"Alexandre Gama", "endereco":"R. Qualquer"}

Bom, é notável a diferença. Visualmente o segundo trecho (em JSON) é mais fácil de ler. Mas só existe essa diferença entre os dois? Na verdade não. Podemos listar algumas outras vantagens:

Vantagens do JSON:
– Leitura mais simples

- Analisador(parsing) mais fácil

- JSON suporta objetos! Sim, ele é tipado!

- Velocidade maior na execução e transporte de dados

- Arquivo com tamanho reduzido

- Quem utiliza? Google, Facebook, Yahoo!, Twitter…

Estas são algumas das vantagens apresentadas pelo JSON. Agora vamos ao que interessa: Código! :)
Vamos fazer um exemplo extremamente simples nesta primeira parte e avançaremos no próximo artigo, inclusive falando sobre JSON em páginas Web.

Qual biblioteca usar?
Existem diversas bibliotecas para trabalharmos com JSON e Java. Usaremos no nosso estudo o json.jar que você pode baixar tranquilamente neste link

O nosso caso de estudo será simples: Teremos uma classe Carro que será a nossa classe POJO e a classe EstudoJSON que terá o nosso famoso método main.

Classe Carro

package br.com.json;

public class Carro {
	private Long id;
	private String modelo;
	private String placa;

	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getModelo() {
		return modelo;
	}
	public void setModelo(String modelo) {
		this.modelo = modelo;
	}
	public String getPlaca() {
		return placa;
	}
	public void setPlaca(String placa) {
		this.placa = placa;
	}

        //Aqui fizemos o Override do método toString() para visualizar a impressão com o System.out.println()
	@Override
	public String toString() {
		return "[id=" + id + ", modelo=" + modelo + ", placa=" + placa
				+ "]";
	}

}

Esta é uma classe simples, onde temos os atributos Id, Modelo e Placa.

Agora teremos a classe EstudoJSON

package br.com.json;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

public class EstudoJSON {
	public static void main(String[] args) throws JSONException {
		adicaoSimplesDeDados();
	}
}

Repare que criamos o método adicaoSimplesDeDados() que conterá o código de exemplo:

private static void adicaoSimplesDeDados() throws JSONException {
    //Criação do objeto carro e atribuição dos valores
	Carro carro = new Carro();
	carro.setId(1l);
	carro.setModelo("Celta");
	carro.setPlaca("AAA1234");

    //Criação do objeto carroJson
	JSONObject carroJson = new JSONObject();
    //Inserção dos valores do carro no objeto JSON
	carroJson.put("id", carro.getId());
	carroJson.put("Modelo", carro.getModelo());
	carroJson.put("Placa", carro.getPlaca());

    //Impressão do objeto JSON
	System.out.println(carroJson);
}

Se executarmos este código, veremos que foi impresso no console o seguinte:

{"id":1,"Modelo":"Celta","Placa":"AAA1234"}

Você desenvolvedor mais atento vai reparar que existe um objeto impresso: Um Long! Isso mesmo! Como vimos, o JSON consegue armazenar objetos! Podemos inclusive armazenar um objeto do tipo Carro mesmo:

Modificamos o nosso método main:

public class EstudoJSON {
	public static void main(String[] args) throws JSONException {
		adicaoSimplesDeDados();

        adicaoDeUmObjeto();
	}
}

E adicionamos o método adicaoDeUmObjeto():

private static void adicaoDeUmObjeto() throws JSONException {
	Carro carro = new Carro();
	carro.setId(1l);
	carro.setModelo("Celta");
	carro.setPlaca("AAA1234");

	JSONObject carroJson = new JSONObject();
    //Adição do objeto carro
	carroJson.put("Carro", carro);

	System.out.println(carroJson);
}

Neste caso foi impresso no console o seguinte:

{"Carro":"[id=1, modelo=Celta, placa=AAA1234]"}

Simples não?
Como o JSON trabalha com coleção de pares nome/valor, podemos imprimir um valor específico simplesmente chamando o nome que desejamos.

System.out.println(carroJson.get("Modelo"));

Veja que neste caso queremos somente o modelo do carro, bastando fazer a chamada get(“nome que desejamos”)!

Conclusão
É isso pessoal! Vimos as vantagens do JSON e vimos como é simples começar a trabalhar com ele. Nos próximos artigos veremos exemplos mais complexos e veremos algo mais real onde faremos chamadas à API do Facebook!

Você também pode encontrar este código no meu Gist Público.

Abraços!