Android Academy · Lección

Patrón Repository

Separe el acceso a los datos de la interfaz de usuario mediante el patrón Repository. Coordine la base de datos Room y la API de red como fuentes únicas de verdad.

Patrón Repository es una lección gratuita de Android Academy en CoddyKit. Esta es la lección 4 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.

¿Por qué usar un Repository?

A medida que su aplicación crece, el ViewModel puede llenarse de código de acceso a datos (consultas de Room, llamadas de Retrofit y lecturas de SharedPreferences).

El patrón Repository encapsula todo el acceso a los datos en una sola clase. El ViewModel solo se comunica con el Repository; no necesita saber de dónde proceden los datos.

Las capas de la arquitectura

La arquitectura recomendada de Android tiene tres capas:

Capa de UI — Activity/Fragment muestra los datos y envía los eventos del usuario
ViewModel — mantiene el estado, procesa los eventos y llama al Repository
Repository — obtiene datos de Room (local) o Retrofit (remoto) y decide qué fuente usar

Un Repository sencillo

Cree una clase Repository que encapsule su DAO y su API remota:

class NoteRepository(private val dao: NoteDao) {

    // Expose a Flow that emits whenever data changes
    val allNotes = dao.getAllNotes()

    suspend fun insert(note: Note) {
        dao.insert(note)
    }

    suspend fun delete(note: Note) {
        dao.delete(note)
    }

    suspend fun update(note: Note) {
        dao.update(note)
    }
}

El ViewModel usa el Repository

El ViewModel obtiene los datos del Repository, no directamente del DAO:

class NoteViewModel(private val repo: NoteRepository) : ViewModel() {

    val notes = repo.allNotes  // Flow from Repository

    fun addNote(title: String, body: String) {
        viewModelScope.launch {
            repo.insert(Note(title = title, body = body))
        }
    }

    fun deleteNote(note: Note) {
        viewModelScope.launch {
            repo.delete(note)
        }
    }
}

Estrategia cache-first

Un patrón habitual de Repository es cache-first. Muestre inmediatamente los datos almacenados en la caché local y, después, actualícelos desde la red en segundo plano:

1. Emita inmediatamente los datos almacenados en la caché de Room
2. Obtenga los datos actualizados de la API
3. Guárdelos en Room; Flow se actualiza automáticamente

Así se consigue una carga rápida y datos actualizados eventualmente.

Implementación de cache-first

Actualice la base de datos local desde la red:

class ProductRepository(
    private val dao: ProductDao,
    private val api: ProductApiService
) {
    // Room Flow emits local data immediately
    val products = dao.getAllProducts()

    // Call this to sync with the server
    suspend fun refresh() {
        try {
            val remoteProducts = api.getProducts()
            dao.insertAll(remoteProducts)  // overwrites local cache
        } catch (e: Exception) {
            // Network failed — cached data is still shown
        }
    }
}

ViewModelFactory

Cuando un ViewModel tiene parámetros en el constructor, necesita un ViewModelFactory para crearlo:

class NoteViewModelFactory(
    private val repo: NoteRepository
) : ViewModelProvider.Factory {
    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        @Suppress("UNCHECKED_CAST")
        return NoteViewModel(repo) as T
    }
}

// In Activity:
val db = NoteDatabase.getInstance(this)
val repo = NoteRepository(db.noteDao())
val factory = NoteViewModelFactory(repo)
val viewModel = ViewModelProvider(this, factory)[NoteViewModel::class.java]

Hilt para la inyección de dependencias

Crear manualmente instancias de Repository y ViewModel resulta tedioso en aplicaciones grandes. Hilt (inyección de dependencias) lo automatiza:

Anote sus clases con @HiltViewModel y @Inject
Hilt crea y proporciona las dependencias automáticamente
Elimina todo el código repetitivo de las factories

Resumen de ventajas

El patrón Repository aporta:

Facilidad de prueba — puede sustituir la API real por una falsa en las pruebas unitarias
Separación de responsabilidades — el ViewModel no sabe si los datos son locales o remotos
Fuente única de verdad — Room es siempre la fuente; la API solo la actualiza
Flexibilidad — puede añadir caché, paginación o nuevas fuentes de datos sin modificar el ViewModel

Comprobación rápida

¿Cuál es la responsabilidad principal del Repository en la arquitectura de Android?

Repaso: patrón Repository

Ahora comprende la arquitectura recomendada de Android:

UI → ViewModel → Repository → (Room / Retrofit)
El Repository es la fuente única de verdad
Cache-first: muestra inmediatamente los datos locales y los actualiza en segundo plano
Use ViewModelFactory cuando el ViewModel tenga parámetros en el constructor
Hilt automatiza la inyección de dependencias en aplicaciones grandes

Último curso: Redes y pulido — Retrofit, imágenes y publicación.

Preguntas frecuentes

¿La lección «Patrón Repository» es gratis?

Sí — el texto completo de «Patrón Repository» 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 «Patrón Repository»?

Separe el acceso a los datos de la interfaz de usuario mediante el patrón Repository. Coordine la base de datos Room y la API de red como fuentes únicas de verdad. 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 4 de 6.

¿Cuánto tiempo toma la lección «Patrón Repository»?

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