Uso de la base de datos Room en Android Jetpack (Kotlin+Room)

1. Introducción básica

La biblioteca de persistencia de Room proporciona una capa de abstracción sobre SQLite para permitir un acceso fluido a la base de datos mientras se aprovecha al máximo el poder de SQLite. En concreto, Room cuenta con las siguientes ventajas:

• Validación en tiempo de compilación para consultas SQL.
• Anotaciones útiles que minimizan el código modelo repetitivo y propenso a errores.
• Ruta de migración de base de datos simplificada.

La habitación consta de tres componentes principales:

• La clase de base de datos (DataBase) se utiliza para guardar la base de datos y servir como punto de acceso principal para la conexión subyacente de los datos persistentes de la aplicación.
• Una entidad de datos (Entidad) se utiliza para representar una tabla en una base de datos de aplicación.
• Objetos de acceso a datos (DAO) , que proporcionan métodos que su aplicación puede usar para consultar, actualizar, insertar y eliminar datos en la base de datos.

2. Explicación detallada

 1. Introducir dependencias. Introducir dependencias en dependencias en build.gradle en la carpeta de la aplicación. Tenga en cuenta que es necesario agregar el id 'kotlin-kapt', kapt, y se informará un error si no se agrega.

plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    id 'kotlin-kapt'
}

    implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'
    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.4.0'
    implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.4.0'

    def room_version = "2.5.0"

    implementation "androidx.room:room-runtime:$room_version"
    kapt "androidx.room:room-compiler:$room_version"
    implementation("androidx.room:room-rxjava2:$room_version")

    // optional - RxJava3 support for Room
    implementation("androidx.room:room-rxjava3:$room_version")

    // optional - Guava support for Room, including Optional and ListenableFuture
    implementation("androidx.room:room-guava:$room_version")

    // optional - Test helpers
    testImplementation("androidx.room:room-testing:$room_version")

    // optional - Paging 3 Integration
    implementation("androidx.room:room-paging:$room_version")

2. @Entity , use Room para definir una entidad de datos Usuario (una clase con anotación de Entidad), una tabla de Entidad consta de una clave principal y una o más columnas, cada instancia en Usuario representa una fila en la tabla de Usuario, seguida de tableName es el nombre de la tabla.Si no se especifica ningún nombre de tabla, el nombre de la clase se usará como el nombre de la tabla de datos de forma predeterminada. Room usa el nombre del campo como el nombre de la columna de forma predeterminada. Si necesita cambiarlo, use la anotación @ColumnInfo para establecer el atributo de nombre (nombre de la columna).

/**
 * @PrimaryKey(autoGenerate = true)表示主键自增，参数autoGenerate表示主键可以由数据库自动生成
 * @ColumnInfo(name = "id"）表示列的名字为id
 * @Ignore表示会忽略这个字段，不进行记录
 */
@Entity(tableName = "user")
data class User(
    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name = "id")
    var id: Int = 0,

    @ColumnInfo(name = "userNum")
    val userNum: String,
    @ColumnInfo(name = "userPwd")
    val userPwd: String? = null,
    @ColumnInfo(name = "sex")
    val sex: String? = null,
    @ColumnInfo(name = "age")
    val age: Int ,
    @ColumnInfo(name = "school")
    val school: String? = null,
)

3. @Dao, use la anotación @Dao para definir una interfaz BaseDao, agregue métodos básicos de inserción, eliminación y modificación, y luego defina un UserDao para ampliar la interfaz BaseDao y agregue los métodos necesarios.

• @Insert , Insert, puede definir un método que inserta sus parámetros en la tabla correspondiente en la base de datos
• @Delete , delete, puede definir un método para eliminar una fila específica de una tabla de base de datos
• @Update , modificado, puede definir un método para actualizar una fila específica en una tabla de base de datos
• @Consulta, consulta, puede consultar datos específicos de la base de datos de la aplicación para operaciones más complejas de inserción, eliminación y actualización

@Dao
interface BaseDao<T> {
    @Insert
    fun insert(bean: T)

    @Insert
    fun insertAll(bean: T)

    @Delete
    fun delete(bean:T)

    @Update
    fun update(bean: T)

}

@Dao
interface UserDao : BaseDao<User> {

    @Query("select * from user where userNum = :userNum")
    fun getByNum(userNum: String): User?

    /**
     * 查询表里所有数据
     */
    @Query("select * from user")
    fun getAllUser(): User?

    /**
     * 根据字段删除记录
     */
    @Query("delete from user where userNum = :userNum")
    fun deleteByNum(userNum: String)


    /**
     * 修改指定用户的密码
     */
    @Query("update user set userPwd =:userPwd where userNum =:userNum")
    fun updatePwd(userNum: String, userPwd: String)

}

 4. @DataBase, defina la clase MyDataBase donde el usuario guarda la base de datos y defina la configuración de la base de datos. La clase @DateBase debe cumplir las siguientes condiciones:

• Debe tener la anotación DataBase, que debe enumerar la matriz de clases de entidad asociadas con la base de datos.
• Debe ser una clase abstracta para extender RoomDataBase
• Para cada clase DAO asociada con la base de datos, se debe definir un método abstracto con cero parámetros en la clase y devolver una instancia de la clase DAO.

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

    abstract fun userDao(): UserDao


    companion object {
        val instance = Room.databaseBuilder(appContext, MyDataBase::class.java, "chat_db").build()
    }
}

5. Llamar a MainActivity

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        insertData()
        updateData()
        deleteData()
        queryData()
    }

    /**
     * 插入一条数据
     */
    private fun insertData() {
        lifecycleScope.launch(Dispatchers.IO) {
            MyDataBase.instance.userDao().insert(
                User(
                    userNum = "GSHD",
                    userPwd = "1231343",
                    sex = "女",
                    age = 18,
                    school = "XXXXX"
                )
            )
        }
    }

    /**
     * 查询 userNum = "GSHD" 的记录
     */
    private fun queryData() {
        lifecycleScope.launch(Dispatchers.IO) {
            MyDataBase.instance.userDao().getByNum(
                userNum = "GSHD"
            )
        }
    }

    /**
     * 修改 userNum = "GSHD" 的userPwd
     */
    private fun updateData() {
        lifecycleScope.launch(Dispatchers.IO) {
            MyDataBase.instance.userDao().updatePwd(
                userNum = "GSHD",
                userPwd = "111111",
            )
        }
    }

    /**
     * 删除 userNum = "GSHD" 的数据
     */
    private fun deleteData() {
        lifecycleScope.launch(Dispatchers.IO) {
            MyDataBase.instance.userDao().deleteByNum(userNum = "GSHD")
        }
    }
}