溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
今天小編給大家分享一下Android Room怎么使用的相關知識點，內容詳細，邏輯清晰，相信大部分人都還太了解這方面的知識，所以分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后有所收獲，下面我們一起來了解一下吧。
考驗你數據庫知識的時候來了！因為你會頻繁看到@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 字段的值都是唯一的。
在使用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 類中使用， 可以在整個數據庫中使用它們。
實體類中的屬性：在實體類中的屬性，可以在處理該屬性時使用指定的類型轉換器
@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> 列表。
第4點說到@Relation時使用到了@Transaction。在這個查詢中，我們使用 @Transaction 注解來確保整個查詢作為一個事務執行，以便 Room 可以在單個操作中檢索 User 實體和與之相關的所有 Book 實體。
@Transaction用于將一組數據庫操作包裝在一個事務中。它可以確保在執行數據庫操作時保持數據庫的一致性，并在必要時回滾事務以確保數據的完整性。
在 Room 中，單個數據庫操作（例如插入、更新或刪除）是自動運行在事務中的。但是，當需要執行多個數據庫操作時，可能需要手動創建一個事務來確保這些操作原子性地執行。如果需要執行多個數據庫操作，請始終考慮使用 @Transaction 注解。這可以避免數據不一致和其他與數據庫操作相關的問題。
@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 )
可以看到，我們剛剛用到了@ColumnInfo這個注解，用于自定義實體類中的列名、默認值和其他屬性。當需要將一個實體類映射到數據庫表時，可以使用 @ColumnInfo 注解來指定實體類中的每個字段在數據庫表中的名稱和其他屬性。
@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。
@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。
@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。
很直觀的注解哈。指定實體類中應該忽略的字段。當需要在實體類中添加一個字段，但不想將其映射到數據庫表中時，可以使用 @Ignore 注解來指定該字段應該被忽略。
@Ignore 注解最常用的用法是忽略一個實體類中的字段，從而防止該字段被映射到數據庫表中。例如：
@Entity(tableName = "users") data class User( @PrimaryKey val id: Int, val name: String, @Ignore val password: String )
在這個例子中，我們使用 @Ignore 將 password 字段指定為應該被忽略的字段。這意味著在數據庫表中，這個字段將不會出現，也不會被映射到 User 實體類中。
除了忽略一個實體類中的字段外，@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 字段的值。
最后，@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 實體類的實例。
考驗你數據庫知識的時候來了！索引(個索引、多個索引、復合索引)可以提高數據庫表查詢的性能，因為它們使數據庫系統能夠更快地查找和排序表中的數據。
@Index 注解最常用的用法是在一個實體類中創建單個索引。例如：
@Entity(tableName = "users", indices = [Index(value = ["name"])]) data class User( @PrimaryKey val id: Int, val name: String, val age: Int )
在這個例子中，我們使用 @Index 注解在 name 字段上創建了一個單個索引。這將使數據庫系統能夠更快地查找和排序 User 表中的數據。
除了在一個實體類中創建單個索引外，@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 表中的數據。
@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 字段的組合進行排序的數據。
當在 Room 中定義一個實體類時，必須使用 @Entity 注解來指定該類應該被映射到數據庫中的哪個表。
@Entity 注解最常用的用法是在一個實體類中指定表名。例如：
@Entity(tableName = "users") data class User( @PrimaryKey val id: Int, val name: String, val age: Int )
在這個例子中，我們使用 @Entity 注解將 User 實體類映射到名為 users 的數據庫表中。這將使 Room 能夠將 User 類中的字段映射到數據庫表中的相應列中。
除了在一個實體類中指定表名外，@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 表中的數據。
最后，@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 表中存在的主鍵值之一。
@Dao 是用于訪問數據庫中數據的一種抽象層。在 Room 中，每個 DAO 都定義了一組用于與數據庫進行交互的方法。意思是就這么用，沒啦。
@Dao
interface UserDao {}@Database 注解是 Room 中的一個注解，用于定義數據庫類。當在 Room 中定義一個數據庫時，必須使用 @Database 注解來指定該數據庫包含哪些實體類和版本號等信息。
@Database 注解最常用的用法是在一個類中定義數據庫實例。例如：
@Database(entities = [User::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
abstract fun userDao(): UserDao
}在這個例子中，我們使用 @Database 注解定義了一個數據庫類 AppDatabase，并在其中指定了包含 User 實體類的數據庫版本號。此外，我們還定義了一個抽象方法 userDao()，用于返回一個 UserDao 數據訪問對象 (DAO)。
@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)。
最后，@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 文件。
用于定義SQL查詢語句，可以在之前的例子中找到，許多的@Query的身影 （考驗你數據庫基礎的時候到了！）
@Query 注解最常用的用法是執行基本的查詢操作。例如：
@Dao
interface UserDao {
@Query("SELECT * FROM users")
fun getAllUsers(): List<User>
}在這個例子中，我們使用 @Query 注解定義了一個基本的 SQL 查詢語句，該語句將返回 users 表中的所有數據。我們將此查詢定義為 getAllUsers() 方法的一部分，以便在需要時調用該方法。
@Query 注解還可以用于執行帶參數的查詢操作。例如：
@Dao
interface UserDao {
@Query("SELECT * FROM users WHERE id = :id")
fun getUserById(id: Int): User
}在這個例子中，我們使用 @Query 注解定義了一個帶有參數的 SQL 查詢語句，該語句將返回 users 表中 id 字段等于給定值的數據。我們將此查詢定義為 getUserById() 方法的一部分，并將 id 參數傳遞給查詢語句。
最后，@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 表之間的關系。
顧名思義哈，也就不用舉例了，嘻嘻嘻
@Dao
interface UserDao {
@Insert\@Update\@Delete
fun xxxUser(user: User)
}使用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方法標記為掛起函數，以便可以在協程中執行異步操作。
很方便吧
這個一般用不到來著，不過如果你要做小說軟件的話，可能有用。用于創建全文本搜索虛擬表。全文本搜索是一種在大型文本數據集中搜索特定文本片段的技術。當您需要在應用程序中實現全文本搜索時，可以使用這兩個注解來創建虛擬表。
@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 列的內容創建一個全文本索引。當您執行全文本搜索時，將使用該索引來查找與搜索查詢匹配的行。
@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 參數指定要創建索引的實體類。
創建全文本搜索虛擬表后，您可以使用 Room 中的 MATCH 關鍵字來執行全文本搜索。例如：
@Dao
interface BookDao {
@Query("SELECT * FROM books WHERE books MATCH :query")
fun searchBooks(query: String): List<Book>
}在這個例子中，我們使用 MATCH 關鍵字來執行全文本搜索操作。該操作將在 books 虛擬表中搜索與 query 參數匹配的行，并返回所有匹配的結果。注意，在使用這些注解時，請確保為要搜索的列創建了索引，以避免搜索操作變得緩慢或不可用。
以上就是“Android Room怎么使用”這篇文章的所有內容，感謝各位的閱讀！相信大家閱讀完這篇文章都有很大的收獲，小編每天都會為大家更新不同的知識，如果還想學習更多的知識，請關注億速云行業資訊頻道。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
