今天小编给大家分享一下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进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。