Room简单实操-易微帮

1. Room介绍，直接Copy官网介绍：

Room 持久性库在 SQLite 上提供了一个抽象层，以便在充分利用 SQLite 的强大功能的同时，能够流畅地访问数据库。具体来说，Room 具有以下优势：

提供针对 SQL 查询的编译时验证。
提供方便注解，可最大限度减少重复和容易出错的样板代码。
简化了数据库迁移路径。

总结就是简化了操作数据库的难度，相对于直接操作Sqlite Api。

2. Room主要组件，包含如下三个部分，内容直接Copy官网：

数据库类（Room Database），用于保存数据库并作为应用持久性数据底层连接的主要访问点 -- 数据库类为应用提供与该数据库关联的 DAO 的实例。
数据实体（Entities），用于表示应用的数据库中的表。
数据访问对象 (Data Access Objects)，提供在数据库中查询、更新、插入和删除数据的方法。

如果链接访问不了，直接将前缀修改为中文官网的域名（https://developer.android.google.cn/）

Room架构示意图

引入依赖库，参考Android版本依赖Version catalog

// Room
implementation(libs.room.runtime)
annotationProcessor(libs.room.compiler)
// To use Kotlin Symbol Processing (KSP)
ksp(libs.room.compiler)
// optional - Kotlin Extensions and Coroutines support for Room
implementation(libs.room.ktx)
// 测试数据库
testImplementation(libs.room.testing)

一、单表

1.1 数据实体

每个 Room 实体定义为带有 @Entity 注解的类。Room 实体包含数据库中相应表中的每一列的字段，包括构成主键的一个或多个列。

/**
 * 用户表对象.
 *
 * @param id
 * 如果您在定义实体类时将一个字段标记为 @PrimaryKey(autoGenerate = true)，
 * 并且在插入记录时不为该字段赋值，Room 将会自动生成一个唯一的值并填充到该字段中。
 */
@Entity
class User(
    /**
     * 主键字段不能为空，并且必须具有唯一性，以确保每条记录都可以唯一标识.
     *
     * autoGenerate = true之后我们将主键默认设置为空或者0，
     * room也会自动自动生成一个唯一的值并填充到该字段中，
     * 但是不建议设置为空，建议默认设置为0。
     */
    @PrimaryKey(autoGenerate = true)
    val id: Long = 0,
    val name: String,
    val age: Int = 0,
    @GenderType
    val gender: Int = GenderType.MALE
) {
    override fun toString(): String {
        return "User(id=$id, name='$name', age=$age, gender=$gender)"
    }
}

注意：

1. 要保留某个字段，Room 必须拥有该字段的访问权限。

2. 可以通过将某个字段设为公开或为其提供 getter 和 setter 方法，确保 Room 能够访问该字段。

1.1.1 自定义表明和列名

默认情况下，Room 将类名称用作数据库表名称。如果希望表具有不同的名称，请设置 @Entity 注解的 tableName 属性。
Room 默认使用字段名称作为数据库中的列名称。如果您希望列具有不同的名称，请将 @ColumnInfo 注解添加到该字段并设置 name 属性。

@Entity(tableName = "users")
class User(
    @PrimaryKey(autoGenerate = true)
    val id: Long = 0,
    @ColumnInfo(name = "uaerName")
    val name: String,
    val age: Int = 0,
    @GenderType
    val gender: Int = GenderType.MALE
)

注意：SQLite 中的表和列名称不区分大小写。

1.1.2 主键介绍

在 Room 数据库中，主键通常定义为长整型（long）是因为长整型提供了更大的范围，可以容纳更多的唯一标识符。这种做法是出于以下几个考虑：

