快速瞭解Android Room使用細則進階

1、前言

上一篇5分鐘帶你瞭解Android Room數據好起來瞭，有人催更，遂決定再寫一篇Room的使用，這篇我們著重講講註解。如果寫的不好，或者有錯誤之處，懇請在評論、私信、郵箱指出，萬分感謝🙏

2、@ForeignKey和@PrimaryKey

考驗你數據庫知識的時候來瞭！因為你會頻繁看到@PrimaryKey所以先講它

@ForeignKey 註解用於定義外鍵關系，它指定瞭一個實體類中的一個字段是另一個實體類的主鍵。這種關系被稱為“外鍵關系”，並且可以用於在多個表之間建立關聯。

例如，如果有兩個實體類 User 和 Address，並且想要將它們關聯起來，則可以使用 @ForeignKey 註解來指定 Address 中的 user_id 字段是 User 的主鍵：

@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    val name: String
)
@Entity(tableName = "addresses",
        foreignKeys = [
            ForeignKey(entity = User::class,
                       parentColumns = ["id"],
                       childColumns = ["user_id"],
                       onDelete = ForeignKey.CASCADE)
        ])
data class Address(
    @PrimaryKey val id: Int,
    val street: String,
    val city: String,
    val state: String,
    val zip: String,
    @ColumnInfo(name = "user_id") val userId: Int
)

在這個例子中，我們使用 @ForeignKey 註解將 Address 中的 user_id 字段指定為 User 的主鍵。這將創建一個外鍵關系，確保在插入或更新 Address 表中的數據時，user_id 字段的值必須是 User 表中存在的主鍵值之一。

@PrimaryKey 註解用於指定實體類中的一個字段是主鍵。主鍵是用於唯一標識每個實體類對象的字段。在 Room 中，每個實體類必須至少有一個字段被指定為主鍵。

例如，如果有一個實體類 User，並且想要將 id 字段指定為主鍵，則可以使用 @PrimaryKey 註解：

@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    val name: String
)

在這個例子中，我們使用 @PrimaryKey 註解將 id 字段指定為 User 實體類的主鍵。這將確保在插入或更新 User 表中的數據時，每個 id 字段的值都是唯一的。

3、@TypeConverters

在使用Room時，你可能會遇到需要在Entity類中使用非基本類型的情況，例如Date、Calendar、List等類型。在這種情況下，你可以使用TypeConverters將這些類型轉換為Room可以存儲的類型。在Room中，可以使用@TypeConverter註解來定義一個類型轉換器，例如：

class Converters {
    @TypeConverter
    fun fromDate(date: Date): Long {
        return date.time
    }
    @TypeConverter
    fun toDate(timestamp: Long): Date {
        return Date(timestamp)
    }
    @TypeConverter
    fun fromList(list: List<String>?): String? {
        return list?.joinToString(",")
    }
    @TypeConverter
    fun toList(string: String?): List<String>? {
        return string?.split(",")
    }
}
@Entity(tableName = "user")
@TypeConverters(Converters::class)
data class User(
    @PrimaryKey val id: Int,
    val name: String,
    val birthday: Date
  	@TypeConverters(HobbiesConverter::class) val hobbies: List<String>
)
@Database(entities = [User::class], version = 1)
@TypeConverters(Converters::class)
abstract class AppDatabase : RoomDatabase() {
    // ...
}
@Dao
@TypeConverters(Converters::class)
interface UserDao {
    @Query("SELECT * FROM user")
    fun getAll(): List<User>
}

示例代碼在非常多的地方使用瞭@TypeConverters ，不同的位置造成的影響也是不同的，實際上可以應用到以下四個地方：

• 實體類：在 @Entity 註解中使用，可以在處理該實體類時使用它們。
• DAO 接口：在 DAO 接口中使用，可以在執行該 DAO 中的查詢時使用它們。
• 數據庫類：在 RoomDatabase 類中使用， 可以在整個數據庫中使用它們。
• 實體類中的屬性：在實體類中的屬性，可以在處理該屬性時使用指定的類型轉換器

4、@Relation

@Relation 用於在實體類之間建立關系。它可以用於定義兩個或更多實體之間的關系，這些實體可以在數據庫中分別存儲在不同的表中。

@Relation 註解應該與 @Query 註解一起使用，以便 Room 可以在查詢結果中返回相關實體之間的關系。@Relation 註解的一個常見用例是定義父子關系，其中一個實體包含對另一個實體的引用。

