Android Academy · Lezione

Pattern Repository

Separa l'accesso ai dati dall'interfaccia utente con il pattern Repository. Coordini il database Room e l'API di rete come uniche fonti di verità.

Pattern Repository è una lezione Android Academy gratuita su CoddyKit. Questa è la lezione 4 di 6. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Android Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Android Academy include 6 lezioni in totale.

Perché usare un Repository?

Con la crescita dell'app, il ViewModel può riempirsi di codice per l'accesso ai dati (query Room, chiamate Retrofit, letture da SharedPreferences).

Il pattern Repository sposta tutto l'accesso ai dati dietro un'unica classe. Il ViewModel comunica solo con il Repository e non deve sapere da dove provengono i dati.

I livelli dell'architettura

L'architettura Android consigliata ha tre livelli:

Livello UI — Activity/Fragment mostra i dati e invia gli eventi dell'utente
ViewModel — conserva lo stato, elabora gli eventi e chiama il Repository
Repository — recupera i dati da Room (locale) o Retrofit (remoto) e decide quale origine usare

Un Repository semplice

Crei una classe Repository che racchiuda il DAO e l'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)
    }
}

Il ViewModel usa il Repository

Il ViewModel recupera i dati dal Repository, non direttamente dal 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)
        }
    }
}

Strategia cache-first

Un pattern Repository comune è cache-first. Mostri immediatamente i dati memorizzati nella cache locale, quindi li aggiorni dalla rete in background:

1. Emetta immediatamente i dati memorizzati nella cache da Room
2. Recuperi i dati aggiornati dall'API
3. Salvi i dati in Room: Flow si aggiorna automaticamente

In questo modo ottiene tempi di caricamento rapidi e dati aggiornati eventualmente.

Implementazione cache-first

Aggiorni il database locale dalla rete:

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

Quando un ViewModel ha parametri nel costruttore, è necessario un ViewModelFactory per 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 per la dependency injection

Creare manualmente le istanze di Repository e ViewModel diventa laborioso nelle app di grandi dimensioni. Hilt (Dependency Injection) automatizza questa operazione:

Annoti le classi con @HiltViewModel, @Inject
Hilt crea e fornisce automaticamente le dipendenze
Elimina il codice ripetitivo delle factory

Riepilogo dei vantaggi

Il pattern Repository offre:

Testabilità — sostituire l'API reale con una finta nei test unitari
Separazione delle responsabilità — il ViewModel non sa se i dati sono locali o remoti
Unica fonte di verità — Room è sempre la fonte; l'API si limita ad aggiornarla
Flessibilità — aggiungere caching, paginazione o nuove origini dati senza modificare il ViewModel

Verifica rapida

Qual è la responsabilità principale del Repository nell'architettura Android?

Riepilogo: pattern Repository

Ora conosce l'architettura Android consigliata:

UI → ViewModel → Repository → (Room / Retrofit)
Il Repository è l'unica fonte di verità
Cache-first: mostrare immediatamente i dati locali e aggiornarli in background
Usare ViewModelFactory quando il ViewModel ha parametri nel costruttore
Hilt automatizza la dependency injection nelle app di grandi dimensioni

Ultimo corso: rete e rifinitura — Retrofit, immagini e pubblicazione.

Domande Frequenti

La lezione «Pattern Repository» è gratuita?

Sì — il testo completo di «Pattern Repository» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Android Academy, passa a CoddyKit PRO. Il corso Android Academy include 6 lezioni in totale.

Cosa imparerò in «Pattern Repository»?

Separa l'accesso ai dati dall'interfaccia utente con il pattern Repository. Coordini il database Room e l'API di rete come uniche fonti di verità. Eserciti Android Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Android Academy?

Non è richiesta alcuna esperienza precedente. Android Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 6.

Quanto tempo richiede la lezione «Pattern Repository»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Android Academy?

Sì. Ogni lezione Android Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Android Academy