Manipulando Json no Android



Será que alguém explica nossa relação.... ♪♩♫♭♪♯♬♪♫♩♫♭ ♪♯ 

 Faaaaaala galeraaaaaaaaaaaa! Estamos aqui para mais um post ao lado de vocês. Hoje vamos focar em javaDroid (Android), Vamos ensinar como manipular dados json no nosso app.

 Lets Rock :p
Atualmente muitos sistemas são alimentados utilizando serviços que retornam um JSON. Por que não criar aplicativos Android que também possam consumir informações via JSON? O objetivo deste post é mostrar como é fácil um aplicativo acessar e exibir informação através deste mecanismo.
O primeiro passo é ter acesso a um serviço, para exemplificar o post, utilizei um serviço local, ilustrado na Figura 1, que gera um JSON com alguns dados como nome e CPF. A ideia do aplicativo, é que assim que a aplicação for iniciada, ela carregue uma lista com o nome de todas as pessoas informadas via JSON e ao clicar no nome seja exibido o nome e CPF em outra tela.

json
FIGURA 1 – DADOS RETORNADOS VIA JSON
Para quem quiser conhecer um pouco mais como criar serviços que retornem esse tipo de estrutura, podem ler o post Webservices usando JAX-RS 2 e Spring.
Depois de vermos a estrutura do serviço JSON, o próximo passo é criar o projeto Android. Criei um projeto Android conforme ilustrado na Figura 2.
projeto
FIGURA 2 – ESTRUTURA DO PROJETO ANDROID
Na Listagem 1, temos classe “Pessoa” é o nosso POJO que representará os dados recebidos.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class Pessoa implements Serializable {
 
/**
* POJO
*/
private static final long serialVersionUID = 1L;
private String nome;
private String cpf;
 
public String getNome() {
return nome;
}
 
public void setNome(String nome) {
this.nome = nome;
}
 
public String getCpf() {
return cpf;
}
 
public void setCpf(String cpf) {
this.cpf = cpf;
}
 
@Override
public String toString() {
return nome;
}
 
}
LISTAGEM 1 – CLASSE PESSOA
O próximo passo é criar a classe “ConsumirJsonActivity”, representada na Listagem 2, que é a responsável por acessar o serviço JSON e criar os objetos com as informações recebidas.
No exemplo estendo a classe “ListActivity” para que assim que o aplicativo for iniciado ele já crie uma lista com os dados.
No método “onCreate” é chamado a classe “DownloadJsonAsyncTask” passando como parâmetro o link de acesso ao serviço.
1
2
3
4
5
6
7
8
public class ConsumirJsonActivity extends ListActivity {
 
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
new DownloadJsonAsyncTask()
.execute("http://10.0.5.180:8080/samples/mock_pessoas");
}
LISTAGEM 2 – MÉTODO QUE CHAMA A URL DO SERVIÇO
O método “onListItemClick”, na Listagem 3, é o responsável por enviar as informações do nome selecionado na lista para a activity “InformacoesActivity” que exibirá os dados em outra tela.
1
2
3
4
5
6
7
8
9
10
@Override
protected void onListItemClick(ListView l, View v, int position, long id) {
super.onListItemClick(l, v, position, id);
 
Pessoa pessoa = (Pessoa) l.getAdapter().getItem(position);
 
Intent intent = new Intent(this, InformacoesActivity.class);
intent.putExtra("pessoa", pessoa);
startActivity(intent);
}
LISTAGEM 3 – MÉTODO RESPONSÁVEL POR ENVIAR OS DADOS SELECIONADOS PARA OUTRA ACTIVITY
A classe “DownloadJsonAsyncTask” é responsável por fazer o processamento dos dados. Ela herda alguns métodos da classe “AsyncTask” que vamos ver mais adiante.
O primeiro método relevante desta classe é o “onPreExecute”, mostrado na Listagem 4, ele é responsável por exibir uma mensagem de feedback enquanto é feito o download das informações.
1
2
3
4
5
6
7
//Exibe pop-up indicando que está sendo feito o download do JSON
@Override
protected void onPreExecute() {
super.onPreExecute();
dialog = ProgressDialog.show(ConsumirJsonActivity.this, "Aguarde",
"Fazendo download do JSON");
}
LISTAGEM 4 – MÉTODO QUE INDICA PARA O USUÁRIO QUE O APLICATIVO ESTÁ FAZENDO O DOWNLOAD DO JSON
Em paralelo a ela é executado o método “doInBackground”, representado na Listagem 5, é neste método que efetivamente fazemos o download do JSON. Por parâmetro é passado para esse método a URL do serviço. Ela é acessada a partir das classes responsáveis por fazer conexões HTTP.
Notem que na linha 14 é chamado o método “getPessoas(json)”, ele que retornará os objetos preenchidos com as informações, sua codificação está na Listagem 6.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//Acessa o serviço do JSON e retorna a lista de pessoas
@Override
protected List<Pessoa> doInBackground(String... params) {
String urlString = params[0];
HttpClient httpclient = new DefaultHttpClient();
HttpGet httpget = new HttpGet(urlString);
try {
HttpResponse response = httpclient.execute(httpget);
HttpEntity entity = response.getEntity();
if (entity != null) {
InputStream instream = entity.getContent();
String json = getStringFromInputStream(instream);
instream.close();
List<Pessoa> pessoas = getPessoas(json);
return pessoas;
}
} catch (Exception e) {
Log.e("Erro", "Falha ao acessar Web service", e);
}
return null;
}
LISTAGEM 5 – MÉTODO QUE ACESSA O SERVIÇO
Como dito a cima, este método “getPessoas” retoma uma lista de pessoas.
O parâmetro que ele recebe é a string JSON retornada pelo serviço.
Primeiro se cria um objeto “JSONArray” passando a string recebida. Esse objeto é como se fosse um array, cada parte do JSON se transforma em uma posição.
Depois o array é percorrido e para cada posição é criado um objeto “JSONObject”.
Utilizando esse objeto é setado os atributos do objeto “Pessoa” passando a chave definida no JSON para obter o valor.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//Retorna uma lista de pessoas com as informações retornadas do JSON
private List<Pessoa> getPessoas(String jsonString) {
List<Pessoa> pessoas = new ArrayList<Pessoa>();
try {
JSONArray pessoasJson = new JSONArray(jsonString);
JSONObject pessoa;
 
for (int i = 0; i < pessoasJson.length(); i++) {
pessoa = new JSONObject(pessoasJson.getString(i));
Log.i("PESSOA ENCONTRADA: ",
"nome=" + pessoa.getString("nome"));
 
Pessoa objetoPessoa = new Pessoa();
objetoPessoa.setNome(pessoa.getString("nome"));
objetoPessoa.setCpf(pessoa.getString("CPF"));
pessoas.add(objetoPessoa);
}
 
} catch (JSONException e) {
Log.e("Erro", "Erro no parsing do JSON", e);
}
return pessoas;
}
LISTAGEM 6 - MÉTODO QUE RETORNA A LISTA DE PESSOAS COM OS ATRIBUTOS PREENCHIDOS COM AS INFORMAÇÕES DO JSON
A próxima etapa é exibir os objetos preenchidos em uma lista. Na Listagem 7, temos o método “onPostExecute”, responsável por realizar esta ação. Este método sempre é executado depois de feito o download. Se o download ocorrer corretamente é criado um adapter para exibir os objetos em uma lista.
Caso haja algum problema durante o acesso ao serviço é exibida uma mensagem informando que não foi possível acessar as informações.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//Depois de executada a chamada do serviço
@Override
protected void onPostExecute(List<Pessoa> result) {
super.onPostExecute(result);
dialog.dismiss();
if (result.size() > 0) {
ArrayAdapter<Pessoa> adapter = new ArrayAdapter<Pessoa>(
ConsumirJsonActivity.this,
android.R.layout.simple_list_item_1, result);
setListAdapter(adapter);
} else {
AlertDialog.Builder builder = new AlertDialog.Builder(
ConsumirJsonActivity.this)
.setTitle("Erro")
.setMessage("Não foi possível acessar as informações!!")
.setPositiveButton("OK", null);
builder.create().show();
}
}
LISTAGEM 7 – MÉTODO CHAMADO DEPOIS QUE O DOWNLOAD É CONCLUÍDO
Também é necessário alterar o arquivo “AndroidManifest.xml”. Nele é preciso acrescentar a permissão de acesso a Internet, como mostrado na Listagem 8, fazendo com que a aplicação consiga acessar o serviço JSON.
1
2
3
</pre>
<uses-permission android:name="android.permission.INTERNET"/>
<pre>
LISTAGEM 8 – PERMISSÃO PARA APLICATIVO ACESSAR A INTERNET
Pronto!! Com algumas linhas de código é possível criar um aplicativo simples que é populado com dados enviados via serviço JSON.
O projeto utilizado como exemplo está disponível aqui.
Na Figura 3 há um exemplo de como ficou o aplicativo.
 app
