Android Academy · Lección

Retrofit y API REST

Realice solicitudes HTTP con Retrofit. Defina interfaces de API, analice JSON con Gson/Moshi, gestione respuestas y errores e integre todo con corrutinas.

Retrofit y API REST es una lección gratuita de Android Academy en CoddyKit. Esta es la lección 1 de 6. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Android Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Android Academy incluye 6 lecciones en total.

¿Qué es Retrofit?

Retrofit es el cliente HTTP más popular para Android, desarrollado por Square. Permite definir su API REST como una interfaz de Kotlin, sin código HTTP repetitivo.

Anote los métodos con @GET, @POST, etc.
Convierte automáticamente las respuestas JSON en data classes de Kotlin
Compatibilidad nativa con corrutinas (suspend fun)

Añadir dependencias

Añada Retrofit y el convertidor de Gson a app/build.gradle:

// app/build.gradle
dependencies {
    implementation 'com.squareup.retrofit2:retrofit:2.11.0'
    implementation 'com.squareup.retrofit2:converter-gson:2.11.0'
    implementation 'com.squareup.okhttp3:logging-interceptor:4.12.0'
}

// AndroidManifest.xml — add internet permission:
// <uses-permission android:name="android.permission.INTERNET" />

Definir la interfaz de la API

Cree una interfaz de Kotlin que describa los endpoints de su API:

import retrofit2.http.*

data class Post(val id: Int, val title: String, val body: String, val userId: Int)

interface ApiService {

    @GET("posts")
    suspend fun getPosts(): List<Post>

    @GET("posts/{id}")
    suspend fun getPost(@Path("id") id: Int): Post

    @POST("posts")
    suspend fun createPost(@Body post: Post): Post

    @GET("posts")
    suspend fun getPostsByUser(@Query("userId") userId: Int): List<Post>
}

Crear la instancia de Retrofit

Cree una instancia singleton de Retrofit, normalmente en un object o mediante Hilt:

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

object RetrofitClient {
    private const val BASE_URL = "https://jsonplaceholder.typicode.com/"

    val api: ApiService by lazy {
        Retrofit.Builder()
            .baseUrl(BASE_URL)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(ApiService::class.java)
    }
}

Realizar una solicitud GET

Llame a la API desde un Repository usando corrutinas de Kotlin:

class PostRepository {
    private val api = RetrofitClient.api

    suspend fun getPosts(): List<Post> {
        return api.getPosts()  // Retrofit handles threading for you
    }

    suspend fun getPost(id: Int): Post {
        return api.getPost(id)
    }
}

// In ViewModel:
fun loadPosts() {
    viewModelScope.launch {
        try {
            val posts = withContext(Dispatchers.IO) {
                repository.getPosts()
            }
            _posts.value = posts
        } catch (e: Exception) {
            _error.value = "Network error: ${e.message}"
        }
    }
}

Mapeo de JSON con Gson

Gson convierte automáticamente el JSON en data classes de Kotlin. Los nombres de los campos deben coincidir con las claves del JSON o debe usar @SerializedName:

import com.google.gson.annotations.SerializedName

data class User(
    val id: Int,
    val name: String,
    val email: String,
    @SerializedName("phone_number")  // JSON key is 'phone_number'
    val phoneNumber: String,
    @SerializedName("created_at")
    val createdAt: String
)

Solicitud POST con un cuerpo

Envíe datos a un servidor usando @POST y @Body:

// API interface:
@POST("users")
suspend fun createUser(@Body user: User): User

// In Repository:
suspend fun createUser(name: String, email: String): User {
    val newUser = User(id = 0, name = name, email = email, phoneNumber = "", createdAt = "")
    return api.createUser(newUser)
}

// In ViewModel:
fun registerUser(name: String, email: String) {
    viewModelScope.launch {
        val user = withContext(Dispatchers.IO) {
            repo.createUser(name, email)
        }
        _registeredUser.value = user
    }
}

Cabeceras y autenticación

Añada cabeceras a cada solicitud mediante un interceptor de OkHttp:

import okhttp3.OkHttpClient
import okhttp3.Interceptor

val authClient = OkHttpClient.Builder()
    .addInterceptor { chain ->
        val request = chain.request().newBuilder()
            .addHeader("Authorization", "Bearer $token")
            .addHeader("Accept", "application/json")
            .build()
        chain.proceed(request)
    }
    .build()

val retrofit = Retrofit.Builder()
    .baseUrl(BASE_URL)
    .client(authClient)  // use our authenticated client
    .addConverterFactory(GsonConverterFactory.create())
    .build()

Gestión de errores HTTP

Una respuesta HTTP correcta (200-299) devuelve un valor. Las respuestas de error (4xx, 5xx) lanzan una HttpException. Gestione siempre ambos casos:

HttpException — el servidor devolvió un código de estado de error
IOException — no hay conexión de red

Comprobación rápida

¿Qué anotación de Retrofit asigna un parámetro de método a un segmento de ruta de URL como /posts/{id}?

Repaso: Retrofit y API

Ahora puede obtener datos de cualquier API REST:

Defina la API con una interfaz de Kotlin y anotaciones (@GET, @POST, @Path, @Query)
Cree una instancia de Retrofit con una URL base y un convertidor de Gson
Llame a funciones suspend desde una corrutina en el ViewModel
Convierta automáticamente JSON → data classes de Kotlin
Gestione HttpException e IOException

Siguiente: mostrar imágenes de red con Coil.

Preguntas frecuentes

¿La lección «Retrofit y API REST» es gratis?

Sí — el texto completo de «Retrofit y API REST» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Android Academy, actualiza a CoddyKit PRO. El curso de Android Academy incluye 6 lecciones en total.

¿Qué aprenderé en «Retrofit y API REST»?

Realice solicitudes HTTP con Retrofit. Defina interfaces de API, analice JSON con Gson/Moshi, gestione respuestas y errores e integre todo con corrutinas. Practicas Android Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Android Academy?

No se requiere experiencia previa. Android Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 6.

¿Cuánto tiempo toma la lección «Retrofit y API REST»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Android Academy?

Sí. Cada lección de Android Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Android Academy