Android Academy · Aula

Banco de dados Room

Persista dados estruturados localmente com Room. Defina Entidades, DAOs e a classe Database. Faça consultas com SQL e observe os resultados com LiveData ou Flow.

Banco de dados Room é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 2 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.

O que é Room?

Room é a biblioteca de persistência recomendada pelo Google para Android. É um invólucro em torno do SQLite que oferece:

Consultas SQL seguras quanto ao tipo, verificadas no momento da compilação
Suporte a corrotinas do Kotlin
Integração com LiveData / Fluxo
Suporte a migrações para alterações de esquema

Os três componentes do Room

O Room é composto por três anotações:

@Entity — uma classe de dados que mapeia para uma tabela do banco de dados
@Dao (Objeto de Acesso a Dados) — uma interface com consultas SQL
@Database — a classe principal do banco de dados, que reúne tudo

Adicionando dependências do Room

Adicione o Room a app/build.gradle:

// app/build.gradle
plugins {
    id 'kotlin-kapt'  // needed for Room annotation processor
}

dependencies {
    val roomVersion = "2.6.1"
    implementation "androidx.room:room-runtime:$roomVersion"
    kapt "androidx.room:room-compiler:$roomVersion"
    implementation "androidx.room:room-ktx:$roomVersion" // coroutine support
}

Definindo uma entidade

Anote uma classe de dados com @Entity para criar uma tabela no banco de dados:

import androidx.room.Entity
import androidx.room.PrimaryKey

@Entity(tableName = "notes")
data class Note(
    @PrimaryKey(autoGenerate = true)
    val id: Int = 0,
    val title: String,
    val body: String,
    val createdAt: Long = System.currentTimeMillis()
)

// Each field = one column in the database table
// @PrimaryKey autoGenerate = Room assigns the id automatically

Criando o DAO

Defina as consultas em uma interface DAO. O Room gera a implementação para você:

import androidx.room.*
import kotlinx.coroutines.flow.Flow

@Dao
interface NoteDao {

    @Query("SELECT * FROM notes ORDER BY createdAt DESC")
    fun getAllNotes(): Flow<List<Note>>  // emits new list whenever data changes

    @Query("SELECT * FROM notes WHERE id = :noteId")
    suspend fun getNoteById(noteId: Int): Note?

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insert(note: Note)

    @Update
    suspend fun update(note: Note)

    @Delete
    suspend fun delete(note: Note)
}

Criando o banco de dados

A classe @Database é o ponto de entrada do Room. Crie-a uma vez e mantenha-a como singleton:

import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
import android.content.Context

@Database(entities = [Note::class], version = 1, exportSchema = false)
abstract class NoteDatabase : RoomDatabase() {

    abstract fun noteDao(): NoteDao

    companion object {
        @Volatile private var INSTANCE: NoteDatabase? = null

        fun getInstance(context: Context): NoteDatabase {
            return INSTANCE ?: synchronized(this) {
                Room.databaseBuilder(
                    context.applicationContext,
                    NoteDatabase::class.java,
                    "note_database"
                ).build().also { INSTANCE = it }
            }
        }
    }
}

Usando o Room no ViewModel

Configure o DAO em um ViewModel usando corrotinas:

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch

class NoteViewModel(private val dao: NoteDao) : ViewModel() {

    val notes = dao.getAllNotes()  // Flow — auto-updates when DB changes

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

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

Observando dados do Room na interface

Colete o Fluxo do Room na sua Activity ou Fragment:

import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.launch

class NoteActivity : AppCompatActivity() {
    private val viewModel: NoteViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // ...

        lifecycleScope.launch {
            viewModel.notes.collect { notes ->
                adapter.submitList(notes)  // update RecyclerView
            }
        }
    }
}

Migrações de banco de dados

Quando você altera sua entidade (adiciona uma coluna ou renomeia uma tabela), deve fornecer uma migração para que os dados existentes do usuário não sejam perdidos.

Incremente o número da versão em @Database(version = 2) e defina um objeto Migration com o SQL para transformar o esquema antigo no novo.

Verificação rápida

Qual anotação do Room marca um método de interface como uma consulta SQL SELECT?

Recapitulação: banco de dados Room

Agora você pode criar aplicativos com persistência de dados locais:

@Entity — classe de dados → tabela do banco de dados
@Dao — interface com @Query, @Insert, @Delete
@Database — ponto de entrada singleton
Retorne Flow<List> do DAO para obter atualizações em tempo real
Chame o DAO a partir do ViewModel usando viewModelScope.launch

A seguir: escreva código assíncrono sem callbacks usando Corrotinas.

Perguntas Frequentes

A aula “Banco de dados Room” é grátis?

Sim — o texto completo de “Banco de dados Room” é 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 “Banco de dados Room”?

Persista dados estruturados localmente com Room. Defina Entidades, DAOs e a classe Database. Faça consultas com SQL e observe os resultados com LiveData ou Flow. 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 2 de 6.

Quanto tempo leva a aula “Banco de dados Room”?

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