唯一标识符范围：长整型可以表示更大范围的整数值，最大可达到 2^63 - 1，相比于整型（int）的最大值 2^31 - 1，长整型提供了更大的唯一标识符范围，可以满足大多数情况下的需求。
避免溢出：使用长整型可以避免标识符溢出的问题。长整型的范围比较大，即使在较长时间内也不太可能出现溢出的情况。
与数据库兼容性：在许多数据库系统中，主键通常被定义为长整型或者类似的数据类型（如 BIGINT），这样可以确保 Room 数据库与其他数据库系统的兼容性。

@PrimaryKey(autoGenerate = true)
val id: Long = 0

1. 如果您在定义实体类时将一个字段标记为 @PrimaryKey(autoGenerate = true)，
并且在插入记录时不为该字段赋值，Room 将会自动生成一个唯一的值并填充到该字段中。

2. 主键字段不能为空，并且必须具有唯一性，以确保每条记录都可以唯一标识.

3. autoGenerate = true之后我们将主键默认设置为空或者0，room也会自动自动生成一个唯一的值并填充到该字段中，但是不建议设置为空，建议默认设置为0。

1.1.3 忽略字段

默认Room 会为实体中定义的每个字段创建一个列。如果某个实体中有不想保留的字段，则可以使用 @Ignore 为这些字段添加注解

@Entity
class User(
    @PrimaryKey(autoGenerate = true)
    val id: Long = 0,
    val name: String,
    val age: Int = 0,
    @GenderType
    val gender: Int = GenderType.MALE,
    @Ignore val headBm: Bitmap?
)

1.2 数据访问对象 (DAO)

对象创建须知

1. 介绍

将每个 DAO 定义为一个接口或一个抽象类。通常应使用接口。

无论哪种形式，都必须始终使用 @Dao 为创建 DAO 对象添加注解。DAO 不具有属性，但它们定义了一个或多个方法，可用于与应用数据库中的数据进行交互。

两种类型的 DAO 方法可以定义数据库交互：

在不编写任何 SQL 代码的情况下插入、更新和删除数据库中的行的便捷方法。
编写自己的 SQL 查询以与数据库进行交互的查询方法。

2. 总结：

1. 对象必须是接口或者抽象类

2. 对象必须使用@DAO注解进行修饰

3. 增、删、改不需要使用任何SQL语句，直接使用@Insert、@Delete、@Update注解方法即可

4. 查询方法直接编写SQL语句就能使用，例如：@Query("SELECT *FROM user")

1.2.1 插入

使用 @Insert 注解，您可以定义将其参数插入数据库中的相应表的方法，可以同时插入一个或多个对象。

1. 插入单个对象，参数必须是具体的`@Entity数据库表，例如例子中的User表`

@Insert 注解的方法每个参数都必须是一个带有 @Entity 注解的 Room 数据实体类实例。
如果 @Insert 方法接收到单个参数，则可返回一个 long 值，这是插入项的新 rowId。

2. 插入多个对象，参数必须是具体的`@Entity数据库表集合或者数组`

数据实体类实例的集合，而且每个参数都指向一个数据库。调用 @Insert 方法时，Room 会将每个传递的实体实例插入到相应的数据库表中。
如果参数是数组或集合，则可改为返回由 long 值组成的数组或集合，并且每个值都作为其中一个插入项的 rowId。

想了解如何返回 rowId 值，请参阅 @Insert 注解的参考文档以及 rowid 表的 SQLite 文档。

/**
 * 插入多个用户数据（碰到冲突就替换为最新的）.
 *
 * @param users 用户数据（可变对象）
 * @return 插入数据ID集合
 */
@Insert(onConflict = OnConflictStrategy.REPLACE)
fun insertAll(vararg users: User): List<Long>

/**
 * 插入用户集合数据.
 *
 * @param users 用户数据集合
 * @return 插入数据ID集合
 */
@Insert(onConflict = OnConflictStrategy.REPLACE)
fun insertAll(users: List<User>): List<Long>

OnConflictStrategy常量介绍：

NONE：没有冲突处理策略，事务将会回滚。
REPLACE：替换旧数据并继续事务。
~~ROLLBACK：事务回滚。已弃用，请使用 ABORT。~~
ABORT：事务回滚。
~~FAIL：事务失败。已弃用，请使用 ABORT。~~
IGNORE：忽略冲突。