FIGURA 3 – LISTA DE NOMES RECEBIDOS VIA JSON

REFERÊNCIAS 

[1] http://www.devmedia.com.br/consumindo-json-em-aplicacoes-android/27589
[2] http://www.vogella.com/tutorials/AndroidJSON/article.html

LINKS EXTERNOS

Até a próxima !

Comentários

Postar um comentário

Postagens mais visitadas deste blog

Executar Audio em Java Swing

Imagem
Uma das coisas que mais motivam nós programadores quando estamos aprendendo a programar ou que continuemos a estudar a linguagem a qual programamos é aprender sempre algo novo que a linguagem nos oferece. Claro que Java nos permite hoje fazer qualquer tipo de aplicação, porém o grande problema é que não sabemos como fazer o que queremos e a partir da aí buscamos cada vez mais o conhecimento que precisamos para fazer o que desejamos. Recentemente descobri essa biblioteca chamada  JLayer  a qual nos permite tocar de forma muito fácil arquivos MP3 em nossos programas Java. Eu ainda não estudei essa biblioteca profundamente para ver tudo o que ela tem, porém hoje eu mostro como fazer o básico para tocar arquivos MP3 usando a Jlayer. O tutorial é dividido em duas partes. A primeira parte (logo a seguir) ensina a tocar um arquivo mp3 em código Java de forma bem simples. Na segunda parte (que publicarei algum dia), ensinarei a tocar o arquivo mp3 usando threads e mostrando alguns o...
Leia mais

