05 jul 2012

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>
            <!-- Using Jackson for JSON marshaling -->
            <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>
                <!-- StAX is not available on Android -->
                <exclusion>
                    <artifactId>stax</artifactId>
                    <groupId>stax</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>stax-api</artifactId>
                    <groupId>stax</groupId>
                </exclusion>
                <!-- Provided by Android -->
                <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 redspark.
Bacharel em Sistemas de Informação pela Universidade de São Paulo.
@OliveiraLima_

 

Leave a Comment