0

ROOM

#Kotlin #Java #Android
Maria Santana
Maria Santana

Olá devs, tudo bem?

Bora aprender um pouco sobre persistência de dados!


Se você está desenvolvendo um aplicativo que processa uma quantidade não trivial de dados estruturados, o ROOM é uma ótima forma para a persistência desses dados localmente.

Por exemplo, quando o dispositivo não conseguir acessar a rede, o usuário ainda poderá navegar pelo conteúdo enquanto estiver off-line. Todas as modificações de conteúdo feitas pelo usuário serão sincronizadas com o servidor quando o dispositivo ficar on-line novamente.


Antes de ir para o código, precisamos entender o conceito dos três componentes principais do ROOM:


  • Banco de dados(Database): contém o suporte do banco de dados e serve como o principal ponto de acesso para a conexão com dados relacionais e persistentes do app.
  • Entidade(Entity): representa uma tabela dentro do banco de dados.
  • DAO: contém os métodos utilizados para acessar o banco de dados.


O app usa o banco de dados do Room para conseguir os objetos de acesso a dados (DAO) associados a esse banco de dados. Logo depois, o app usa cada DAO para conseguir entidades do banco de dados e salvar as alterações dessas entidades de volta no banco de dados. Por fim, o app usa uma entidade para conseguir e definir valores que correspondam a colunas da tabela no banco de dados.


Na imagem abaixo fica mais simples de entender o esquema:


Para poder utilizar o ROOM, você precisa adicionar algumas dependências no seu arquivo build.gradle :

    //ROOM Database
	    def room_version = "2.3.0"
	    implementation("androidx.room:room-runtime:$room_version")
	    annotationProcessor "androidx.room:room-compiler:$room_version"
	    kapt("androidx.room:room-compiler:$room_version")
	    implementation("androidx.room:room-ktx:$room_version")
	    testImplementation("androidx.room:room-testing:$room_version")


No código a seguir está um exemplo de um banco de dados, com uma entidade e um DAO:


Classe User do tipo data, que será nossa entity:

    @Entity
    data class User(
        @PrimaryKey val uid: Int,
        @ColumnInfo(name = "first_name") val firstName: String?,
        @ColumnInfo(name = "last_name") val lastName: String?
    )

  

Uma interface UserDao, que será nosso DAO:

    @Dao
    interface UserDao {
        @Query("SELECT * FROM user")
        fun getAll(): List<User>

        @Query("SELECT * FROM user WHERE uid IN (:userIds)")
        fun loadAllByIds(userIds: IntArray): List<User>

        @Query("SELECT * FROM user WHERE first_name LIKE :first AND " +
               "last_name LIKE :last LIMIT 1")
        fun findByName(first: String, last: String): User

        @Insert
        fun insertAll(vararg users: User)

        @Delete
        fun delete(user: User)
    }

  

Uma classe UserDatabase abstrata, que será o nosso Database:

    @Database(entities = arrayOf(User::class), version = 1)
    abstract class AppDatabase : RoomDatabase() {
        abstract fun userDao(): UserDao
    }

  

Para conseguir uma instância do banco de dados, basta usar o código a seguir:

    val db = Room.databaseBuilder(
                applicationContext,
                AppDatabase::class.java, "database-name"
            ).build()

  

OBS: perceba que as classes e interface, responsável pelo gerenciamento do ROOM, necessitam de suas determinadas anotações.


Aconselho ler a documentação oficial do android para um estudo mais aprofundado:

Room Database


Podem comentar qualquer dúvida e feedback, ou falar diretamente comigo no meu linkedin <3

0
1

Comentários (1)

2
Wellington Santos

Wellington Santos

20/07/2021 21:45

O artigo ficou bom, direto ao ponto. 👍

Mobile Developer | Kotlin | Java

Brasil