The document discusses consuming REST web services with Android. It covers: 1) The need to have an online application, data formats like JSON and XML, and types of web services like SOAP and REST. 2) Transforming data received from web services into Java objects using libraries like Spring, Volley, and Google Gson. 3) Making HTTP requests to REST services and handling responses.

1. Consumindo Web Service REST
com Android
Alexandre Antunes
Bemobi & Portal Android

2. Intodução
➢
➢
➢
➢
➢
➢
➢
➢
➢
Necessidade de ter um aplicativo online;
Por que utilizar um Web Service (Padrão x Solução Proprietária);
Tipos de Web Service (SOAP x REST);
Overview das API’s existentes (String x Volley);
Formatos de notação de dados (JSON x XML);
Transformando dados em objetos Java (Android JSON x google-gson);
Comunicação eficiente;
Transmitindo dados seguros;
Implementando um simples REST Client.

3. Necessidade de ter um aplicativo online

4. Necessidade de ter um aplicativo online
➢
➢
➢
➢
➢
➢
➢
Guardar dados em nuvem;
Sistema multiplataforma (web, desktop e mobile);
Saber qual o interesse dos usuários que estão acessando a plataforma;
Controle de acesso;
Serviço customizado para cada cliente;
Compartilhar ações/dados/eventos;
Redes sociais (Facebook, twitter e Google+).

5. Por que utilizar um Web Service (Protocolo Proprietário)
➢
➢
➢
➢
➢
➢
➢
➢
➢
Identificadores de mensagens (sucesso e erro);
Tipos de erros;
Formato de dados (String??? Array de bytes??);
Converter esses dados quando entram no sistema;
Segurança (criptografia);
Documentação do protocolo para implementação de terceiros;
Debug;
Custo;
Tempo de desenvolvimento.

6. Por que utilizar um Web Service (Padrão)
➢
➢
São baseados em tecnologia padrão;
HTTP como protocolo de comunicação;
○
○
➢
➢
➢
➢
➢
➢
Headers;
Status code;
SSL para seguraça;
Dados em XML ou JSON;
Ferramentas que facilitam a conversão dos dados;
Ferramentas de debug (SoapUi, Postman, REST Console e etc.);
API’s pada Java (Jersey, CXF, Spring MVC e etc.);
Praticamente todas as linguagens suportam a criação de um Web
Service.

7. Tipos de Web Service
➢
➢
➢
➢
O Web Service foi criado para que aplicações desenvolvidas em
linguagens diferentes possam se comunicar por meio de serviços
(métodos) que são expostos para que outros sistemas possam acessálos.
O objetivo dos Web Services é a comunicação de aplicações através da
Internet.
O W3C e OASIS são as instituições responsáveis pela padronização
dos Web Services. Empresas como IBM, Microsoft e Sun apóiam o
desenvolvimento desse padrão.
Segundo o W3C um Web Service define-se como: um sistema projetado
para suportar a interoperabilidade entre máquinas sobre rede.

8. Tipos de Web Service (SOAP)
➢
➢
➢
O SOAP (Simple Object Access Protocol) baseia-se numa invocação
remota de um método e para tal necessita especificar o endereço do
componente, o nome do método e os argumentos para esse método.
Os dados são formatados em XML com determinadas regras e enviados
normalmente por HTTP.
Não define ou impõe qualquer semântica, quer seja de modelo de
programação, quer seja a semântica específica da implementação. Este
aspecto é extremamente importante, pois permite que o serviço ou o
cliente sejam aplicações desenvolvidas por diferentes linguagens.

9. Tipos de Web Service (SOAP)
➢
➢
O WSDL descreve os serviços disponibilizados à rede através de uma
semântica XML, este providencia a documentação necessária para se
chamar um sistema distribuído e o procedimento necessário para que
esta cominicação se estabeleça.
Enquanto o SOAP especifica a comunicação entre um cliente e um
servidor, o WSDL descreve os serviços oferecidos.

