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