Existem várias bibliotecas para fazer requisições HTTP em Android, mas a que considero mais simples e rápida é sem dúvida o Rest Template do Spring.

Adicionando dependências

O primeiro passo é adicionar as dependências necessárias ao projeto. Será necessária a biblioteca do Rest Template, mais as bibliotecas do Jackson.

Em seu arquivo build.gradle do módulo, adicione:

dependencies {
   // [...]
   compile 'org.springframework.android:spring-android-rest-template:2.0.0.M3'
   compile 'com.fasterxml.jackson.core:jackson-annotations:2.6.3'
   compile 'com.fasterxml.jackson.core:jackson-databind:2.2.1'
}

Ainda neste arquivo, em android adicione:

android {
   // [...]

   packagingOptions {
       exclude 'META-INF/ASL2.0'
       exclude 'META-INF/LICENSE'
       exclude 'META-INF/license.txt'
       exclude 'META-INF/NOTICE'
       exclude 'META-INF/notice.txt'
   }
}

Após, clique para sincronizar o projeto, aguarde a sincronização ser concluída e podemos utilizar o Rest Template.

Usando o Rest Template no Android

É importante antes de mais nada, adicionar a permissão de internet ao projeto. Para isso abra o arquivo AndroidManifest.xml e adicione:

<uses-permission android:name="android.permission.INTERNET" />

Agora basta escrever o código em java para criar um singleton do rest template, onde será adicionado os conversores necessários para converter json em objeto.

import android.content.Context;

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.client.RestTemplate;

import java.nio.charset.Charset;
import java.util.Collections;

/**
* Created by wolmir on 18/12/17.
*/
public class RestTemplateSingleton {

   private static RestTemplateSingleton restTemplateSingleton;
   private RestTemplate restTemplate;

   private RestTemplateSingleton(Context context) {
       restTemplate = new RestTemplate();

       ObjectMapper objectMapper = new ObjectMapper();
       objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
       MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
       converter.setObjectMapper(objectMapper);

       restTemplate.getMessageConverters().add(converter);
       restTemplate.getMessageConverters().add(0, new StringHttpMessageConverter(Charset.forName("UTF-8")));
   }


   public static RestTemplateSingleton getInstance(Context context) {
       if ( restTemplateSingleton == null ) {
           restTemplateSingleton = new RestTemplateSingleton(context);
       }

       return restTemplateSingleton;
   }

   public RestTemplate getRestTemplate() {
       return restTemplate;
   }

}

Feito isso agora já é possível fazer as chamadas HTTP.

ResponseEntity<T[]> forEntity = RestTemplateSingleton.getInstance(context).getRestTemplate().getForEntity(URL, T[].class);

Note que T é o objeto que será retornado no corpo da requisição e a URL a url do json a ser convertido.

Não esqueca de deixar suas dúvidas nos comentários e compartilhar este post.