webservicenoandroid-131109002153-phpapp01-1- Android 2015-2

Prévia do material em texto

Consumindo Web Service REST
com Android
Alexandre Antunes
Bemobi & Portal Android
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.
Necessidade de ter um aplicativo online
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+).
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.
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.
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.
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. 
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.
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.
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
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.
Formatos de notação dados (JSON x XML)
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.
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'
}
Spring - Utilização
➢ Criamos o nosso POJO, que será exatamente o mapeamento no nosso 
JSON:
POJO:
public class Cliente {
private int id;
private String nome;
private String cpf;
private String endereco;
//Getters and Setters
}
Retorno do Servidor:
{
 "cpf": "111222333-00",
 "endereco": "Rua das ruas, 9",
 "id": "1",
 "nome": "Alexandre Antunes"
}
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.
 
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.
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;
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);
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.
}
});
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;
Transformando dados em objetos Java
➢ Nativo JSONObject:
Retorno do Servidor:
{
 "cpf": "111222333-00",
 "endereco": "Rua das ruas, 9",
 "id": "1",
 "nome": "Alexandre Antunes"
}
private Cliente parse(JSONObject jsonObject) {
Cliente cliente = new Cliente();
try {
cliente.setId(jsonObject.getString("id"));
cliente.setNome(jsonObject.getString("nome"));
cliente.setCpf(jsonObject.getString("cpf"));
cliente.setEndereco(jsonObject.getString("endereco"));
} catch (JSONException e) {
e.printStackTrace();
}
return cliente;
}
Transformando dados em objetos Java
➢ Google Gson:
Retorno do Servidor:
{
 "cpf": "111222333-00",
 "endereco": "Rua das ruas, 9",
 "id": "1",
 "nome": "Alexandre Antunes"
}
private Cliente parse(JSONObject jsonObject) {
Gson gson = new Gson();
return gson.fromJson(jsonObject, Cliente.class);
}
Spring x Volley
Spring:
○ 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.
➢ Volley
○ Faz as requisições em uma nova thread;
○ Implementa uma fila para as requisições.
➢ Ambos suportam HTTPS.
Comunicação eficiente
Comunicação eficiente
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);
Transmitindo dados seguros
➢ Autenticação (OAuth - token);
➢ Autorização (Áreas restritas);
➢ SSL (HTTPS);
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;
 }
}
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;
}
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]);
 }
}
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
Contato
➢ Alexandre Antunes
○ Administrador do Portal Android;
○ Membro organizador do GDG Rio de Janeiro;
➢ antunes@portalandroid.org