@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    val name: String,
    val email: String
)
@Entity(tableName = "books")
data class Book(
    @PrimaryKey val id: Int,
    val title: String,
    val author: String,
    val userId: Int
)
data class UserWithBooks(
    @Embedded val user: User,
    @Relation(
        parentColumn = "id",
        entityColumn = "userId"
    )
    val books: List<Book>
)

在這個示例中，我們有兩個實體類 User 和 Book，它們之間有一個父子關系，其中一個用戶可以擁有多本書。然後，我們定義瞭一個 UserWithBooks 數據類，它包含一個嵌套的 User 實體和一個 @Relation 註解，用於指定如何檢索與該用戶關聯的所有書籍。@Relation 註解包括 parentColumn 和 entityColumn 參數，分別指定父實體的主鍵列和子實體的外鍵列。

當我們使用 @Relation 註解時，我們需要在查詢中使用 SELECT 語句，以便 Room 可以檢索相關的實體。例如，在 Dao 接口中，我們可以使用以下查詢：

//Transaction下一點就會說
@Transaction
@Query("SELECT * FROM users WHERE id = :id")
fun getUserWithBooks(id: Int): UserWithBooks

此外，我們使用 SELECT * 語句來檢索所有用戶屬性和相關的書籍列表，因為 UserWithBooks 數據類包含一個嵌套的 User 實體和一個 List<Book> 列表。

5、@Transaction

第4點說到@Relation時使用到瞭@Transaction。在這個查詢中，我們使用 @Transaction 註解來確保整個查詢作為一個事務執行，以便 Room 可以在單個操作中檢索 User 實體和與之相關的所有 Book 實體。

@Transaction用於將一組數據庫操作包裝在一個事務中。它可以確保在執行數據庫操作時保持數據庫的一致性，並在必要時回滾事務以確保數據的完整性。

在 Room 中，單個數據庫操作（例如插入、更新或刪除）是自動運行在事務中的。但是，當需要執行多個數據庫操作時，可能需要手動創建一個事務來確保這些操作原子性地執行。如果需要執行多個數據庫操作，請始終考慮使用 @Transaction 註解。這可以避免數據不一致和其他與數據庫操作相關的問題。

6、@Embedded

上一篇，有同志說@Embedded很好用，的確如此哈

@Embedded用於指定一個實體類中的一個或多個字段應該作為其所屬的另一個實體的嵌入式對象。這使得 Room 可以將多個相關實體的數據組合成一個單獨的對象，從而簡化瞭數據庫操作。

當在一個實體類中使用 @Embedded 註解時，可以指定該實體類中的一個或多個字段應該嵌入到另一個實體類中。例如，假設有一個 Address 實體類和一個 User 實體類，其中 User 實體類包含一個 Address 對象。可以使用 @Embedded 註解將 Address 對象嵌入到 User 實體類中：

@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    val name: String,
    @Embedded val address: Address
)
data class Address(
    val street: String,
    val city: String,
    val state: String,
    val zip: String
)

在這個例子中，User 實體類包含一個 Address 對象，它使用 @Embedded 註解指定瞭該對象應該嵌入到 User 實體類中。在查詢數據庫時，Room 將自動組合 User 實體類和 Address 實體類中的字段，以便可以輕松地訪問和操作它們。

還可以使用 prefix 參數來指定 Room 應該在組合兩個實體類中的字段時使用的前綴。例如：

@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    val name: String,
    @Embedded(prefix = "home_") val homeAddress: Address,
    @Embedded(prefix = "work_") val workAddress: Address
)

在這個例子中，User 實體類包含兩個 Address 對象，一個是 homeAddress，另一個是 workAddress。我們使用 @Embedded(prefix = "home_") 和 @Embedded(prefix = "work_") 註解為每個地址對象指定瞭不同的前綴。這使得 Room 可以區分兩個地址對象中的相同字段，並將它們組合成一個單獨的對象。

當然你也可以這麼幹

@Entity(tableName 
data class User(
    @PrimaryKey val id: Int,
    val name: String,
    @Embedded @ColumnInfo(name = "home_address") val homeAddress: Address
)

7、@ColumnInfo

可以看到，我們剛剛用到瞭@ColumnInfo這個註解，用於自定義實體類中的列名、默認值和其他屬性。當需要將一個實體類映射到數據庫表時，可以使用 @ColumnInfo 註解來指定實體類中的每個字段在數據庫表中的名稱和其他屬性。

（1）指定實體類中的字段名稱

@ColumnInfo 註解最常用的用途是指定實體類中的字段名稱。例如：

@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    @ColumnInfo(name = "full_name") val name: String,
    val age: Int
)