1.2.2 更新

更新方法直接用@Update修饰，ROOM支持更新单个对象（单行）、集合对象（多行）、数组对象（查看源码：EntityDeletionOrUpdateAdapter）。与 @Insert 方法一样，@Update 方法接受数据实体实例作为参数。

/**
 * 更新用户数据.
 *
 * @param users 用户数据（可变对象）
 * @return 更新数据ID集合
 */
@Update
fun update(vararg users: User)

Room 使用主键（就是User表中的id）将传递的实体实例与数据库中的行进行匹配。如果没有具有相同主键的行，Room 不会进行任何更改。

@Update 方法可以选择性地返回 int 值，指示成功更新的行数。

1.2.3 删除

删除方法直接用@Delete修饰，ROOM支持删除单个对象、集合对象、数组对象（查看源码：EntityDeletionOrUpdateAdapter）

/**
 * 删除多个用户数据.
 *
 * @param users 用户数据（可变对象）
 */
@Delete
fun delete(vararg users: User)

/**
 * 删除用户集合.
 *
 * @param users 用户集合
 */
@Delete
fun delete(users: List<User>)

从源码中我们可以看到，ROOM中删除和更新调用的是相同的方法。

Room 使用主键将传递的实体实例与数据库中的行进行匹配。如果没有具有相同主键的行，Room 不会进行任何更改。

@Delete 方法可以选择性地返回 int 值，指示成功删除的行数。

1.2.4 查询

Room的查询主要是写Sql语句，只要是对Sql语句熟悉的，写起来就是得心应手。

如下常用的查询方法，使用如下注解在方法上：@Query("查询的SQL")

1. 查询数据库中所有对象

/**
 * 查询所有用户数据.
 *
 * @return 用户数据集合
 */
@Query("SELECT *FROM user")
fun getAll(): List<User>

2. 查询数据库表列的子集

在数据库查询的时候，我们偶尔不需要查询全部的列，例如此例中的用户表我们可能只需要查询用户ID、用户名。

借助 Room可以从任何查询返回简单对象，前提是将一组结果列映射到需要查询的简单的对象。

举例：

1. 创建需要的列的对象

/**
 * 偶尔我们只是需要查询用户数据的列子集。
 * 借助 Room，可以从任何查询返回简单对象，前提是可以将一组结果列映射到返回的对象。
 */
data class UserTuple(
    val id: Long,
    val name: String
)

2. 查询指定子集

/**
 * 查询用户数据的列子集.
 *
 * @return 返回用户数据列子集
 */
@Query("SELECT id, name FROM user")
fun getSimpleAll(): List<UserTuple>

3. 将简单参数传递给查询，使用指定参数进行查询

/**
 * 通过用户ID查询用户数据.
 *
 * @param id 用户ID
 * @return 用户数据
 */
@Query("SELECT *FROM user WHERE id = :id")
fun getById(id: Int): User

/**
 * 通过用户名查询用户数据（没啥意义，用户名可以重名，查询的是最近的用户）.
 *
 * @param name 用户名
 * @return 用户数据
 */
@Query("SELECT *FROM user WHERE name LIKE :name LIMIT 1")
fun findByName(name: String): User

/**
 * 通过用户名查询用户数据集合.
 *
 * @param name 用户名
 * @return 用户数据集合
 */
@Query("SELECT *FROM user WHERE name LIKE :name ORDER BY id DESC")
fun findAllByName(name: String): List<User>

/**
 * 查询某一年龄段用户数据.
 *
 * @param minAge 最小年龄
 * @param maxAge 最大年龄
 * @return 用户数据集合
 */
@Query("SELECT *FROM user WHERE age BETWEEN :minAge AND :maxAge")
fun getAllBetweenAges(minAge: Int, maxAge: Int): List<User>

