Persistência de dados no Android com ROOM #1 — Criando Entidades

Photo by Andy Holmes on Unsplash

Persistir informações é necessário em qualquer aplicação, e por isso o Framework Android desde sua primeira versão já contava com uma solução para o problema utilizando o banco de dados SQLite .

No entanto, a API contida no pacote android.database.sqlite pode ser vista como de baixo nível, e requer uma sintaxe muito longa até mesmo para tarefas simples como inserção no banco de dados, por exemplo.

Por essa razão, os “componentes de arquitetura do android”, parte integrante do Android JetPack contam com o Room, uma nova abstração em torno da persistência de dados que conta com uma série de classes bem mais simples e intuitivas de serem utilizadas.

Esse é o primeiro de uma série de artigos explorando as funcionalidades dessa biblioteca.

Nesse artigo você aprenderá como configurar as “Entidades” de persistência do Room. Vamos lá?!

Configurações Básicas

Antes de mais nada é necessário que a biblioteca seja adicionada ao arquivo build.gradle do seu projeto:

implementation "android.arch.persistence.room:runtime:$room_version"
kapt "android.arch.persistence.room:compiler:$room_version"

Lembre-se de modificar o $room_version para a versão mais recente da biblioteca, que pode ser encontrada aqui.

Obs.: Caso já esteja utilizando a nova estrutura de pacotes androidx.* adicione as dependências abaixo ao invés:

implementation 'androidx.room:room-runtime:$room_version'
kapt 'androidx.room:room-compiler:$room_version'

Definindo um Model

O Room permitirá que você crie um model para representar a estrutura da tabela que será automaticamente criada. Para isso vamos criar um data class com os atributos necessários:

data class Postagem(
    val id: Int,
    val titulo: String,
    val conteudo: String,
    val nota: Int
)

Adicione anotações — @Entity && @PrimaryKey

Uma vez que sua classe estiver definida, o primeiro passo é adicionar a anotação @Entity à classe:

@Entity
data class Postagem( ... )

Isso fará com que o processador de anotações do Room consiga identificar que essa classe deve ser persistida.

Igualmente importante é anotar um dos campos dessa classe com @PrimaryKey. Como o própio nome indica, isso fará com que esse atributo se torne a chave primária da entidade.

@Entity
data class Postagem(
    @PrimaryKey(autoGenerate = true)
    val id: Int, ...
)

O atributo “autoGenerate” é opcional nessa anotação, então só o defina como true caso queira que o Room faça o controle automático do id quando um novo registro estiver sendo adicionado no banco de dados.

@ColumnInfo

A biblioteca conta ainda com a anotação @ColumnInfo. Essa anotação permite que sejam repassadas outras informações em relação ao campo anotado. Caso queira que a coluna gerada no banco de dados conte com um nome diferente daquele definido na classe, por exemplo, você pode usar o atributo “name” presente nessa anotação:

@Entity
data class Postagem(
    ...
    @ColumnInfo(name = "aplausos")
    val nota: Int
)

Você também pode adicionar atributos à sua classe que não serão persistidos no banco de dados. Para isso é necessário adicionar a anotação @Ignore.

@Entity
data class Postagem(
    ...
    @Ignore
    val qtdComentarios: Int
)

@Embedded

Outro detalhe super interessante é a possibilidade de se utilizar a composição para modelar sua tabela; para se adicionar informações referentes ao autor da postagem, basta definir um novo data class:

data class Autor(
    val nome: String,
    val perfil: String
)

E então criar um novo atributo na classe Postagem com anotação @Embedded:

@Entity
data class Postagem(
    ...
    @Embedded
    val autor: Autor
)

Isso fará com que todos os campos contidos na classe Autor sejam acrescidos à tabela postagem, o que dá maior flexibilidade e desacopla a sua classe model da estrutura do banco de dados.

@TypeConverters

Por fim, existem ainda situações em que o tipo de dado utilizado na classe difere daquele a ser persistido no banco de dados. Para essas situações você pode criar um TypeConverter e associá-lo ao campo que deseja.

Criar um TypeConverter é muito simples, basta criar uma classe com dois métodos com apenas um parâmetro e que não retornem Unit, conforme o exemplo abaixo:

class ReferenciaConverter {
    @TypeConverter
    fun toDatabase(ref: Referencia): String {
        return "${ref.autor}.${ref.obra}"
    }

    @TypeConverter
    fun fromDatabase(ref: String): Referencia{
        val parts = ref.split(".")

        return Referencia(parts[0], parts[1])
    }
}

Para que o Room saiba da existência desse TypeConverter, utilizamos a anotação @TypeConverters, que pode ser utilizada em diferentes escopos. Caso adicionada à classe, por exemplo, todos os atributos compatíveis serão afetados; se adicionada a um atributo da classe, apenas aquele atributo em específico será afetado.

@Entity
data class Postagem(
    ...
    @TypeConverters(ReferenciaConverter::class)
    val referencia: Referencia
)

#Done

E é isso. Com essas anotações sua classe já está preparada para ser persistida utilizando o Room. A versão final da entidade ficaria assim:

Caso tenha gostado dessa postagem, não se esqueça de deixar alguns aplausos. Se quiser saber um pouco mais sobre essa biblioteca, é só me seguir para ser notificado sobre as próximas postagens.

Até a próxima.