Crear una solicitud HTTP en Kotlin

1. Crear un proyecto de Kotlin y agregar dependencias
2. Use Retrofit para crear una solicitud HTTP en Kotlin
3. Use una API de la biblioteca estándar de Java para crear una solicitud HTTP en Kotlin
4. Use la API Fuel para crear una solicitud HTTP en Kotlin
5. Use la API OkHttp para crear una solicitud HTTP en Kotlin
6. Conclusión

HTTP es un protocolo de comunicación para la web y es responsable de servir contenido web desde un servidor web al navegador web.

El contenido web puede ser datos estáticos o datos dinámicos. Los datos estáticos significan que la información que se muestra en una página no cambia, mientras que los datos dinámicos que se muestran en una página web siempre cambian.

Los datos recuperados de un servidor incluyen datos estructurados, imágenes y archivos de video. La mayoría de las aplicaciones suelen trabajar con datos estructurados, que son gestionados por una base de datos.

Un enfoque común al obtener datos de la base de datos al cliente web es usar API tranquilas. Las API de descanso son consumidas por la aplicación utilizando diferentes bibliotecas a través del protocolo HTTP y cargadas en el cliente web.

En este tutorial, aprenderemos las diferentes formas que podemos usar para crear una solicitud HTTP que consuma una API Restful. La API Restful devuelve una lista de países de una aplicación alojada en Heroku.

Crear un proyecto de Kotlin y agregar dependencias

Abra el entorno de desarrollo de IntelliJ y seleccione Archivo > Nuevo > Proyecto. En la ventana que se abre, ingrese el nombre del proyecto como kotlin-http-request, seleccione Kotlin en la sección Idioma y seleccione Gradle en la sección Build system.

Finalmente, presione el botón Crear para generar el proyecto.

Abra el archivo build.gradle.kts y asegúrese de tener todas las dependencias que se muestran en el siguiente código. Estas dependencias nos ayudan a agregar las bibliotecas que podemos usar para crear solicitudes HTTP.

dependencies{
    implementation ("com.squareup.retrofit2:retrofit:2.9.0")
    implementation ("com.squareup.retrofit2:converter-gson:2.9.0")
    implementation ("com.github.kittinunf.fuel:fuel:2.3.1")
    implementation ("com.squareup.okhttp3:okhttp:4.10.0")
    testImplementation(kotlin("test"))
}

Use Retrofit para crear una solicitud HTTP en Kotlin

Retrofit es la biblioteca más utilizada al desarrollar aplicaciones con Kotlin o Java.

En la carpeta kotlin, cree una carpeta llamada modelo. Cree un archivo llamado Country.kt y copie y pegue el siguiente código en el archivo.

package model

data class Country(var id: Number,
              var countryName: String);

En este código, hemos creado una clase de datos que usaremos para almacenar los objetos país obtenidos del servidor. La clase tiene campos id y countryName, que se mapearán con los campos de los objetos recuperados del servidor.

En la carpeta kotlin, cree una carpeta llamada servicio. Cree un archivo llamado CountryService.kt y copie y pegue el siguiente código en el archivo.

package service

import model.Country
import retrofit2.Call
import retrofit2.http.GET

interface CountryService {
    @GET("/country/all")
    fun getAllCountries(): Call<List<Country>>;
}

En este código, hemos creado una solicitud GET que se asigna a la ruta relativa /country/all para obtener todos los países List<Country> del servidor. Siempre usamos la anotación @GET cuando queremos recuperar datos de un servidor.

Tenga en cuenta que el método getAllCountries() devuelve una Call, lo que significa que el método realiza una solicitud al servidor y devuelve una respuesta.

Cree un archivo llamado CountryServiceImpl.kt y copie y pegue el siguiente código en el archivo.

package service

import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactory

class CountryServiceImpl {
    fun getCountryServiceFactory(): CountryService{
        val retrofit = Retrofit.Builder()
            .baseUrl("https://countryapp254.herokuapp.com")
            .addConverterFactory(GsonConverterFactory.create())
            .build();

        return retrofit.create(CountryService::class.java);
    }
}

Esta clase realiza el trabajo principal de obtener los datos del servidor asignando la URL relativa que proporcionamos en el método getAllCountries() con la baseUrl() proporcionada al constructor.

El addConverterFactory() nos ayuda a deserializar los objetos de Kotlin utilizando la biblioteca Gson, que también proporciona Retrofit.