4. 将一组参数传递给查询，查询指定组查询条件的数据

/**
 * 通过用户ID查询用户数据.
 *
 * @param userIds 用户ID集合
 * @return 用户数据集合
 */
@Query("SELECT * FROM user WHERE id IN (:userIds)")
fun getAllByIds(userIds: IntArray): List<User>

1.2.5 完整DAO对象

增、删、改、查完整的DAO对象代码：

/**
 * 用户表数据库操作对象.
 */
@Dao
interface UserDao {

    /**
     * 插入多个用户数据（碰到冲突就替换为最新的）.
     *
     * @param users 用户数据（可变对象）
     * @return 插入数据ID集合
     */
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insertAll(vararg users: User): List<Long>

    /**
     * 插入用户集合数据.
     *
     * @param users 用户数据集合
     * @return 插入数据ID集合
     */
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insertAll(users: List<User>): List<Long>

    /**
     * 删除多个用户数据.
     *
     * @param users 用户数据（可变对象）
     */
    @Delete
    fun delete(vararg users: User)

    /**
     * 删除用户集合.
     *
     * @param users 用户集合
     */
    @Delete
    fun delete(users: List<User>)

    /**
     * 更新用户数据.
     *
     * @param users 用户数据（可变对象）
     * @return 更新数据ID集合
     */
    @Update
    fun update(vararg users: User)

    /**
     * 查询所有用户数据.
     *
     * @return 用户数据集合
     */
    @Query("SELECT *FROM user")
    fun getAll(): List<User>

    /**
     * 查询用户数据的列子集.
     *
     * @return 返回用户数据列子集
     */
    @Query("SELECT id, name FROM user")
    fun getSimpleAll(): List<UserTuple>

    /**
     * 通过用户ID查询用户数据.
     *
     * @param id 用户ID
     * @return 用户数据
     */
    @Query("SELECT *FROM user WHERE id = :id")
    fun getById(id: Int): User

    /**
     * 通过用户ID查询用户数据.
     *
     * @param userIds 用户ID集合
     * @return 用户数据集合
     */
    @Query("SELECT * FROM user WHERE id IN (:userIds)")
    fun getAllByIds(userIds: IntArray): List<User>

    /**
     * 通过用户名查询用户数据（没啥意义，用户名可以重名，查询的是最近的用户）.
     *
     * @param name 用户名
     * @return 用户数据
     */
    @Query("SELECT *FROM user WHERE name LIKE :name LIMIT 1")
    fun findByName(name: String): User

    /**
     * 通过用户名查询用户数据集合.
     *
     * @param name 用户名
     * @return 用户数据集合
     */
    @Query("SELECT *FROM user WHERE name LIKE :name ORDER BY id DESC")
    fun findAllByName(name: String): List<User>

    /**
     * 查询某一年龄段用户数据.
     *
     * @param minAge 最小年龄
     * @param maxAge 最大年龄
     * @return 用户数据集合
     */
    @Query("SELECT *FROM user WHERE age BETWEEN :minAge AND :maxAge")
    fun getAllBetweenAges(minAge: Int, maxAge: Int): List<User>

}

1.3 数据库对象

数据库类必须满足以下条件：

必须带有 @Database 注解，该注解包含列出所有与数据库关联的数据实体的 entities 数组 -- 可以定义N多表，只需要放在entities = [User::class, Work::class]。
必须是一个抽象类，用于扩展 RoomDatabase。
对于与数据库关联的每个 DAO 类，数据库类必须定义一个具有零参数的抽象方法，并返回 DAO 类的实例。

/**
 * 数据库.
 */
@Database(entities = [User::class], version = 1)
abstract class TestDataBase : RoomDatabase() {
    /**
     * 用户表操作类.
     */
    abstract fun userDao(): UserDao
}

注意：

1. 如果您的应用在单个进程中运行，在实例化 TestDataBase 对象时应遵循单例设计模式。每个 RoomDatabase 实例的成本相当高，而您几乎不需要在单个进程中访问多个实例。

