当前位置 : 主页 > 手机开发 > android >

Android开发Jetpack组件Room使用讲解

来源:互联网 收集:自由互联 发布时间:2023-02-01
目录 简介 Room使用步骤 1 添加依赖 2 创建Entity实体类 3 声明Dao对象 4 声明Database对象 5 获取数据 6 最终使用 简介 Room 是 Google 官方推出的数据库 ORM 框架。ORM 是指Object Relational Mapping,即
目录
  • 简介
  • Room使用步骤
    • 1 添加依赖
    • 2 创建Entity实体类
    • 3 声明Dao对象
    • 4 声明Database对象
    • 5 获取数据
    • 6 最终使用

简介

Room 是 Google 官方推出的数据库 ORM 框架。ORM 是指 Object Relational Mapping,即对象关系映射,也就是将关系型数据库映射为面向对象的语言。使用 ORM 框架,我们就可以用面向对象的思想操作关系型数据库,不再需要编写 SQL 语句。

Room使用步骤

1 添加依赖

build.gradle {
apply plugin: 'kotlin-kapt'

dependencies {
    kapt "androidx.room:room-compiler:$rootProject.roomVersion"
    implementation "androidx.room:room-runtime:$rootProject.roomVersion"
    }

}

2 创建Entity实体类

@Entity(tableName = "apps")
data class AppEntity(
        @ColumnInfo(name = "packageName") @PrimaryKey val packageName: String,
        @ColumnInfo(name = "app_id") val id: Int,
        @ColumnInfo(name = "versionCode") val versionCode: String,
        @ColumnInfo(name = "versionLabel") val versionLabel: String,
        @ColumnInfo(name = "versionName") val versionName: String,
        @ColumnInfo(name = "description") val description: String,
        @ColumnInfo(name = "icon") val icon: String)
 @Entity(tableName = "comments",
        foreignKeys = [
            ForeignKey(entity = AppEntity::class,
                    parentColumns = ["packageName"],
                    childColumns = ["packageName"],
                    onDelete = ForeignKey.CASCADE)
        ],
    	indices = [Index("packageName")])
class CommentEntity(@PrimaryKey(autoGenerate = true) val id: Int = 0,
                val packageName: String,
                val comment: String = "this is comment for $packageName")

实体类我们采用的是注解Entity来标记,其中有很多属性:

  • tableName: 用来设置数据库中表名字。如果不设置这个值的话,默认是类的名字
  • indices: 用来设置索引,索引用于提高数据库表的数据访问速度的,有单列索引和组合索引
  • inheritSuperIndices: 父类的索引是否会自动被当前类继承
  • primaryKeys: 用来设置主键,如果这个主键的值可以唯一确定这个对象,就可以只设置一个主键。如果一个字段值不能够唯一确定对象,就需要复合主键,这里primaryKeys可以设置数组;另外每一个Entity都需要设置一个主键,如果父类和子类都设置了主键,则子类的主键会覆盖父类的主键
  • foreignKeys: 用来设置外键,也就是FOREIGN KEY约束。因为Sqlite数据库属于关系型数据库,所以表于表之间会有关系存在,那么这个属性值就用来联系两个表单之间的关系;如上CommentEntity中设置了外键为AppEntity中的packageName
  • ignoredColumns: 被忽略的字段

类中还使用了ColumnInfo注解; 其中的属性值name用来标记的是表中一个字段在数据库中的存储的字段值,如果不设置的话默认为声明的字段的值

另外还有Embedded,表示的是嵌套对象; 我们可以把类A放入另外一个类B中,只需要在B中对A使用注解Embedded即可,这样的话,B就可以正常使用A中所有的属性值

3 声明Dao对象

@Dao
interface AppsDao {
    @Query("SELECT * FROM apps")
    fun loadApps(): LiveData<List<AppEntity>>
    @Query("SELECT * FROM apps WHERE packageName = :packageName")
    fun loadApp(packageName: String): LiveData<AppEntity>
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insertAll(apps: List<AppEntity>)
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insert(app: AppEntity)
    @Delete
    fun delete(app: AppEntity)
    @Update
    fun update(app: AppEntity)
}