E Esse Tal de Nano Service?

Imagem
  Ao longo dos anos, o desenvolvimento de software se afastou das arquiteturas monolíticas tradicionais, abordando suas complexidades com código fortemente acoplado e interconectado. Isso resultou na adoção de microsserviços, abordagens eficientes nativas da nuvem que permitem a computação distribuída por meio de vários serviços menores. Desde que os microsserviços se tornaram mainstream, nos últimos anos, os nanoservices evoluíram como outro padrão que foi projetado principalmente para superar as complexidades encontradas nos microsserviços. Essencialmente, os nanoserviços dividem ainda mais os serviços para trazer eficiência adicional. Este artigo descreve como o desenvolvimento de componentes menores para criar um aplicativo é uma abordagem preferencial, portanto: Explicar micro e nanoserviços Explore benefícios e desafios Compartilhe exemplos e práticas recomendadas para ajudá-lo a determinar a estrutura certa para suas necessidades Melhorando as práticas de desenvolvimento Dev...
Leia mais

Processo de Software - Um simples mapa conceitual

Imagem
Salve Salve galera! Sim, eu sei que os senhores estão chateados comigo pois, a algum tempo não faço nenhuma postagem :D. Essa vida corrida me consumiu nesse final de ano muito tempo então acabei ficando in off do blog. Porém, recentemente, para uma disciplina da faculdade, percebi que os alunos estavam com um pouco de dificuldade para compreender a estrutura de um processo de software (conceito). Tendo este ponto em vista, desenhei um pequeno mapa conceitual do mesmo. Para quem não sabe, um mapa conceitual  são estruturas esquemáticas que representam conjuntos de ideias e conceitos dispostos em uma espécie de rede de proposições, de modo a apresentar mais claramente a exposição do conhecimento e organizá-lo segundo a compreensão cognitiva do seu idealizador. Com este mapa, foi visível a compreensão dos alunos com o tema e, neste contexto, acredito que possa ajudar outras pessoas a entender esta estrutura. Segue abaixo o modelo: Espero que este possa lhes ajudar a com...
Leia mais