2. 如果应用在多个进程中运行，请在数据库构建器调用中包含 enableMultiInstanceInvalidation()。这样，如果您在每个进程中都有一个 TestDataBase 实例，可以在一个进程中使共享数据库文件失效，并且这种失效会自动传播到其他进程中 TestDataBase 的实例。

1.4 构建数据库实例，进行数据库操作

@RunWith(AndroidJUnit4::class)
class RoomTest {
    companion object {
        private const val TAG = "RoomTest"
    }

    private lateinit var mDb: TestDataBase
    private lateinit var mUserDao: UserDao
    private lateinit var mWorkDao: WorkDao
    private lateinit var mUserWorkDao: UserWorkDao

    @Before
    fun createDb() {
        val context = ApplicationProvider.getApplicationContext<Context>()
        mDb = Room.databaseBuilder(
            context,
            TestDataBase::class.java,
            "pp-test-database"
        ).build()
        mUserDao = mDb.userDao()
        mWorkDao = mDb.workDao()
        mUserWorkDao = mDb.userWorkDao()
    }

    @After
    fun closeDb() {
        mDb.close()
    }

    @Test
    fun testInsert() {
        mUserDao.insertAll(
            User(name = "刘亦菲", age = 20, gender = GenderType.FEMALE),
            User(name = "唐嫣", age = 30, gender = GenderType.FEMALE)
        ).run {
            assertEquals(2, this.size)
            mUserDao.getAll().run {
                for ((index, value ) in this.withIndex()) {
                    // 更新
                    // mUserDao.update(User(id = value.id, name = "修改$index", age = value.age, gender = value.gender))
                    // 插入数据
                    mWorkDao.insertAll(Work(introduce = "打工人$index", userId = value.id))
                }

                // 删除
                // mUserDao.delete(this[0])
            }



            mUserWorkDao.getAllUserWork().run {
                for ((index, value) in this.withIndex()) {
                    "index=$index, value=$value".logI(TAG)
                }
            }
        }
    }
}

Room操作单表已经介绍完成，按照上述操作即可成功使用room操作Sqlite数据库

二、多表

2.1 定义对象之间的关系

由于 SQLite 是关系型数据库，因此您可以定义各个实体之间的关系。虽然大多数对象关系映射库都允许实体对象相互引用，但 Room 明确禁止这样做。

原因：了解 Room 为何不允许对象引用

Room 中，可以通过两种方式定义和查询实体之间的关系：

使用具有嵌入式对象的中间数据类
使用具有多重映射返回值类型的关系型查询方法。

2.1.1 中间数据类

创建Work工作类对象

@Entity(
    foreignKeys = [ForeignKey(
        entity = User::class,
        parentColumns = arrayOf("id"),
        childColumns = arrayOf("userId"),
        onDelete = ForeignKey.CASCADE
    )]
)
data class Work(
    @PrimaryKey(autoGenerate = true)
    val id: Long = 0,
    val introduce: String,
    /**
     * 外键，对应用户表的id.
     */
    val userId: Long
) {
    override fun toString(): String {
        return "Work(id=$id, introduce='$introduce', userId=$userId)"
    }
}

在 Room 中，@ForeignKey 注解用于定义外键约束，这些约束用于确保数据的完整性和一致性。使用外键约束可以建立表与表之间的关联关系，从而实现数据的引用完整性。

外键约束的主要作用包括：

维护关联关系：通过外键约束，您可以在一个表中引用另一个表中的数据。这样可以建立表与表之间的关联关系，使得数据之间的关系更加清晰明确。
确保引用完整性：外键约束可以确保在引用另一个表中的数据时，被引用的数据确实存在。这样可以避免出现引用无效数据的情况，保证了数据的完整性。
实现级联操作：通过外键约束，可以实现级联操作，例如在删除或更新父表中的数据时，自动删除或更新子表中相关联的数据。这样可以保持数据之间的一致性。