10. Tipos de Web Service (REST)
➢
➢
➢
➢
REST é uma técnica de engenharia de software para sistemas
distribuídos desenvolvida pelo Roy Fielding.
A REST (Transferência de Estado Representativo) é pretendida como
uma imagem do design da aplicação se comportará: uma rede de
websites (um estado virtual), onde o usuário progride com uma
aplicação selecionando as ligações (transição de estado), tendo como
resultado a página seguinte (que representa o estado seguinte da
aplicação) que está sendo tranferida ao usuário e apresentada para seu
uso.
Sistemas que seguem os princípios REST são conhecidos como
RESTful.
WADL.

11. Tipos de Web Service (REST)
➢
➢
➢
O que é importante ter em mente é que o princial em um Web Service
RESTful são as URLs do sistema e os resources.
Um resource é um recurso, uma entidade, ou seja, é um objeto com
informação que será representado por meio de um XML.
Em geral, a URL para acessar esse recurso será sempre a mesma,
porém caso mudemos o método HTTP (GET, POST, PUT e DELETE) o
resultado da requisição será diferente.
Método
exemplo.com/recurso
exemplo.com/recurso/1
GET
Lista os recursos
Detalhe de um recurso
POST
Adiciona um recurso
-
PUT
-
Atualiza um recurso
DELETE
-
Remove um recurso

12. Formatos de dados (JSON x XML)
➢
➢
➢
➢
JSON e XML são formatos para a notação de dados a serem
transmitidos;
A maior e mais importante diferença entre eles, e o que importa para
nós nesse momento, é que o XML acaba ocupando muito mais espaço
que o JSON quando representam o mesmo objeto.
Isso acontece porque o XML usa uma tag para identificar o inicio e o
final de cada nó.
O JSON é fortemente recomendado quando estamos falando de
dispositivos móveis, por consumir menos banda da conexão de internet
do usuário.

13. Formatos de notação dados (JSON x XML)

14. Spring
➢
O Spring é uma ferramenta bastante usada por desenvolvedores Java e
não podia estar de fora quando falamos em Android.
➢
A ferramenta para android é bem leve e simples de usar, apresentando
as seguintes funcionalidades principais:
○ Rest Client para Android;
○ Suporte a autenticação para APIs seguras.
➢
Ela está disponível tanto para Maven quanto para o Gradle.
➢
Como ela é modular, podemos usar apenas o que vamos precisar.

15. Spring
➢
Maven
<dependencies>
<dependency>
<groupId> org.springframework.android </groupId>
<artifactId> spring-android-rest-template </artifactId>
<version> 1.0.1.RELEASE </version>
</dependency>
</dependencies>
➢
Gradle
dependencies {
compile 'org.springframework.android:spring-android-rest-template:1.0.1.RELEASE'
}

16. Spring - Utilização
➢
Criamos o nosso POJO, que será exatamente o mapeamento no nosso
JSON:
Retorno do Servidor:
POJO:
{
public class Cliente {
private int id;
private String nome;
private String cpf;
private String endereco;
"cpf": "111222333-00",
"endereco": "Rua das ruas, 9",
"id": "1",
"nome": "Alexandre Antunes"
}
//Getters and Setters
}

17. Spring - Utilização
➢
Para fazer o parse o Spring recomenda usar o Jackson, que é bastante
usado e muito bom por sinal, mas normalmente é usado no lado do
Servidor.
<dependency>
<groupId>com.fasterxml.jackson.core
</groupId>
<artifactId>jackson-databind
</artifactId>
<version>2.2.1</version>
</dependency>
➢
A questão é avaliar o desempenho. Ele suporta as seguintes APIs para
essa função:
○
○
○
Jackson JSON Processor;
Jackson 2.x;
Google Gson.