在這個例子中，我們使用 @ColumnInfo(name = "full_name") 將 name 字段的名稱指定為 full_name。這意味著在數據庫表中，這個字段將被命名為 full_name，而不是 name。

（2）指定實體類中的字段默認值

@ColumnInfo 註解還可以用於指定實體類中的字段默認值。例如：

@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    @ColumnInfo(name = "full_name") val name: String,
    @ColumnInfo(name = "is_active") val isActive: Boolean = true
)

在這個例子中，我們使用 @ColumnInfo(name = "is_active") 將 isActive 字段的名稱指定為 is_active，並將其默認值設置為 true。這意味著在數據庫表中，這個字段將被命名為 is_active，並且默認值將為 true。

（3）指定實體類中的字段約束

@ColumnInfo 註解還可以用於指定實體類中的字段約束。例如：

@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    @ColumnInfo(name = "full_name") val name: String,
    @ColumnInfo(name = "is_active") val isActive: Boolean = true,
    @ColumnInfo(name = "created_at", defaultValue = "CURRENT_TIMESTAMP") val createdAt: String
)

在這個例子中，我們使用 @ColumnInfo(name = "created_at", defaultValue = "CURRENT_TIMESTAMP") 將 createdAt 字段的名稱指定為 created_at，並將其默認值設置為 CURRENT_TIMESTAMP。這意味著在數據庫表中，這個字段將被命名為 created_at，並且默認值將為 CURRENT_TIMESTAMP。

8、@Ignore

很直觀的註解哈。指定實體類中應該忽略的字段。當需要在實體類中添加一個字段，但不想將其映射到數據庫表中時，可以使用 @Ignore 註解來指定該字段應該被忽略。

忽略一個實體類中的字段

@Ignore 註解最常用的用法是忽略一個實體類中的字段，從而防止該字段被映射到數據庫表中。例如：

@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    val name: String,
    @Ignore val password: String
)

在這個例子中，我們使用 @Ignore 將 password 字段指定為應該被忽略的字段。這意味著在數據庫表中，這個字段將不會出現，也不會被映射到 User 實體類中。

（1）忽略一個實體類中的 getter 和 setter 方法

除瞭忽略一個實體類中的字段外，@Ignore 註解還可以用於忽略一個實體類中的 getter 和 setter 方法。這可以幫助控制 Room 如何處理實體類中的方法。

例如，如果希望 Room 不生成一個實體類中的 setter 方法，則可以將 @Ignore 註解添加到該方法上：

@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    val name: String,
    val password: String
) {
    @Ignore
    fun setPassword(password: String) {
        // ...
    }
}

在這個例子中，我們使用 @Ignore 將 setPassword 方法指定為應該被忽略的方法。這意味著 Room 不會生成一個 setter 方法來設置 password 字段的值。

（2）忽略一個實體類中的整個構造函數

最後，@Ignore 註解還可以用於忽略一個實體類中的整個構造函數。這可以幫助控制 Room 如何處理實體類中的構造函數。

例如，如果希望 Room 不使用默認的構造函數來創建實體類的實例，則可以使用 @Ignore 註解標記該構造函數：

@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    val name: String,
    val password: String
) {
    @Ignore
    constructor(id: Int, name: String) : this(id, name, "")
}

在這個例子中，我們使用 @Ignore 將第二個構造函數指定為應該被忽略的構造函數。這意味著 Room 不會使用這個構造函數來創建 User 實體類的實例。

9、@Index

考驗你數據庫知識的時候來瞭！索引(個索引、多個索引、復合索引)可以提高數據庫表查詢的性能，因為它們使數據庫系統能夠更快地查找和排序表中的數據。

（1）在一個實體類中創建單個索引

@Index 註解最常用的用法是在一個實體類中創建單個索引。例如：

@Entity(tableName = "users", indices = [Index(value = ["name"])])
data class User(
    @PrimaryKey val id: Int,
    val name: String,
    val age: Int
)

在這個例子中，我們使用 @Index 註解在 name 字段上創建瞭一個單個索引。這將使數據庫系統能夠更快地查找和排序 User 表中的數據。

（2）在一個實體類中創建多個索引

除瞭在一個實體類中創建單個索引外，@Index 註解還可以用於在一個實體類中創建多個索引。例如：

