Android Academy · Aula

Padrão Repository

Separe o acesso aos dados da interface do usuário com o padrão Repository. Coordene o banco de dados Room e a API de rede como fontes únicas da verdade.

Padrão Repository é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 4 de 6. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 6 aulas no total.

Por que usar um Repository?

À medida que seu aplicativo cresce, o ViewModel pode ficar cheio de código de acesso a dados (consultas do Room, chamadas do Retrofit, leituras do SharedPreferences).

O padrão Repository coloca todo o acesso a dados por trás de uma única classe. O ViewModel conversa apenas com o Repository — ele não precisa saber de onde vêm os dados.

As camadas da arquitetura

A arquitetura Android recomendada tem três camadas:

Camada de interface — Activity/Fragment exibe dados e envia eventos do usuário
ViewModel — mantém o estado, processa eventos e chama o Repository
Repository — busca dados no Room (local) ou no Retrofit (remoto) e decide qual fonte usar

Um Repository simples

Crie uma classe Repository que encapsule seu DAO e sua 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)
    }
}

O ViewModel usa o Repository

O ViewModel obtém dados do Repository — não diretamente do 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)
        }
    }
}

Estratégia de cache primeiro

Um padrão comum de Repository: cache primeiro. Exiba imediatamente os dados armazenados localmente em cache e depois atualize-os pela rede em segundo plano:

1. Emita imediatamente os dados armazenados no Room
2. Busque dados atualizados da API
3. Salve no Room — o Flow é atualizado automaticamente

Isso proporciona tempos de carregamento rápidos e dados atualizados posteriormente.

Implementação de cache primeiro

Atualize o banco de dados local pela rede:

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 um ViewModel tem parâmetros no construtor, você precisa de uma ViewModelFactory para criá-lo:

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 injeção de dependências

Criar manualmente instâncias de Repository e ViewModel fica trabalhoso em aplicativos grandes. O Hilt (injeção de dependências) automatiza esse processo:

Adicione as anotações @HiltViewModel e @Inject às suas classes
O Hilt cria e fornece as dependências automaticamente
Elimina todo o código repetitivo das factories

Resumo dos benefícios

O padrão Repository oferece:

Facilidade de teste — substitua a API real por uma falsa em testes unitários
Separação de responsabilidades — o ViewModel não sabe se os dados são locais ou remotos
Fonte única da verdade — o Room é sempre a fonte; a API apenas o atualiza
Flexibilidade — adicione cache, paginação ou novas fontes de dados sem alterar o ViewModel

Verificação rápida

Qual é a principal responsabilidade do Repository na arquitetura Android?

Recapitulação: padrão Repository

Agora você entende a arquitetura Android recomendada:

UI → ViewModel → Repository → (Room / Retrofit)
O Repository é a fonte única da verdade
Cache primeiro: exiba os dados locais imediatamente e atualize-os em segundo plano
Use ViewModelFactory quando o ViewModel tiver parâmetros no construtor
O Hilt automatiza a injeção de dependências em aplicativos maiores

Último curso: rede e acabamento — Retrofit, imagens e publicação.

Perguntas Frequentes

A aula “Padrão Repository” é grátis?

Sim — o texto completo de “Padrão Repository” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 6 aulas no total.

O que vou aprender em “Padrão Repository”?

Separe o acesso aos dados da interface do usuário com o padrão Repository. Coordene o banco de dados Room e a API de rede como fontes únicas da verdade. Você pratica Android Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Android Academy?

Nenhuma experiência prévia é necessária. Android Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 6.

Quanto tempo leva a aula “Padrão Repository”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Android Academy?

Sim. Cada aula de Android Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Android Academy