1. 定义一对一关系

两个实体之间的一对一关系是指：父实体的每个实例恰好对应于子实体的 1 个实例，反之亦然。

例子：

一个用户只有一份工作，每个工作只能有一个用户。因此User尸体和Work实体之间就是一对一的关系。
如需定义一对一关系，为两个实体分别创建一个类。其中一个实体必须包含一个变量，且该变量是对另一个实体的主键的引用。

上述例子中User和Work实体，work表的userId对应的就是User表的id，重新copy一份如下

@Entity
class User(
    @PrimaryKey(autoGenerate = true)
    val id: Long = 0,
    val name: String,
    val age: Int = 0,
    @GenderType
    val gender: Int = GenderType.MALE
) 


data class Work(
    @PrimaryKey(autoGenerate = true)
    val id: Long = 0,
    val introduce: String,
    /**
     * 外键，对应用户表的id.
     */
    val userId: Long
)

需要创建一个新的数据类，其中每个实例都包含父实体的一个实例和与之对应的子实体实例。
使用 @Embedded 注释表示要分解为表格中的子字段的对象，父实体。将 @Relation 注释添加到子实体的实例，同时将 parentColumn 设置为父实体主键列的名称，并将 entityColumn 设置为引用父实体主键的子实体列的名称。

/**
 * 用户和对应工作数据.
 *
 * 一对一的关系
 */
data class UserWork(
    @Embedded
    val user: User,
    @Relation(
        parentColumn = "id",
        entityColumn = "userId"
    )
    val work: Work
) {
    override fun toString(): String {
        return "UserWork(user=$user, work=$work)"
    }
}

向 DAO 类添加一个方法，用于返回将父实体与子实体配对的数据类的所有实例。该方法需要 Room 运行两次查询，因此应向该方法添加 @Transaction 注释，以确保整个操作以原子方式执行。

/**
 * 用户和对应工作表数据库操作对象.
 */
@Dao
interface UserWorkDao {
    /**
     * 查询用户和用户工作数据.
     *
     * @return 用户和用户工作数据集合
     */
    @Transaction
    @Query("SELECT *FROM user")
    fun getAllUserWork(): List<UserWork>

}

2. 定义一对多关系

父实体的每个实例对应于子实体的零个或多个实例，但子实体的每个实例只能恰好对应于父实体的一个实例。

定义一对多关系，需要为这两个实体分别创建一个类。与一对一关系一样，子实体必须包含一个变量，且该变量是对父实体的主键的引用。
将 @Relation 注释添加到子实体的实例，同时将 parentColumn 设置为父实体主键列的名称，并将 entityColumn 设置为引用父实体主键的子实体列的名称。

/**
 * 用户和对应工作数据.
 *
 * 一对多的关系
 */
class UserWorkList(
    @Embedded
    val user: User,
    @Relation(
        parentColumn = "id",
        entityColumn = "userId"
    )
    val workList: MutableList<Work>
) {
    override fun toString(): String {
        return "UserWorkList(user=$user, workList=$workList)"
    }
}

/**
 * 用户和对应工作表数据库操作对象.
 */
@Dao
interface UserWorkDao {
    

    /**
     * 查询用户和用户工作数据.
     *
     * @return 用户和用户工作数据集合
     */
    @Transaction
    @Query("SELECT *FROM user")
    fun getUserWithWorkList(): List<UserWorkList>
}

3. 定义多对多关系

两个实体之间的多对多关系是指：父实体的每个实例对应于子实体的零个或多个实例，反之亦然。

例子：

每个用户表都可以包含多个计划，每个计划都可以包含在多个用户表中。因此，User 实体和 Work 实体之间存在多对多关系。
如需定义多对多关系，需要为两个实体分别创建一个类。
多对多关系与其他关系类型均不同的一点在于，子实体中通常不存在对父实体的引用。因此，需要创建第三个类来表示两个实体之间的关联实体（即交叉引用表）。交叉引用表中必须包含表中表示的多对多关系中每个实体的主键列。