18. Spring - Utilização
➢
Fazendo a requisição ao serviço:
// Saber a URL do serviço
String url = "http://10.0.2.2:8080/WebServiceREST/cliente/1";
// Criar uma instância do RestTemplate
RestTemplate restTemplate = new RestTemplate();
// Dizer ao Spring que você quer usar o Jackson para fazer o parse do JSON
restTemplate.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
// Executar o mmétodo HTTP GET, fazendo o parse do JSON para o Objeto Cliente
Cliente cliente = restTemplate.getForObject(url, Cliente.class);
➢
Agora só nos basta usar esse objeto para popular nossa “view”, salvar
no banco ou qualquer outra coisa.

19. Volley
➢
➢
➢
➢
O Volley foi divulgado no Google I/O 2013;
Basicamente ela serve para realizar requisições para a web com
simplicidade e, o mais importante, rapidamente;
Processamento das requisições e cache;
Benefícios:
○ Gerencia automaticamente as requisições;
○ Cache em disco e memória;
○ Possibilidade de cancelar uma requisição;
○ Customização;
○ Debugging e tracing;

20. Volley - Utilização
➢
Baixar o Volley no Git e incluir o código no seu projeto:
git clone https://android.googlesource.com/platform/frameworks/volley
➢
Importando projetos do Git:
http://www.technotalkative.com/android-import-android-projects-from-git/
➢
Fazendo a requisição ao serviço:
// Saber a URL do serviço
String url = "http://10.0.2.2:8080/WebServiceREST/cliente/1";
// Criar uma instância do RequestQueue
RequestQueue queue = Volley.newRequestQueue(this);

21. Volley - Utilização
// Criar uma instância do JsonObjectRequest, passando o método HTTP, a url, um callback de sucesso
e um de erro.
JsonObjectRequest jsObjRequest = new JsonObjectRequest(Request.Method.GET, url, null, new Response.
Listener<JSONObject>() {
@Override
public void onResponse(JSONObject response) {
// TODO Incluir código de sucesso.
// Usar a lib de JSON padrão ou o Gson para fazer o parse para o seu Objeto,
// no nosso caso o objeto é o Cliente.
Cliente cliente = parse(response); // Já veremos a implementação desse método.
// Popular a View com o objeto Cliente.
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
// TODO Incluir código para quando a requisição falhar.
// Mostrar uma Dialog informando ao usuário o erro.
}
});

22. Transformando dados em objetos Java
Existem várias formas e APIs para fazer o parse de um JSON para um
objeto, as mais importantes são:
➢
Jackson:
○ Não é tão simples de implementar;
○ Tem dezenas de funcionalidades;
○ Com o Spring pode ser bem simples.
➢
Nativo JSONObject:
○ Já vem no SDK do Android;
○ Simples de implementar, mas trabalhoso;
➢
Google Gson:
○ Também pode usar com o Spring;
○ A mais simples. Em uma linha o seu objeto está pronto para usar;

23. Transformando dados em objetos Java
➢
Nativo JSONObject:
private Cliente parse(JSONObject jsonObject) {
Cliente cliente = new Cliente();
Retorno do Servidor:
{
try {
cliente.setId(jsonObject.getString("id"));
"cpf": "111222333-00",
"endereco": "Rua das ruas, 9",
cliente.setNome(jsonObject.getString("nome"));
"id": "1",
cliente.setCpf(jsonObject.getString("cpf"));
"nome": "Alexandre Antunes"
cliente.setEndereco(jsonObject.getString("endereco"));
} catch (JSONException e) {
e.printStackTrace();
}
return cliente;
}
}

24. Transformando dados em objetos Java
➢
Google Gson:
private Cliente parse(JSONObject jsonObject) {
Gson gson = new Gson();
Retorno do Servidor:
{
return gson.fromJson(jsonObject, Cliente.class);
"cpf": "111222333-00",
"endereco": "Rua das ruas, 9",
}
"id": "1",
"nome": "Alexandre Antunes"
}

