>>
>
>>488388>>
>
>
>
>
>>
>>
>>
>>>
Para aqueles que não sabem o que é o Android Jetpack então
Android Jetpack é uma coleção de componentes de software Android para facilitar o desenvolvimento de grandes aplicativos Android.
Vão ajudá-lo a
- Seguir as melhores práticas
- Livre você de escrever código boilerplate.
- Simplificar tarefas complexas, para que você possa se concentrar no código que você se importa.
Aqui está o vídeo do Android Developers Channel:
Agora vamos falar de Room
Room é uma biblioteca de persistência, parte do Android Jetpack.
Aqui está o vídeo do Android Developers Channel:
Room fornece uma camada de abstração sobre SQLite para permitir o acesso fluente ao banco de dados enquanto aproveita todo o poder do SQLite.
Room é agora considerado como uma melhor abordagem para a persistência de dados do que SQLiteDatabase. Ele facilita o trabalho com objetos SQLiteDatabase em sua aplicação, diminuindo a quantidade de código de boilerplate e verificando consultas SQL em tempo de compilação.
- Verificação em tempo de compilação de consultas SQL. cada @Query e @Entity é verificado em tempo de compilação, o que preserva sua aplicação de problemas de crash em tempo de execução e não apenas verifica a única sintaxe, mas também tabelas ausentes.
- Código da placa do spoiler
- Facilmente integrado com outros componentes da arquitetura (como LiveData)
Problemas maiores com o uso de SQLite são
- Não há verificação em tempo de compilação de consultas SQL brutas. Por exemplo, se você escrever uma consulta SQL com um nome de coluna errado que não existe no banco de dados real, então ele dará exceção durante o tempo de execução e você não poderá capturar este problema durante o tempo de compilação.
- Como seu esquema muda, você precisa atualizar as consultas SQL afetadas manualmente. Este processo pode ser demorado e sujeito a erros.
- É preciso usar muito código de boilerplate para converter entre consultas SQL e objetos de dados Java (POJO).
Room vs SQLite
Room é uma biblioteca ORM, Object Relational Mapping. Em outras palavras, a Sala irá mapear os objetos de nossa base de dados para objetos Java. Room fornece uma camada de abstração sobre SQLite para permitir acesso fluente ao banco de dados enquanto aproveita todo o poder da SQLite.
Diferença entre SQLite e a biblioteca de persistência Room:-
- No caso da SQLite, não há verificação em tempo de compilação de consultas a SQLite bruta. Mas no Room, há validação SQL em tempo de compilação.
- É preciso usar muito código de boilerplate para converter entre consultas SQL e objetos de dados Java. Mas, Room mapeia nossos objetos de banco de dados para objetos Java sem código boilerplate.
- Como seu esquema muda, você precisa atualizar as consultas SQL afetadas manualmente. Room resolve este problema.
- Room é construído para trabalhar com LiveData e RxJava para observação de dados, enquanto SQLite não o faz.
Componentes da Sala DB
A Sala tem três componentes principais da Sala DB :
- Entidade
- Dao
- Base de dados
Entidade
Representa uma tabela dentro da base de dados. Sala cria uma tabela para cada classe que tem @Entity annotação, os campos na classe correspondem a colunas na tabela. Portanto, as classes de entidades tendem a ser pequenas classes de modelos que não contêm nenhuma lógica.
Entidades anotações
Antes de começarmos a modelar nossas entidades, precisamos conhecer algumas anotações úteis e seus atributos.
@Entity – cada classe de modelo com esta anotação terá uma tabela de mapeamento em DB
- foreignKeys – nomes de chaves estrangeiras
- indices – lista de indicações na tabela
- primaryKeys – nomes de chaves primárias de entidades
- tableName
@PrimaryKey – como o seu nome indica, esta anotação aponta a chave primária da entidade. autoGenerate – se definido como true, então SQLite estará gerando um id único para a coluna
@PrimaryKey(autoGenerate = true)
@ColumnInfo – permite especificar informação personalizada sobre a coluna
@ColumnInfo(name = "column_name")
@Ignore – campo não será persistido por Room
@Embed – campos aninhados podem ser referenciados diretamente nas consultas SQL.
Dao
DAOs são responsáveis por definir os métodos que acessam a base de dados. No SQLite inicial, usamos os objectos Cursor. Com Room, não precisamos de todo o código Cursor relacionado e podemos simplesmente definir nossas consultas usando anotações na classe.Dao
Base de dados
Contém o suporte do banco de dados e serve como o principal ponto de acesso para a conexão subjacente aos dados relacionais persistidos de seu aplicativo.
Para criar um banco de dados precisamos definir uma classe abstrata que se estenda por RoomDatabase. Esta classe é anotada com @Database, lista as entidades contidas no banco de dados, e os DAOs que as acessam.
A classe que é anotada com @Database deve satisfazer as seguintes condições:
- Ser uma classe abstrata que se estende por
RoomDatabase. - Inclua a lista de entidades associadas ao banco de dados dentro da anotação.
- Contenha um método abstrato que tenha 0 argumentos e retorne a classe que é anotada com
@Dao.
Em tempo de execução, você pode adquirir uma instância de Database chamando Room.databaseBuilder() ou Room.inMemoryDatabaseBuilder().
Passo 1: Adicione as dependências de Gradle
- Para adicioná-lo ao seu projeto, abra o arquivo de nível de projeto
build.gradlee adicione a linha destacada como mostrado abaixo:
2. Abra o arquivo build.gradle para sua aplicação ou módulo e adicione dependências:
Passo 2: Crie uma classe de modelo
Room cria uma tabela para cada classe anotada com @Entity; os campos na classe correspondem a colunas na tabela. Portanto, as classes de entidade tendem a ser pequenas classes de modelo que não contêm nenhuma lógica. A nossa classe Person representa o modelo para os dados no banco de dados. Então vamos atualizá-lo para dizer ao Room que ele deve criar uma tabela baseada nesta classe:
- Anotar a classe com
@Entitye usar a propriedadetableNamepara definir o nome da tabela. - Configurar a chave primária adicionando a anotação
@PrimaryKeyaos campos corretos – no nosso caso, este é o ID do Usuário. - Configurar o nome das colunas para os campos da classe usando a anotação
@ColumnInfo(name = "column_name"). Sinta-se livre para pular este passo se seus campos já tiverem o nome correto da coluna. - Se vários construtores forem adequados, adicione a anotação
@Ignorepara dizer ao Room qual deve ser usado e qual não.
Passo 3: Criar Objetos de Acesso aos Dados (DAOs)
DAOs são responsáveis por definir os métodos que acessam a base de dados.
Para criar um DAO precisamos criar uma interface e anotar com @Dao .
Passo 4: Criar o banco de dados
Para criar um banco de dados precisamos definir uma classe abstrata que se estenda RoomDatabase. Esta classe é anotada com @Database, lista as entidades contidas no banco de dados e os DAOs que as acessam.
Passo 4: Gerenciando os dados
Para gerenciar os dados, antes de mais nada, precisamos criar uma instância do banco de dados.
Então podemos inserir apagar e atualizar a base de dados.
Certifique-se de que toda a operação deve ser executada em uma thread diferente. No meu caso eu uso Executers (ver aqui)
Query:
Inserir:
Delete:
>
Update:
Executar com o Executor
Eu também liguei um repo se você precisar ver o exemplo de Room Database.