Android Academy · Leçon

Patron Repository

Séparez l’accès aux données de l’interface utilisateur avec le patron Repository. Coordonnez la base de données Room et l’API réseau comme sources uniques de vérité.

Patron Repository est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 6. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 6 leçons au total.

Pourquoi utiliser un Repository ?

À mesure que votre application grandit, le ViewModel peut se retrouver encombré de code d'accès aux données (requêtes Room, appels Retrofit, lectures de SharedPreferences).

Le modèle Repository regroupe tout l'accès aux données derrière une seule classe. Le ViewModel communique uniquement avec le Repository : il n'a pas besoin de savoir d'où proviennent les données.

Les couches de l'architecture

L'architecture Android recommandée comporte trois couches :

Couche d'interface — l'activité ou le fragment affiche les données et transmet les événements utilisateur
ViewModel — conserve l'état, traite les événements et appelle le Repository
Repository — récupère les données depuis Room (local) ou Retrofit (distant) et choisit la source à utiliser

Un Repository simple

Créez une classe Repository qui encapsule votre DAO et votre API distante :

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)
    }
}

Le ViewModel utilise le Repository

Le ViewModel obtient les données depuis le Repository, et non directement depuis le 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)
        }
    }
}

Stratégie du cache en priorité

Un modèle Repository courant consiste à donner la priorité au cache. Affichez immédiatement les données mises en cache localement, puis actualisez-les depuis le réseau en arrière-plan :

1. Émettre immédiatement les données mises en cache par Room
2. Récupérer les données à jour depuis l'API
3. Enregistrer les données dans Room — le Flow se met à jour automatiquement

Vous obtenez ainsi un chargement rapide et des données finalement actualisées.

Implémentation du cache en priorité

Actualisez la base de données locale depuis le réseau :

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

Lorsqu'un ViewModel possède des paramètres de constructeur, vous avez besoin d'un ViewModelFactory pour le créer :

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 pour l'injection de dépendances

Créer manuellement des instances de Repository et de ViewModel devient fastidieux dans les grandes applications. Hilt (injection de dépendances) automatise cette tâche :

Annotez vos classes avec @HiltViewModel et @Inject
Hilt crée et fournit automatiquement les dépendances
Supprime tout le code répétitif des fabriques

Résumé des avantages

Le modèle Repository apporte :

Testabilité — remplacez la véritable API par une fausse API pour les tests unitaires
Séparation des responsabilités — le ViewModel ne sait pas si les données sont locales ou distantes
Source unique de vérité — Room reste toujours la source ; l'API sert uniquement à l'actualiser
Flexibilité — ajoutez une mise en cache, une pagination ou de nouvelles sources de données sans modifier le ViewModel

Vérification rapide

Quelle est la responsabilité principale du Repository dans l'architecture Android ?

Récapitulatif : modèle Repository

Vous comprenez maintenant l'architecture Android recommandée :

UI → ViewModel → Repository → (Room / Retrofit)
Le Repository est la source unique de vérité
Cache en priorité : affichez immédiatement les données locales et actualisez-les en arrière-plan
Utilisez ViewModelFactory lorsque le ViewModel possède des paramètres de constructeur
Hilt automatise l'injection de dépendances dans les grandes applications

Dernier cours : réseau et finition — Retrofit, images et publication.

Questions Fréquemment Posées

La leçon « Patron Repository » est-elle gratuite ?

Oui — le texte complet de « Patron Repository » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 6 leçons au total.

Qu'est-ce que j'apprendrai dans « Patron Repository » ?

Séparez l’accès aux données de l’interface utilisateur avec le patron Repository. Coordonnez la base de données Room et l’API réseau comme sources uniques de vérité. Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 6.

Combien de temps prend la leçon « Patron Repository » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Android Academy