@Entity(tableName = "users", indices = [
    Index(value = ["name"]),
    Index(value = ["age"])
])
data class User(
    @PrimaryKey val id: Int,
    val name: String,
    val age: Int
)

在這個例子中，我們使用 @Index 註解在 name 和 age 字段上創建瞭兩個索引。這將使數據庫系統能夠更快地查找和排序 User 表中的數據。

（3）在一個實體類中創建復合索引

@Index 註解還可以用於在一個實體類中創建復合索引。復合索引是指將多個字段組合在一起以創建一個索引，這將使數據庫系統能夠更快地查找和排序這些字段的組合。

例如，如果希望在 User 表中按照 name 和 age 字段的組合進行排序，則可以使用 @Index 註解來創建一個復合索引：

@Entity(tableName = "users", indices = [
    Index(value = ["name", "age"])
])
data class User(
    @PrimaryKey val id: Int,
    val name: String,
    val age: Int
)

在這個例子中，我們使用 @Index 註解在 name 和 age 字段上創建瞭一個復合索引。這將使數據庫系統能夠更快地查找和排序 User 表中按照 name 和 age 字段的組合進行排序的數據。

10、@Entity

當在 Room 中定義一個實體類時，必須使用 @Entity 註解來指定該類應該被映射到數據庫中的哪個表。

（1）在一個實體類中指定表名

@Entity 註解最常用的用法是在一個實體類中指定表名。例如：

@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    val name: String,
    val age: Int
)

在這個例子中，我們使用 @Entity 註解將 User 實體類映射到名為 users 的數據庫表中。這將使 Room 能夠將 User 類中的字段映射到數據庫表中的相應列中。

（2）在一個實體類中指定索引

除瞭在一個實體類中指定表名外，@Entity 註解還可以用於在一個實體類中指定索引。索引可以提高數據庫表查詢的性能，因為它們使數據庫系統能夠更快地查找和排序表中的數據。

例如，如果希望在 User 表中按照 name 字段進行排序，則可以使用 @Entity 註解來創建一個索引：

@Entity(tableName = "users", indices = [Index(value = ["name"])])
data class User(
    @PrimaryKey val id: Int,
    val name: String,
    val age: Int
)

在這個例子中，我們使用 @Entity 註解在 name 字段上創建瞭一個索引。這將使數據庫系統能夠更快地查找和排序 User 表中的數據。

（3）在一個實體類中指定繼承關系

最後，@Entity 註解還可以用於在一個實體類中指定繼承關系。如果的實體類繼承自另一個實體類，則可以使用 @Entity 註解來指定它們之間的關系。

例如，如果有一個 Person 實體類和一個 Employee 實體類，Employee 實體類繼承自 Person 實體類，則可以使用 @Entity 註解來指定它們之間的關系：

@Entity(tableName = "user")
open class User(
    @PrimaryKey val id: Int,
    val name: String
)
@Entity(tableName = "employees")
data class Employee(
    @PrimaryKey val id: Int,
    val salary: Int,
    @ColumnInfo(name = "user_id") val userId: Int
) : User(userId, "")

在這個例子中，我們使用 @Entity 註解將 Person 實體類映射到名為 people 的數據庫表中，並將 Employee 實體類映射到名為 employees 的數據庫表中。此外，我們還使用 @Entity 註解指定瞭 Employee 實體類繼承自 Person 實體類，並使用 @ColumnInfo 註解將 person_id 字段指定為 Employee 表中的外鍵。這將確保在插入或更新 Employee 表中的數據時，person_id 字段的值必須是 Person 表中存在的主鍵值之一。

11、@Dao

@Dao 是用於訪問數據庫中數據的一種抽象層。在 Room 中，每個 DAO 都定義瞭一組用於與數據庫進行交互的方法。意思是就這麼用，沒啦。

@Dao
interface UserDao {}

12、@Database

@Database 註解是 Room 中的一個註解，用於定義數據庫類。當在 Room 中定義一個數據庫時，必須使用 @Database 註解來指定該數據庫包含哪些實體類和版本號等信息。

（1）在一個類中定義數據庫實例

@Database 註解最常用的用法是在一個類中定義數據庫實例。例如：

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

在這個例子中，我們使用 @Database 註解定義瞭一個數據庫類 AppDatabase，並在其中指定瞭包含 User 實體類的數據庫版本號。此外，我們還定義瞭一個抽象方法 userDao()，用於返回一個 UserDao 數據訪問對象 (DAO)。

