Cómo empezar con Ktor en Kotlin: Guía para principiantes

JetBrains creó una librería que tiene por objetivo facilitar el consumo y la creación de APIs de manera nativa en Kotlin. En caso de que aún no sepas usarla y no le estés sacando el máximo provecho, te guiaremos para que aprendas a trabajar con Ktor en Kotlin. Para ello haremos uso de Ktor Client y construiremos una aplicación multiplataforma que consulte datos de una API sencilla de superhéroes.

Ktor en Kotlin: La herramienta ideal para APIs y servidores

Con esta librería puedes crear aplicaciones backend y construir datos en el frontend. Ktor es diferente de otros frameworks porque te brinda soporte para aplicaciones Kotlin Multiplatform (KMP), de modo que si piensas desarrollar en Android e iOS, te será muy útil.

Además, Ktor en Kotlin está optimizado para trabajar con corrutinas, así que puedes hacer peticiones HTTP en segundo plano y no se bloqueará la interfaz de usuario.

Configuración inicial del proyecto

Paso 1: Crea el proyecto KMP con Ktor en Kotlin

• Abre Android Studio y crea un nuevo proyecto utilizando el wizard de Kotlin Multiplatform.

• Selecciona las plataformas Android e iOS.

• Elige Jetpack Compose Multiplatform para simplificar la creación de la interfaz.

Paso 2: Agrega las dependencias necesarias en build.gradle.kts

En el archivo build.gradle.kts del módulo ComposeApp, define las dependencias para Ktor Client y Kotlinx Serialization, porque las usarás para procesar el JSON de la API:

dependencies {
    commonMain {
        implementation("io.ktor:ktor-client-core:2.3.11")
        implementation("io.ktor:ktor-client-content-negotiation:2.3.11")
        implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.11")
    }
    androidMain {
        implementation("io.ktor:ktor-client-okhttp:2.3.11")
    }
    iosMain {
        implementation("io.ktor:ktor-client-darwin:2.3.11")
    }
}

Con esta configuración, Ktor estará disponible tanto en el código común como en el específico de cada plataforma.

Configurando el cliente de Ktor en Kotlin

Ahora vas a crear un cliente HTTP con Ktor en Kotlin para manejar la comunicación con la API. Dentro del directorio commonMain/kotlin, crea un nuevo archivo NetworkUtils.kt con este código:

import io.ktor.client.*
import io.ktor.client.engine.*
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.serialization.kotlinx.json.*
import kotlinx.serialization.json.Json

object NetworkUtils {
    val httpClient = HttpClient {
        install(ContentNegotiation) {
            json(Json { ignoreUnknownKeys = true })
        }
    }
}

Aquí configuras el httpClient de Ktor con ContentNegotiation, permitiendo que cualquier respuesta JSON se serialice directamente en data classes de Kotlin.

Consumir datos de la API de SuperHero

Para esta guía, usaremos SuperHero API, una API pública con la que obtienes información sobre superhéroes. Debes obtener un access-token gratuito en su sitio web, que usarás para las solicitudes.

La URL base para la API es:

https://www.superheroapi.com/api.php/your-access-token/search/name 

donde your-access-token es el token generado y name representa el nombre del superhéroe que se buscará.

Paso 1: Crea las clases de datos en Kotlin

Para procesar el JSON que recibirás de la API, necesitas clases de datos compatibles con Ktor en Kotlin.

Crea el directorio model dentro de commonMain/kotlin y añade las siguientes data classes:

@Serializable
data class ApiResponse(
    val results: List<Hero>,
    @SerialName("response") val ok: String
)

@Serializable
data class Hero(
    val id: String,
    val name: String,
    val powerstats: PowerStats,
    val biography: Biography,
    val appearance: Appearance
)

@Serializable
data class PowerStats(
    val intelligence: String,
    val strength: String,
    val speed: String,
    val durability: String,
    val power: String,
    val combat: String
)

@Serializable
data class Biography(
    val fullName: String,
    val alignment: String
)

@Serializable
data class Appearance(
    val gender: String,
    val race: String,
    val height: List<String>,
    val weight: List<String>
)

La anotación @Serializable y la librería kotlinx.serialization permiten que Ktor pueda convertir el JSON recibido en objetos de Kotlin.

La clase ApiResponse representa el JSON principal y contiene una lista de superhéroes (results), mientras que Hero describe cada superhéroe.

Paso 2: Crea la función para consumir la API

Dentro de NetworkUtils, tienes que añadir una función para realizar la petición a la API. Esta función recibe el nombre del superhéroe y devuelve los resultados en una lista:

suspend fun getSuperheroes(name: String): List<Hero> {
    val url = "https://www.superheroapi.com/api.php/your-access-token/search/$name"
    val response: ApiResponse = httpClient.get(url).body()
    return response.results
}

Este método realiza la petición HTTP usando httpClient.get() y convierte el JSON en un objeto ApiResponse, gracias a la configuración de ContentNegotiation de Ktor en Kotlin.

Crear la interfaz con Jetpack Compose Multiplatform

Gracias al Jetpack Compose Multiplatform, puedes definir una interfaz que funcione tanto en Android como en iOS.

Agrega el siguiente código a tu función de interfaz para capturar el nombre del superhéroe y mostrar sus datos:

@Composable
@Preview
fun SuperheroSearchApp() {
    MaterialTheme {
        var superheroName by remember { mutableStateOf("") }
        var superheroList by remember { mutableStateOf<List<Hero>>(emptyList()) }

        Column(Modifier.fillMaxWidth(), horizontalAlignment = Alignment.CenterHorizontally) {
            TextField(
                value = superheroName,
                onValueChange = { superheroName = it },
                label = { Text("Nombre del superhéroe") }
            )
            Button(onClick = {
                CoroutineScope(Dispatchers.IO).launch {
                    superheroList = NetworkUtils.getSuperheroes(superheroName)
                }
            }) {
                Text("Buscar")
            }
            LazyColumn {
                items(superheroList) { hero ->
                    Text("Nombre: ${hero.name}")
                }
            }
        }
    }
}

Esta interfaz incluye un TextField para ingresar el nombre del superhéroe y un botón que activa la búsqueda.

Los resultados se muestran en un LazyColumn, que genera una lista con el nombre de cada héroe encontrado.

Ejecución y pruebas de la app

Con esta implementación, al ingresar el nombre de un superhéroe y presionar “Buscar”, la aplicación consumirá los datos de la API y mostrará los resultados. Ktor en Kotlin maneja la conversión JSON a objetos de Kotlin, permitiéndote ver rápidamente el resultado.

Trabajar con Ktor en Kotlin es solo el comienzo de lo que puedes lograr en el desarrollo de apps multiplataforma. Puedes crear aplicaciones móviles de calidad profesional, en el Bootcamp de Desarrollo de Aplicaciones Móviles iOS & Android de KeepCoding. Nosotros te ayudaremos a ganar la experiencia para convertirte en un desarrollador móvil en una industria con alta demanda, salarios competitivos y estabilidad laboral. ¡Inscríbete y transforma tu carrera en tecnología!