25. Spring x Volley
Spring:
○
➢
Volley
○
○
➢
Usa a thread atual para realizar a requisição (Como a partir da API
level 11 do Android, não podemos mais executar tarefas demoradas
na MainThread, é obrigatório que seja feito em uma thread separada
(NetworkOnMainThreadException) - Recomendo o uso de uma AsyncTask
para realizar essa função.
Faz as requisições em uma nova thread;
Implementa uma fila para as requisições.
Ambos suportam HTTPS.

26. Comunicação eficiente

27. Comunicação eficiente

28. Comunicação eficiente
➢
Sempre informar ao usuário que os dados estão sendo carregados;
➢
Evitar trafegar dados desnecessários;
➢
Evitar requisições repetidas;
➢
Quebrar retornos muito grandes em várias requisições (paginar);
➢
Carregar a tela de forma assíncrona(textos x imagens);

29. Transmitindo dados seguros
➢
Autenticação (OAuth - token);
➢
Autorização (Áreas restritas);
➢
SSL (HTTPS);

30. Implementando um simples REST Client no Android
public class HttpClientSingleton {
private static final int JSON_CONNECTION_TIMEOUT = 3000;
private static final int JSON_SOCKET_TIMEOUT = 5000;
private static HttpClientSingleton instance;
private HttpParams httpParameters ;
private DefaultHttpClient httpclient;
private void setTimeOut(HttpParams params){
HttpConnectionParams.setConnectionTimeout(params, JSON_CONNECTION_TIMEOUT);
HttpConnectionParams.setSoTimeout(params, JSON_SOCKET_TIMEOUT);
}
private HttpClientSingleton() {
httpParameters = new BasicHttpParams();
setTimeOut(httpParameters);
httpclient = new DefaultHttpClient(httpParameters);
}
public static DefaultHttpClient getHttpClientInstace(){
if(instance==null)
instance = new HttpClientSingleton();
return instance.httpclient;
}
}

31. Implementando um simples REST Client no Android
public String[] get(String url) {
String[] result = new String[2];
HttpGet httpget = new HttpGet(url);
HttpResponse response;
try {
response = HttpClientSingleton.getHttpClientInstace().execute(httpget);
HttpEntity entity = response.getEntity();
if (entity != null) {
result[0] = String.valueOf(response.getStatusLine().getStatusCode());
InputStream instream = entity.getContent();
result[1] = toString(instream);
instream.close();
Log.i("get", "Result from post JsonPost : " + result[0] + " : " + result[1]);
}
} catch (Exception e) {
Log.e("NGVL", "Falha ao acessar Web service", e);
result[0] = "0";
result[1] = "Falha de rede!";
}
return result;
}

32. Implementando um simples REST Client no Android
private static final String URL_WS = "http://10.0.2.2:8080/WebServiceREST/cliente/";
public Cliente getCliente(int id) throws Exception {
String[] resposta = new WebServiceCliente().get(URL_WS + id);
if (resposta[0].equals("200")) {
Gson gson = new Gson();
Cliente cliente = gson.fromJson(resposta[1], Cliente.class);
return cliente;
} else {
throw new Exception(resposta[1]);
}
}

33. Fontes
➢
➢
➢
➢
➢
➢
➢
➢
➢
➢
➢
➢
➢
➢
➢
http://pt.wikipedia.org/wiki/Web_service#SOAP
http://pt.wikipedia.org/wiki/REST
http://en.wikipedia.org/wiki/Web_Application_Description_Language
http://spring.io/guides/gs/consuming-rest-android/
http://docs.spring.io/spring-android/docs/1.0.x/reference/html/rest-template.html
http://www.portalandroid.org/comunidade/viewforum.php?f=119
https://github.com/FasterXML/jackson
http://developer.android.com/reference/org/json/JSONObject.html
https://code.google.com/p/google-gson/
http://www.technotalkative.com/android-import-android-projects-from-git/
http://java.dzone.com/articles/android-%E2%80%93-volley-library
https://android.googlesource.com/platform/frameworks/volley
https://gist.github.com/ficusk/5474673
http://pt.wikipedia.org/wiki/JSON
http://pt.wikipedia.org/wiki/XML

34. Contato
➢
Alexandre Antunes
○
○
➢
Administrador do Portal Android;
Membro organizador do GDG Rio de Janeiro;
antunes@portalandroid.org