@Entity
class User(
    /**
     * 主键字段不能为空，并且必须具有唯一性，以确保每条记录都可以唯一标识.
     *
     * autoGenerate = true之后我们将主键默认设置为空或者0，
     * room也会自动自动生成一个唯一的值并填充到该字段中，
     * 但是不建议设置为空，建议默认设置为0。
     */
    @PrimaryKey(autoGenerate = true)
    val id: Long = 0,
    val name: String,
    val age: Int = 0,
    @GenderType
    val gender: Int = GenderType.MALE
)

/**
 * 计划表.
 */
@Entity
data class Plan(
    @PrimaryKey(autoGenerate = true)
    val planId: Long = 0,
    val planName: String,
    val planTime: Long
)

/**
 * 用户和对应计划数据.
 *
 * 多对多的关系的交叉引用表
 */
@Entity(primaryKeys = ["id", "planId"])
data class UserPlanCrossRef(
    val id: Long,
    val planId: Long
)

您想如何查询这些相关实体：

如果想查询用户表和每个用户表所含计划的列表，则应创建一个新的数据类，其中包含单个 User 对象，以及该用户表所包含的所有 Plan 对象的列表。
如果想查询计划表和每个计划所在用户表的列表，则应创建一个新的数据类，其中包含单个 Plan 对象，以及包含该计划的所有 User 对象的列表。

在这两种情况下，都可以通过以下方法在实体之间建立关系：在上述每个类中的 @Relation 注释中使用 associateBy 属性来确定提供 User 实体与 Plan 实体之间关系的交叉引用实体。

/**
 * 用户表对应的计划列表.
 */
data class UserWithPlans(
    @Embedded val user: User,
    @Relation(
        parentColumn = "id",
        entityColumn = "planId",
        associateBy = Junction(UserPlanCrossRef::class)
    )
    val plans: MutableList<Plan>
)


/**
 * 计划表对应的用户列表.
 */
data class PlanWithUsers(
    @Embedded val plan: Plan,
    @Relation(
        parentColumn = "planId",
        entityColumn = "id",
        associateBy = Junction(UserPlanCrossRef::class)
    )
    val users: MutableList<User>
)

向 DAO 类添加一个方法，用于提供您的应用所需的查询功能。

getUserWithPlans：该方法会查询数据库并返回查询到的所有 UserWithPlans 对象。
getPlanWithUsers：该方法会查询数据库并返回查询到的所有 PlanWithUsers 对象。

这两个方法都需要 Room 运行两次查询，因此应为这两个方法添加 @Transaction 注释，以确保整个操作以原子方式执行。

/**
 * 用户和对应计划表数据库操作对象.
 */
@Dao
interface UserPlanDao {

    /**
     * 查询用户和对应计划数据.
     *
     * @return 用户和对应计划数据
     */
    @Transaction
    @Query("SELECT *FROM user")
    fun getUserWithPlans(): List<UserWithPlans>

    /**
     * 查询计划和对应用户数据.
     *
     * @return 查询计划和对应用户数据
     */
    @Transaction
    @Query("SELECT *FROM `plan`")
    fun getPlanWithUsers(): List<PlanWithUsers>
}

注意：如果 @Relation 注释不适用于你的特定用例，可能需要在 SQL 查询中使用 JOIN 关键字来手动定义适当的关系。如需详细了解如何手动查询多个表，请参阅使用 Room DAO 访问数据。

4. 定义嵌套关系

嵌套关系请直接参考官方文档，一般不建议使用

定义嵌套关系

2.1.2 多重映射返回值类型

注意：Room 在 2.4 及更高版本中仅支持多重映射返回值类型。

在多重映射返回值类型方法中，无需定义任何其他数据类，而是根据所需的映射结构为您的方法定义多重映射返回值类型，并直接在 SQL 查询中定义实体之间的关系。

