Facilitando as requisições utilizando OkHttp no Android

Quando estamos desenvolvendo um aplicativo temos uma grande possibilidade de ter que consumir dados de algum servidor, portanto precisamos fazer alguns códigos para fazerem a comunicação e, por boa prática, centralizamos esse código numa classe especialista para realizar a comunicação :

public class WebClient {
// métodos para comunicação com servidor
}

Até a versão 4.0 do Android estavámos acostumados a utilizar a biblioteca da Apache para fazer essa comunicação. Após a versão 4.0, foi recomendado usar a biblioteca nativa do java. Vamos ver como fazer um GET & POST utilizando essa biblioteca, vamos adotar que no POST enviaremos um JSON.

public class WebClient {
public String post(String json) throws IOException {
URL url = new URL("http://www.umsitequalquer.com.br/fazPost");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-type", "application/json"); connection.setRequestProperty("Accept", "application/json");
connection.setDoOutput(true);
PrintStream printStream = new PrintStream(connection.getOutputStream()); printStream.println(json);
connection.connect();
String jsonDeResposta = new Scanner(connection.getInputStream()).next();
return jsonDeResposta; }
public String get() throws IOException {
URL url = new URL("http://www.umsitequalquer.com.br/fazGet");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("GET");
connection.setRequestProperty("Accept", "application/json");
connection.connect();
String jsonDeResposta = new Scanner(connection.getInputStream()).next();
return jsonDeResposta; }
}

Geralmente a nossa classe WebClient fica mais ou menos com essa carinha, uns métodos a mais para fazer outros tipos de requisição. Contudo, essa classe está muito verbosa, estamos digitando bastante. Deve ter alguma forma de melhorar esse código e é o que iremos fazer.

Vamos usar a biblioteca OkHttp para facilitar nossa vida !

Para trazermos ela para nosso projeto temos que registrá-la no nosso gradle :

dependencies { compile 'com.android.support:appcompat-v7:21.0.3' compile 'com.squareup.okhttp3:okhttp:3.2.0' }

Para conseguirmos usá-la, teremos que criar um objeto do tipo OkHttpClient, que será responsável pela comunicação.

public class WebClient {
public String post(String json) throws IOException {
OkHttpClient client = new OkHttpClient(); // restante do código
}
}

Temos que pedir para nosso client fazer a requisição ao servidor, para isso usaremos o método newCall(), que quando for executado devolverá a resposta do servidor :

public class WebClient {
public String post(String json) throws IOException {
OkHttpClient client = new OkHttpClient(); Response response = client.newCall().execute();
// restante do código
}
}

Estamos fazendo uma chamada que faz a requisição, mas não definimos qual é a requisição que queremos fazer. Portanto temos que criar a nossa requisição :

public class WebClient {
public String post(String json) throws IOException {
OkHttpClient client = new OkHttpClient();
String url = "http://www.umsitequalquer.com.br/fazPost";
Request.Builder builder = new Request.Builder();
builder.url(url);
MediaType mediaType = MediaType.parse("application/json; charset=utf-8"); RequestBody body = RequestBody.create(mediaType, json); builder.post(body);
Request request = builder.build();
Response response = client.newCall(request).execute();
// restante do código
} }

Como vimos no código, criar uma requisição na mão daria muito trabalho, por esse motivo estamos usando um Builder, atráves dele passamos as informações que são necessárias, como a URL. Para escrever no corpo do nosso POST usamos o objeto RequestBody, para criar este objeto usamos o método estático create, que recebe um identificador do tipo do arquivo, representado na classe MediaType, e recebe o objeto que será escrito no corpo.

Agora com o corpo da requisição pronto, temos que informar ao nosso Builder que nossa requisição será um POST, passando o corpo da requisição. Com isso pronto, basta criarmos a requisição, atráves do método build().

Feito tudo isso, falta agora pegarmos o corpo da resposta e devolver como resposta do nosso método, igual fazíamos antes :

public class WebClient {
public String post(String json) throws IOException {
OkHttpClient client = new OkHttpClient();
String url = "http://www.umsitequalquer.com.br/fazPost";
Request.Builder builder = new Request.Builder();
builder.url(url);
MediaType mediaType = MediaType.parse("application/json; charset=utf-8"); RequestBody body = RequestBody.create(mediaType, json); builder.post(body);
Request request = builder.build();
Response response = client.newCall(request).execute();
String jsonDeResposta = response.body().string(); return jsonDeResposta;
} }

Para pegarmos o corpo da resposta, temos o método body(), que retorna um ResponseBody e para transformarmos ele em String usamos o método string(). Desta forma, o nosso POST está terminado, ficou faltando fazermos o GET :

public String get() throws IOException {
String url = "http://www.umsitequalquer.com.br/fazGet";
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder().url(url).build();
Response response = client.newCall(request).execute();
String jsonDeResposta = response.body().string();
return jsonDeResposta; }

Como podemos ver, não muda praticamente nada do que fizemos anteriormente, exceto por não termos que falar que estamos fazendo um GET, pois já é definido por padrão.

Qual você prefere, a utilização da biblioteca nativa do Java ou usar a biblioteca OkHttp ? Vimos aqui como utilizar a biblioteca do OkHttp 3 para facilitar nossas requisições, evitando muito código e de leitura bem mais simples !

Quer saber mais sobre Android ? Aqui no Alura temos alguns cursos bem bacanas, confere clicando aqui !