（2）指定多個實體類

@Database 註解還可以用於指定多個實體類。例如：

@Database(entities = [User::class, Address::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
    abstract fun addressDao(): AddressDao
}

在這個例子中，我們使用 @Database 註解指定瞭包含 User 和 Address 實體類的數據庫版本號。然後，我們定義瞭兩個抽象方法 userDao() 和 addressDao()，分別用於返回 UserDao 和 AddressDao 數據訪問對象 (DAO)。

（3）指定數據庫升級策略

最後，@Database 註解還可以用於指定數據庫升級策略。當升級數據庫時，可能需要指定一些操作來處理數據模式的變化。Room 提供瞭兩種升級策略：Migrate 和 FallbackToDestructiveMigration。

例如，如果希望在升級數據庫時保留現有數據，可以使用 Migrate 升級策略：

val migration1to2 = object : Migration(1, 2) {
    override fun migrate(database: SupportSQLiteDatabase) {
        // TODO: write migration code here
    }
}
@Database(entities = [User::class], version = 2, migrations = [migration1to2])
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
}

在這個例子中，我們使用 Migrate 升級策略將數據庫版本從 1 升級到 2。我們定義瞭一個名為 migration1to2 的遷移對象，用於在升級數據庫時執行自定義的 SQL 語句。然後，我們使用 @Database 註解指定瞭包含 User 實體類的數據庫版本號和升級策略。

如果不需要保留現有數據，可以使用 FallbackToDestructiveMigration 升級策略：

@Database(entities = [User::class], version = 2, exportSchema = false)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
    companion object {
        @Volatile
        private var instance: AppDatabase? = null
        fun getInstance(context: Context): AppDatabase {
            return instance ?: synchronized(this) {
                instance ?: buildDatabase(context).also { instance = it }
            }
        }
        private fun buildDatabase(context: Context): AppDatabase {
            return Room.databaseBuilder(context, AppDatabase::class.java, "app-database")
                .fallbackToDestructiveMigration().build()
        }
    }
}

在這個例子中，我們使用 FallbackToDestructiveMigration 升級策略將數據庫版本從 1 升級到 2。我們使用 @Database 註解指定瞭包含 User 實體類的數據庫版本號和升級策略，並將 exportSchema 參數設置為 false，以避免生成不必要的 JSON 文件。

13、@Query

用於定義SQL查詢語句，可以在之前的例子中找到，許多的@Query的身影 （考驗你數據庫基礎的時候到瞭！）

（1）基本查詢操作

@Query 註解最常用的用法是執行基本的查詢操作。例如：

@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    fun getAllUsers(): List<User>
}

在這個例子中，我們使用 @Query 註解定義瞭一個基本的 SQL 查詢語句，該語句將返回 users 表中的所有數據。我們將此查詢定義為 getAllUsers() 方法的一部分，以便在需要時調用該方法。

（2）帶參數的查詢操作

@Query 註解還可以用於執行帶參數的查詢操作。例如：

@Dao
interface UserDao {
    @Query("SELECT * FROM users WHERE id = :id")
    fun getUserById(id: Int): User
}

在這個例子中，我們使用 @Query 註解定義瞭一個帶有參數的 SQL 查詢語句，該語句將返回 users 表中 id 字段等於給定值的數據。我們將此查詢定義為 getUserById() 方法的一部分，並將 id 參數傳遞給查詢語句。

（3）使用關聯查詢

最後，@Query 註解還可以用於執行關聯查詢。關聯查詢是一種可以跨多個表查詢數據的查詢類型。

@Dao
interface UserDao {
    @Query("SELECT * FROM users INNER JOIN addresses ON users.address_id = addresses.id")
    fun getUsersWithAddresses(): List<UserWithAddress>
}

在這個例子中，我們使用 @Query 註解定義瞭一個關聯查詢語句，該語句將返回 users 表中的數據以及與之關聯的 addresses 表中的數據。我們將此查詢定義為 getUsersWithAddresses() 方法的一部分，並使用 INNER JOIN 子句指定 users 表和 addresses 表之間的關系。

14、@Insert、@Update、@Delete

顧名思義哈，也就不用舉例瞭，嘻嘻嘻

@Dao
interface UserDao {
    @Insert\@Update\@Delete
    fun xxxUser(user: User)
}

15、多數據源