以下查询方法会返回 User 和 Work 实例的映射，用于表示指定用户和用户参与的所有工作

@Query("SELECT *FROM user JOIN work ON user.id = work.userId")
fun getUserWithWorks(): Map<User, List<Work>>

2.1.3 完整的数据库对象，需要将涉及到的数据表定义在

@Database(entities = [User::class, Work::class, Plan::class, UserPlanCrossRef::class], version = 1)

/**
 * 数据库.
 */
@Database(entities = [User::class, Work::class, Plan::class, UserPlanCrossRef::class], version = 1)
abstract class TestDataBase : RoomDatabase() {
    /**
     * 用户表操作类.
     */
    abstract fun userDao(): UserDao

    /**
     * 工作表操作类.
     */
    abstract fun workDao(): WorkDao

    /**
     * 计划表操作类.
     */
    abstract fun planDao(): PlanDao

    /**
     * 用户表和工作表操作类.
     */
    abstract fun userWorkDao(): UserWorkDao

    /**
     * 用户表和计划表操作类.
     */
    abstract fun userPlanDao(): UserPlanDao
}

示例代码：

PractiseProject

参考

1. Room使用官方文档（https://developer.android.com/?hl=zh-cn）

2. Room使用中文官方文档（Android 开发者 | Android Developers）

Room简单实操

一、单表

1.1 数据实体

1.1.1 自定义表明和列名

1.1.2 主键介绍

1.1.3 忽略字段

1.2 数据访问对象 (DAO)

对象创建须知

1. 介绍

2. 总结：

1.2.1 插入

1. 插入单个对象，参数必须是具体的`@Entity数据库表，例如例子中的User表`

2. 插入多个对象，参数必须是具体的`@Entity数据库表集合或者数组`

1.2.2 更新

1.2.3 删除

1.2.4 查询

1. 查询数据库中所有对象

2. 查询数据库表列的子集

3. 将简单参数传递给查询，使用指定参数进行查询

4. 将一组参数传递给查询，查询指定组查询条件的数据

1.2.5 完整DAO对象

1.3 数据库对象

1.4 构建数据库实例，进行数据库操作

二、多表

2.1 定义对象之间的关系

2.1.1 中间数据类

1. 定义一对一关系

2. 定义一对多关系

3. 定义多对多关系

4. 定义嵌套关系

2.1.2 多重映射返回值类型

2.1.3 完整的数据库对象，需要将涉及到的数据表定义在

示例代码：

参考

网站公告

今日签到

热门文章

最新发布

Room简单实操

一、单表

1.1 数据实体

1.1.1 自定义表明和列名

1.1.2 主键介绍

1.1.3 忽略字段

1.2 数据访问对象 (DAO)

对象创建须知

1. 介绍

2. 总结：

1.2.1 插入

1. 插入单个对象，参数必须是具体的@Entity数据库表，例如例子中的User表

2. 插入多个对象，参数必须是具体的@Entity数据库表集合或者数组

1.2.2 更新

1.2.3 删除

1.2.4 查询

1. 查询数据库中所有对象

2. 查询数据库表列的子集

3. 将简单参数传递给查询，使用指定参数进行查询

4. 将一组参数传递给查询，查询指定组查询条件的数据

1.2.5 完整DAO对象

1.3 数据库对象

1.4 构建数据库实例，进行数据库操作

二、多表

2.1 定义对象之间的关系

2.1.1 中间数据类

1. 定义一对一关系

2. 定义一对多关系

3. 定义多对多关系

4. 定义嵌套关系

2.1.2 多重映射返回值类型

2.1.3 完整的数据库对象，需要将涉及到的数据表定义在

示例代码：

参考

网站公告

今日签到

热门文章

最新发布

1. 插入单个对象，参数必须是具体的`@Entity数据库表，例如例子中的User表`

2. 插入多个对象，参数必须是具体的`@Entity数据库表集合或者数组`