Cree un archivo Main.kt en la carpeta kotlin y copie y pegue el siguiente código en el archivo.

import model.Country
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
import service.CountryService
import service.CountryServiceImpl

fun getAllCountriesUsingRetrofit(){
    val countryService: CountryService =
        CountryServiceImpl().getCountryServiceFactory();

    val call: Call<List<Country>> = countryService.getAllCountries();

    call.enqueue(object : Callback<List<Country>> {
        override fun onResponse(call: Call<List<Country>>,
                                response: Response<List<Country>>
        ) {
            response.body()?.forEach(::println)
        }

        override fun onFailure(call: Call<List<Country>>, t: Throwable) {
            t.printStackTrace();
        }

    })
}

fun main(){
    getAllCountriesUsingRetrofit();
}

El código anterior verifica si nuestro código Retrofit está funcionando. Invoque el getCountryServiceFactory() que devuelve un CountryService.

La instancia CountryService nos ayuda a llamar al método getAllCountries(). El método devuelve una Call que contiene una respuesta a nuestros datos.

Para recuperar los países del servidor, llame al método enqueue() e implemente los métodos onResponse() y onFailure() de CallBack.

El método enqueue() se ejecuta de forma asíncrona y, dado que estamos creando una aplicación de consola, solo necesitamos registrar la respuesta body() en la consola. Ejecute este código y asegúrese de que el resultado sea como se muestra a continuación.

[{"id":18,"countryName":"Kenya"},
{"id":20,"countryName":"Tanzania"},
{"id":21,"countryName":"Ethiopia"},
{"id":22,"countryName":"Malawi"},
{"id":23,"countryName":"Country"},
{"id":24,"countryName":"Country"},
{"id":25,"countryName":"Kenya"},
{"id":26,"countryName":"Country"},
{"id":27,"countryName":"USA"},
{"id":28,"countryName":"USA"},
{"id":29,"countryName":"Kenya"},
{"id":30,"countryName":"Kenya"}]

Use una API de la biblioteca estándar de Java para crear una solicitud HTTP en Kotlin

Comente el ejemplo anterior en el archivo Main.kt y copie y pegue el siguiente código en el archivo posterior.

import java.net.HttpURLConnection
import java.net.URL

fun getCountriesUsingHttpURLConnection(){
    var url = URL("https://countryapp254.herokuapp.com/country/all");

    with(url.openConnection() as HttpURLConnection){
        inputStream.bufferedReader().use {
            it.lines().forEach(::println)
        }
    }
}

fun main(){
    getCountriesUsingHttpURLConnection();
}

La URLConnection es una API de la biblioteca estándar de Java del paquete java.net y se puede utilizar en Kotlin para realizar solicitudes HTTP.

El HttpURLConnection es una instancia de URLConnection, y lo usamos para crear una conexión HTPP a nuestro servidor. La función with() realiza una sola solicitud al servidor utilizando la conexión establecida, ejecuta el código dentro de la función y devuelve nuestro resultado.

El inputStream dentro de la función lee los datos de la conexión establecida utilizando un bufferedReader() y la función de extensión use() nos ayuda a registrar los datos leídos desde el servidor a la consola. Ejecute este código y asegúrese de que el resultado sea como se muestra a continuación.

[{"id":18,"countryName":"Kenya"},
{"id":20,"countryName":"Tanzania"},
{"id":21,"countryName":"Ethiopia"},
{"id":22,"countryName":"Malawi"},
{"id":23,"countryName":"Country"},
{"id":24,"countryName":"Country"},
{"id":25,"countryName":"Kenya"},
{"id":26,"countryName":"Country"},
{"id":27,"countryName":"USA"},
{"id":28,"countryName":"USA"},
{"id":29,"countryName":"Kenya"},
{"id":30,"countryName":"Kenya"}]

Use la API Fuel para crear una solicitud HTTP en Kotlin

Comente el ejemplo anterior en el archivo Main.kt y copie y pegue el siguiente código en el archivo posterior.

import com.github.kittinunf.fuel.httpGet
import com.github.kittinunf.result.Result

fun getCountriesUsingFuel(){
    val request = "https://countryapp254.herokuapp.com/country/all"
        .httpGet()
        .responseString{ request, response, result ->
            when(result){
                is Result.Failure -> {
                    println(result.getException());
                }

                is Result.Success -> {
                    println(result.get())
                }
            }
        }

    request.join();
}