使用Kotlin Flow可以很方便地處理多個數據源的情況。在使用Room時，我們可以在Repository層中實現本地和遠程數據源的邏輯，並使用Kotlin Flow來組合和轉換數據。

以下是一個示例，演示瞭如何使用Room和Kotlin Flow處理多個數據源的情況：

class UserRepository(
    private val userDao: UserDao,
    private val api: ApiService
) {
    fun getUsers(): Flow<List<User>> {
        val localUsers = userDao.getAll().asFlow()
        val remoteUsers = api.getUsers().asFlow()
        return localUsers.combine(remoteUsers) { local, remote ->
            // 合並本地和遠程數據
            (local + remote).distinctBy { it.id }
        }
    }
    suspend fun updateUser(user: User) {
        api.updateUser(user.id, user)
        userDao.update(user)
    }
}

在以上示例中，我們在UserRepository中使用瞭本地和遠程數據源，並使用Kotlin Flow.combine操作符將本地和遠程數據源合並在一起，並在最後返回一個Flow對象。我們還使用瞭suspend修飾符將updateUser方法標記為掛起函數，以便可以在協程中執行異步操作。

很方便吧

16、@Fts3和@Fts4

這個一般用不到來著，不過如果你要做小說軟件的話，可能有用。用於創建全文本搜索虛擬表。全文本搜索是一種在大型文本數據集中搜索特定文本片段的技術。當您需要在應用程序中實現全文本搜索時，可以使用這兩個註解來創建虛擬表。

（1）@Fts3 註解

@Fts3 註解用於創建一個基於 SQLite FTS3 算法的虛擬表。例如：

@Fts3
@Entity(tableName = "books")
data class Book(
    @ColumnInfo(name = "book_title") val title: String,
    @ColumnInfo(name = "book_author") val author: String,
    @ColumnInfo(name = "book_description") val description: String
)

在這個例子中，我們使用 @Fts3 註解定義瞭一個名為 books 的虛擬表。該表將基於 title、author 和 description 列的內容創建一個全文本索引。當您執行全文本搜索時，將使用該索引來查找與搜索查詢匹配的行。

（2）@Fts4 註解

@Fts4 註解用於創建一個基於 SQLite FTS4 算法的虛擬表。例如：

@Fts4(contentEntity = Book::class)
@Entity(tableName = "book_fts")
data class BookFts(
    @ColumnInfo(name = "book_fts_title") val title: String,
    @ColumnInfo(name = "book_fts_author") val author: String,
    @ColumnInfo(name = "book_fts_description") val description: String
)

在這個例子中，我們使用 @Fts4 註解定義瞭一個名為 book_fts 的虛擬表。該表將基於 title、author 和 description 列的內容創建一個全文本索引。與 @Fts3 註解不同的是，@Fts4 註解需要使用 contentEntity 參數指定要創建索引的實體類。

（3）使用全文本搜索

創建全文本搜索虛擬表後，您可以使用 Room 中的 MATCH 關鍵字來執行全文本搜索。例如：

@Dao
interface BookDao {
    @Query("SELECT * FROM books WHERE books MATCH :query")
    fun searchBooks(query: String): List<Book>
}

在這個例子中，我們使用 MATCH 關鍵字來執行全文本搜索操作。該操作將在 books 虛擬表中搜索與 query 參數匹配的行，並返回所有匹配的結果。註意，在使用這些註解時，請確保為要搜索的列創建瞭索引，以避免搜索操作變得緩慢或不可用。

總結

我們在這一篇提到瞭17個註釋，，我們可以使用以上註解來定義實體類、DAO接口和數據庫，並實現各種數據操作和類型轉換。這些註解可以幫助我們更好地使用Room進行開發，並實現更加復雜和高效的功能，涵蓋瞭絕大數開發的需求。當然，在實際開發中，我們還需要根據具體的業務需求和技術特點來選擇合適的方案和實現方式。

實際上，Room的應用遠不止如此，如果有人感興趣的話，我就繼續出下一期吧！

感謝

• 校稿：ChatGpt/Bing
• 文筆優化：ChatGpt/Bing/秘塔寫作貓

以上就是快速瞭解Android Room使用細則進階的詳細內容，更多關於Android Room使用細則的資料請關註WalkonNet其它相關文章！

推薦閱讀：

• 快速瞭解Android Room使用細則
• Android開發Jetpack組件Room用例講解
• Android Jetpack中Room的使用
• Android kotlin+協程+Room數據庫的簡單使用
• 新手瞭解java 泛型基礎知識