这个Dao对象的声明必须使用interface修饰; 另外我们看到提供了四种增删改查的注解,只有查询的注解需要输入少量的SQL语句,定义接口的返回值还可以是LiveData等可观察的数据,操作起来是非常方便的

当我们同步代码之后会在generated中生成一个xxx_Impl.java对象,里面将我们声明的接口方法都做了实现,不需要我们自己处理了

4 声明Database对象

@Database(entities = [AppEntity::class, CommentEntity::class], version = 1, exportSchema = false)
abstract class AppDatabase : RoomDatabase() {
    abstract fun appsDao(): AppsDao
    abstract fun commentsDao(): CommentsDao
    companion object {
        private const val DATABASE_NAME = "forward-db"
        private val executors: ExecutorService = Executors.newSingleThreadExecutor()
        @Volatile
        private var instance: AppDatabase? = null
        fun getInstance(context: Context): AppDatabase {
            return instance ?: synchronized(this) {
                instance ?: buildDatabase(context.applicationContext).also {
                    instance = it
                }
            }
        }
        private fun buildDatabase(context: Context): AppDatabase {
            return Room.databaseBuilder(context, AppDatabase::class.java, DATABASE_NAME)
                    .addCallback(object : Callback() {
                        override fun onCreate(db: SupportSQLiteDatabase) {
                            executors.execute {
                                Thread.sleep(3000)
                                val request: OneTimeWorkRequest = OneTimeWorkRequestBuilder<AppsWorker>().build()
                                WorkManager.getInstance(context).enqueue(request)
                            }
                        }
                    })
                    .build()
        }
    }
}

使用Database注解需要传入我们声明的所有的Entity对象,版本号version,以及是否导出Schema等属性值

这个类是要继承RoomDatabase的,一般将这个类使用单例的形式提供使用; 并且采用建造者模式创建对象,我们可以将数据的获取放在某一个地方,这里是放在了数据库的onCreate方法中,这里采用的是WorkManager的方式,如下所示

5 获取数据

class AppsWorker(context: Context, workerParameters: WorkerParameters)
    : CoroutineWorker(context, workerParameters) {
    private val TAG by lazy {
        AppsWorker::class.java.simpleName
    }
    override suspend fun doWork(): Result = coroutineScope {
        try {
            applicationContext.assets.open("apps.json").use {
                JsonReader(it.reader()).use { reader ->
                    val appsType = object : TypeToken<List<AppEntity>>() {}.type
                    val appsList: List<AppEntity> = Gson().fromJson(reader, appsType)
                    val comments = DataGenerator.getComments(appsList)
                    val appsDao = RepositoryProvider.providerAppsRepository(applicationContext)
                    val commentDao = RepositoryProvider.providerCommentsRepository(applicationContext)
                    appsDao.insertAll(appsList)
                    commentDao.insertAll(comments)
                }
                Result.success()
            }
        } catch (e: Exception) {
            Result.failure()
        }
    }
    private fun insertData(database: AppDatabase, apps: List<AppEntity>, comments: List<CommentEntity>) {
        database.runInTransaction {
            database.appsDao().insertAll(apps)
            database.commentsDao().insertAll(comments)
        }
    }
}

WorkManager的使用不是这一节的重点,它的使用比较简单,但是源码分析却是比较复杂的;后面会单独的进行讲解

6 最终使用

   viewModel.apps.observe(viewLifecycleOwner, Observer {
        if (it.isNullOrEmpty()) {
            binding.loading = true
        } else {
            binding.loading = false
            adapter.setList(it)
        }
        binding.executePendingBindings()
    })

调用了上述的代码就将我们的数据和生命周期仅仅绑定在一起,并且如果数据发生变化的话,会立刻回调我们更新UI的代码,就达到了我们的目的

以上就是Android开发Jetpack组件Room使用讲解的详细内容,更多关于Android Jetpack组件Room的资料请关注自由互联其它相关文章!

上一篇:Android实现传感器功能
下一篇:没有了
网友评论