fun main(){
    getCountriesUsingFuel();
}

La API Fuel es otro enfoque que podemos usar para crear solicitudes HTTP en nuestras aplicaciones. En este ejemplo, hemos llamado a la función httpGet(), una extensión de la clase String, para indicar que estamos realizando una petición GET.

La cadena proporciona la API RESTful utilizada para obtener datos del servidor.

El método httpGet() devuelve una Solicitud que nos permite llamar al método responseString() para ejecutar la solicitud de forma asíncrona en un Charset.UTF-8 pasando un controlador como argumento.

El controlador es una función lambda que acepta tres parámetros de tipo Solicitud, Respuesta y Resultado y devuelve una Unidad, lo que significa que no devuelve ningún valor. Como estamos interesados en el Resultado, invocamos Fracaso y Éxito, que proporcionan un resultado cuando la aplicación falló o tuvo éxito, respectivamente.

El método when() es el mismo que switch en Java y nos ayuda a tomar diferentes decisiones cuando la solicitud fue exitosa o fallida. Ejecute este código y asegúrese de que el resultado sea como se muestra a continuación.

[{"id":18,"countryName":"Kenya"},
{"id":20,"countryName":"Tanzania"},
{"id":21,"countryName":"Ethiopia"},
{"id":22,"countryName":"Malawi"},
{"id":23,"countryName":"Country"},
{"id":24,"countryName":"Country"},
{"id":25,"countryName":"Kenya"},
{"id":26,"countryName":"Country"},
{"id":27,"countryName":"USA"},
{"id":28,"countryName":"USA"},
{"id":29,"countryName":"Kenya"},
{"id":30,"countryName":"Kenya"}]

Use la API OkHttp para crear una solicitud HTTP en Kotlin

Comente el ejemplo anterior en el archivo Main.kt y copie y pegue el siguiente código en el archivo posterior.

import okhttp3.OkHttpClient
import okhttp3.Request

private val httpClient = OkHttpClient()

fun getCountriesUsingOkHttp() {
    val countriesRequest = Request.Builder()
        .url("https://countryapp254.herokuapp.com/country/all")
        .build();

    httpClient.newCall(countriesRequest).execute().use { countryResponse ->
        if (!countryResponse.isSuccessful) throw RuntimeException("status code $countryResponse");

        println(countryResponse.body!!.string())
    }
}

fun main(){
    getCountriesUsingOkHttp();
}

El OkHttpClient() crea una instancia de API compartida que podemos usar para realizar solicitudes HTTP al servidor.

La instancia compartida se crea porque cada cliente tiene sus grupos de subprocesos y grupos de conexiones, y es importante reutilizarlos para ahorrar memoria y reducir la latencia.

El Builder() crea una Solicitud utilizando la URL proporcionada, y para preparar una solicitud al servidor, invocamos el método newCall() desde la instancia OkHttpClient() y pasamos la Solicitud como argumento de este método.

El método newCall() devuelve una Call e invocamos su método execute() para obtener la respuesta de la solicitud de Response.body(). La función de extensión use() nos ayuda a acceder a los datos de la respuesta y registrarlos en la consola.

Tenga en cuenta que la función use() cierra el resultado independientemente de si se lanzó una excepción o no. Ejecute este código y asegúrese de que el resultado sea como se muestra a continuación.

[{"id":18,"countryName":"Kenya"},
{"id":20,"countryName":"Tanzania"},
{"id":21,"countryName":"Ethiopia"},
{"id":22,"countryName":"Malawi"},
{"id":23,"countryName":"Country"},
{"id":24,"countryName":"Country"},
{"id":25,"countryName":"Kenya"},
{"id":26,"countryName":"Country"},
{"id":27,"countryName":"USA"},
{"id":28,"countryName":"USA"},
{"id":29,"countryName":"Kenya"},
{"id":30,"countryName":"Kenya"}]

Conclusión

En este tutorial, hemos aprendido diferentes formas que podemos aprovechar para crear solicitudes HTTP en Kotlin. Los enfoques que cubrimos incluyen el uso de Retrofit, el uso de una API de la biblioteca estándar de Java, el uso de la API Fuel y, finalmente, el uso de la API OkHttp.

Tenga en cuenta que estos no son los únicos enfoques que podemos usar; hay otros enfoques que podemos usar, como la API Volley. Siéntase libre de usar cualquier método que sea adecuado para su caso de uso.