Android – Consumindo JSON com SpringAndroid

Dando continuidade à série de desenvolvimento de aplicações REST com Spring, neste post eu darei um exemplo de como consumir JSON nas suas aplicaçoes Android com a utilização do Spring.

Quem não leu o post anterior, eu sugiro que o faça em, pois ele contempla alguns aspectos de configuração do ANDROID que não serão replicados neste post.

As implementações demonstradas a seguir exibem o consumo de um serviço REST simples criado por mim que fornece uma lista de contatos.

Neste exemplo, básicamente as únicas alterações que realizaremos em comparação com o post anterior, serão a utilização de um novo MessageConverter e algumas anotações nos nossos POJOs.

Para este exemplo, precisaremos das seguintes dependências descritas em nosso pom.xml:

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

<properties>
<platform.version> 2.3.3
</platform.version>
<spring-android-version>1.0.0.RELEASE</spring-android-version>
<jackson-version>1.9.5</jackson-version>
<simple-version>2.6.4</simple-version>
</properties>

<dependencies>
<dependency>
<groupId>com.google.android</groupId>
<artifactId>android</artifactId>
<version>${platform.version}</version>
<scope>provided</scope>
</dependency>

<dependency>
<groupId>org.springframework.android</groupId>
<artifactId>spring-android-rest-template</artifactId>
<version>${spring-android-version}</version>
</dependency>
<dependency>

<groupId>org.codehaus.jackson</groupId>
<artifactId>jackson-mapper-asl</artifactId>
<version>${jackson-version}</version>
</dependency>

<dependency>
<groupId>org.simpleframework</groupId>
<artifactId>simple-xml</artifactId>
<version>${simple-version}</version>
<exclusions>

<exclusion>
<artifactId>stax</artifactId>
<groupId>stax</groupId>
</exclusion>
<exclusion>
<artifactId>stax-api</artifactId>
<groupId>stax</groupId>
</exclusion>

<exclusion>
<artifactId>xpp3</artifactId>
<groupId>xpp3</groupId>
</exclusion>
</exclusions>
</dependency>

</dependencies>

O método que realiza a a chamada ao serviço deve ter o seguinte formato:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public void recuperarContatos(final View v) {

RestTemplate restTemplate = new RestTemplate();

List<HttpMessageConverter<?>> messageConverters = new ArrayList<HttpMessageConverter<?>>();
messageConverters.add(new MappingJacksonHttpMessageConverter());
restTemplate.setMessageConverters(messageConverters);

restTemplate.setRequestFactory(new HttpComponentsClientHttpRequestFactory());

Contatos contatos = restTemplate.getForObject("http://192.168.16.148:8080/rest/contatos", Contatos.class);

// Tratamento com os contatos recebidos.

}

Inicialmente, assim como no exemplo anterior, definimos o nosso RestTemplate, adicionamos uma request factory (para que o template saiba realizar nosso request ao serviço) e um message converter que serialize o JSON recebido e o salvaremos em um POJO descrito por nós. Este POJO, que será descrito a seguir, deve possuir os campos com nomes exatamente iguais aos retornados pelo serviço, para que saiba fazer a serialização.

Para a leitura do JSON recebido, definimos os seguintes POJOs:

1
2
3
4
5
6
7
8

@JsonIgnoreProperties(ignoreUnknown = true)
public class Contatos {

private Collection<Contato> contatoList;

// Getters, Setters e Construtores...

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@JsonIgnoreProperties(ignoreUnknown = true)
public class Contato {

private String nome;

private String celular;

private String email;

private String twitter;

private String facebook;

// Getters, Setters e Construtores...

}

Como pode-se notar, definimos o POJO que contém as propriedades e um outro que possui uma lista deste objeto. Desta forma, o Jackson JSON Processor consegue serializar o JSON recebido tranquilamente. A única medida de precaução que devemos tomar para evitar problemas com a nossa aplicação, é adicionar a anotação @JsonIgnoreProperties(ignoreUnknown = true) em nossas classes, para que uma possível falta de propriedades em nossas classes em comparação com o JSON recebido não resulte em um “crash” na aplicação.

Este foi mais um post da série Android, espero que tenham gostado. Quaisquer dúvidas, sugestões e/ou reclamações, comentem!

_________________________________________

Lucas Oliveira – Analista Programador na DClick.
Bacharel em Sistemas de Informação pela Universidade de São Paulo.
@OliveiraLima_

Android – Consumindo JSON com SpringAndroid

Deixe Seu Comentário