关于android:Room又要写业务代码了看看我吧给你飞一般的感觉

41次阅读

共计 13825 个字符，预计需要花费 35 分钟才能阅读完成。

前言：

🏀在咱们日常开发中，常常要和数据打交道，所以存储数据是很重要的事。Android 从最开始应用 SQLite 作为数据库存储数据，再到许多的开源的数据库，例如 QRMLite，DBFlow，郭霖大佬开发的 Litepal 等等，都是为了不便 SQLite 的应用而呈现的，因为 SQLite 的应用繁琐且容易出错。Google 当然也意识到了 SQLite 的一些问题，于是在 Jetpack 组件中推出了 Room，实质上 Room 也是在 SQLite 上提供了一层封装。因为它官网组件的身份，和良好的开发体验，当初逐步成为了最支流的数据库 ORM 框架。

🌟Room 官网文档：https://developer.android.goo…

🌟SQL 语法教程：https://www.runoob.com/sqlite…

🚀本文代码地址：https://github.com/taxze6/Jet…

为什么要应用 Room？Room 具备什么劣势？

Room 在 SQLite 上提供了一个形象层，以便在充分利用 SQLite 的弱小性能的同时，可能享有更健壮的数据库拜访机制。

Room 的具体劣势：

  • 有能够最大限度缩小反复和容易出错的样板代码的注解
  • 简化了数据库迁徙门路
  • 针对编译期 SQL 的语法查看
  • API 设计敌对，更容易上手，了解
  • 与 SQL 语句的应用更加贴近，可能升高学习老本
  • 对 RxJava、LiveData、Kotlin 协程等都反对

Room 具备三个次要模块

  • Entity: Entity用来示意数据库中的一个表。须要应用 @Entity(tableName = "XXX") 注解，其中的参数为表名。
  • Dao: 数据库拜访对象，用于拜访和治理数据（增删改查）。在应用时须要 @DAO 注解
  • Database: 它作为数据库持有者，用 @Database 注解和 Room Database 扩大的类

如何应用 Room 呢？

①增加依赖
最近更新工夫（文章公布时的最新版本） 稳定版 Alpha 版
2022 年 6 月 1 日 2.4.2 2.5.0-alpha02 
plugins {
    ...
    id 'kotlin-kapt'
}
​
def room_version = "2.4.2"
implementation "androidx.room:room-runtime:$room_version"
annotationProcessor "androidx.room:room-compiler:$room_version"
kapt 'androidx.room:room-compiler:$room_version'
②创立 Entity 实体类，用来示意数据库中的一张表（table）
@Entity(tableName = "user")
data class UserEntity(// 主键定义须要用到 @PrimaryKey(autoGenerate = true)注解，autoGenerate 参数决定是否自增长
    @PrimaryKey(autoGenerate = true) val id:Int = 0, // 默认值为 0
    @ColumnInfo(name = "name", typeAffinity = ColumnInfo.TEXT) val name:String?,
    @ColumnInfo(name = "age", typeAffinity = ColumnInfo.INTEGER) val age:Int?
)

其中，每个表的字段都要加上 @ColumnInfo(name = "xxx", typeAffinity = ColumnInfo.xxx)，name 属性示意这张表中的字段名，typeAffinity示意改字段的数据类型。

其余罕用注解：

  • @Ignore :Entity中的所有属性都会被长久化到数据库，除非应用@Ignore

    @Ignore val name: String?
  • @ForeignKey: 外键束缚，不同于目前存在的大多数 ORM 库，Room 不反对 Entitiy 对象间的间接援用。Google 也做出了解释，具体起因请查看：https://developer.android.com…，不过 Room 容许通过外键来示意 Entity 之间的关系。ForeignKey咱们文章前面再谈，先讲简略的应用。
  • @Embedded : 实体类中援用其余实体类，在某些状况下，对于一张表的数据，咱们用多个 POJO 类来示意，所以在这种状况下，咱们能够应用 Embedded 注解嵌套对象。
③创立数据拜访对象（Dao）解决增删改查
@Dao
interface UserDao {
    // 增加用户
    @Insert
    fun addUser(vararg userEntity: UserEntity)
​
    // 删除用户
    @Delete
    fun deleteUser(vararg userEntity: UserEntity)
​
    // 更新用户
    @Update
    fun updateUser(vararg userEntity: UserEntity)
​
    // 查找用户
    // 返回 user 表中所有的数据
    @Query("select * from user")
    fun queryUser(): List<UserEntity>}

Dao负责提供拜访 DB 的API，咱们每一张表都须要一个 Dao。在这里应用@Dao 注解定义 Dao 类。

  • @Insert, @Delete须要传一个 entity() 进去
  • Class<?> entity() default Object.class;
  • @Query则是须要传递 SQL 语句
  • public @interface Query {
    // 要运行的 SQL 语句
    String value();}

☀留神：Room 会在编译期基于 Dao 主动生成具体的实现类，UserDao_Impl（实现增删改查的办法）。

🔥Dao 所有的办法调研都在以后线程进行，须要防止在 UI 线程中间接拜访！

④创立 Room database
@Database(entities = [UserEntity::class], version = 1)
abstract class UserDatabase : RoomDatabase() {abstract fun userDao(): UserDao
}

通过 Room.databaseBuilder() 或者 Room.inMemoryDatabaseBuilder()获取 Database 实例

val db = Room.databaseBuilder(
    applicationContext,
    UserDatabase::class.java, "userDb"
    ).build()

☀留神：创立 Database 的老本较高，所以咱们最好应用单例的Database，防止重复创立实例所带来的开销。

单例模式创立 Database：

@Database(entities = [UserEntity::class], version = 1)
abstract class UserDatabase : RoomDatabase() {abstract fun getUserDao(): UserDao
​
    companion object {
        @Volatile
        private var INSTANCE: UserDatabase? = null
​
        @JvmStatic
        fun getInstance(context: Context): UserDatabase {
            val tmpInstance = INSTANCE
            if (tmpInstance != null) {return tmpInstance}
            // 锁
            synchronized(this) {
                val instance =
                    Room.databaseBuilder(context, UserDatabase::class.java, "userDb").build()
                INSTANCE = instance
                return instance
            }
        }
    }
}
​
⑤在 Activity 中应用，进行一些可视化操作

activity_main:

<LinearLayout
    ...
    tools:context=".MainActivity"
    android:orientation="vertical">
    <Button
        android:id="@+id/btn_add"
        ...
        android:text="减少一条数据"/>
    <Button
        android:id="@+id/btn_delete"
        ...
        android:text="删除一条数据"/>
    <Button
        android:id="@+id/btn_update"
        ...
        android:text="更新一条数据"/>
    <Button
        android:id="@+id/btn_query_all"
        ...
        android:text="查新所有数据"/>
</LinearLayout>

MainActivity：

private const val TAG = "My_MainActivity"
class MainActivity : AppCompatActivity() {
    private val userDao by lazy {UserDatabase.getInstance(this).getUserDao()}
    private lateinit var btnAdd: Button
    private lateinit var btnDelete: Button
    private lateinit var btnUpdate: Button
    private lateinit var btnQueryAll: Button
    override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        init()
        // 增加数据
        btnAdd.setOnClickListener {
            // 数据库的增删改查必须在子线程，当然也能够在协程中操作
            Thread {val entity = UserEntity(name = "Taxze", age = 18)
                userDao.addUser(entity)
            }.start()}
        // 查问数据
        btnQueryAll.setOnClickListener {
            Thread {val userList = userDao.queryUser()
                userList.forEach {Log.d(TAG, "查问到的数据为：$it")
                }
            }.start()}
        // 批改数据
        btnUpdate.setOnClickListener {
            Thread {userDao.updateUser(UserEntity(2, "Taxzeeeeee", 18))
            }.start()}
        // 删除数据
        btnDelete.setOnClickListener {
            Thread {userDao.deleteUser(UserEntity(2, null, null))
            }.start()}
    }
    // 初始化
    private fun init() {btnAdd = findViewById(R.id.btn_add)
        btnDelete = findViewById(R.id.btn_delete)
        btnUpdate = findViewById(R.id.btn_update)
        btnQueryAll = findViewById(R.id.btn_query_all)
    }
}

后果：

到这里咱们曾经讲完了 Room 的最根本的应用，如果只是一些非常简单的业务，你看到这里曾经能够去写代码了，然而还有一些进阶的操作需解说一下，持续往下看吧！

数据库的降级

Room 在 2021 年 4 月 21 日公布的版本 2.4.0-alpha01 中开始反对主动迁徙，不过很多敌人反馈还是有很多问题，倡议手动迁徙，当然如果你应用的是更低的版本只能手动迁徙啦。

具体信息请参考：https://developer.android.goo…

具体如何降级数据库呢？上面咱们一步一步来实现吧！

①批改数据库版本

在 UserDatabase 文件中批改version，将其变为 2(原来是 1)

在此时，咱们须要想一想，咱们要对数据库做什么降级操作呢？

咱们这里为了演示就给数据库减少一张成绩表:

@Database(entities = [UserEntity::class,ScoreEntity::class], version = 2)

增加表：

@Entity(tableName = "score")
data class ScoreEntity(@PrimaryKey(autoGenerate = true) var id: Int = 0,
    @ColumnInfo(name = "userScore")
    var userScore: Int
)
②创立对应的 Dao,ScoreDao
@Dao
interface ScoreDao {
    @Insert
    fun insertUserScore(vararg scoreEntity: ScoreEntity)
​
    @Query("select * from score")
    fun queryUserScoreData():List<ScoreEntity>}
③在 Database 中增加迁徙
@Database(entities = [UserEntity::class,ScoreEntity::class], version = 2)
abstract class UserDatabase : RoomDatabase() {abstract fun getUserDao(): UserDao
    
    // 增加一个 Dao
    abstract fun getScoreDao():ScoreDao
​
    companion object {
        // 变量名最好为 xxx 版本迁徙到 xxx 版本
        private val MIGRATION_1_2 = object : Migration(1, 2) {override fun migrate(database: SupportSQLiteDatabase) {
                database.execSQL(
                    """
                    create table userScore(
                    id integer primary key autoincrement not null,
                    userScore integer not null)
                """.trimIndent())
            }
        }
​
        @Volatile
        private var INSTANCE: UserDatabase? = null
​
        @JvmStatic
        fun getInstance(context: Context): UserDatabase {
            ...
            synchronized(this) {
                val instance =
                    Room.databaseBuilder(
                        context.applicationContext,
                        UserDatabase::class.java,
                        "userDb"
                    )
                        .addMigrations(MIGRATION_1_2)
                        .build()
                INSTANCE = instance
                return instance
            }
        }
    }
}
④应用更新后的数据

在 xml 布局中增加两个 Button:

<Button
    android:id="@+id/btn_add_user_score"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="减少 user 的 score 数据"/>
​
<Button
    android:id="@+id/btn_query_user_score"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="查问 user 的 score 数据"/>

在 MainActivity 中退出：

private val userScoreDao by lazy {UserDatabase.getInstance(this).getScoreDao()}
​
...
​
private lateinit var btnAddUserScore: Button
private lateinit var btnQueryUserScore: Button
​
...
btnAddUserScore = findViewById(R.id.btn_add_user_score)
btnQueryUserScore = findViewById(R.id.btn_query_user_score)
​
...
btnAddUserScore.setOnClickListener {
            Thread{userScoreDao.insertUserScore(ScoreEntity(userScore = 100))
            }.start()}
​
btnQueryUserScore.setOnClickListener {
            Thread{userScoreDao.queryUserScoreData().forEach{Log.d(TAG,"userScore 表的数据为:$it")
                }
            }.start()}

这样对数据库的一次手动迁徙就实现啦！💪

如果你想持续降级，就反复之前的步骤，而后将 2→3

private val MIGRATION_2_3 = object : Migration(2, 3) {override fun migrate(database: SupportSQLiteDatabase) {
        database.execSQL(""".... 再一次新的操作""".trimIndent()
        )
    }
}
​
...
.addMigrations(MIGRATION_1_2,MIGRATION_2_3)

应用 Room 更多的骚操作！

①想晓得更多的 Room 数据库迁徙的操作吗，那你能够看看这篇文章：

https://www.modb.pro/db/139101

②更优雅的批改数据

在下面的批改数据操作中，咱们是须要填入每个字段的值的，然而，大部分状况，咱们是不会全副晓得的，比方咱们不晓得 User 的age，那么咱们的 age 字段就填个 Null 吗？

val entity = UserEntity(name = "Taxze", age = null)

这显然是不适合的！

当咱们只想批改用户名的时，却又不晓得 age 的值的时候，咱们须要怎么批改呢？

⑴创立 UpdateNameBean

class UpdateNameBean(var id:Int,var name:String)

⑵在 Dao 中退出新的办法

@Update(entity = UserEntity::class)
fun updataUser2(vararg updataNameBean:UpdateNameBean)

⑶而后在应用时只须要传入 id，和 name 即可

userDao.updateUser2(updataNameBean(2, "Taxzeeeeee"))

当然你也能够给用户类创立多个构造方法，并给这些构造方法增加@lgnore

③详解 @Insert 插入
@Dao
interface UserDao {@Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insertUsers(vararg userEntity: UserEntity)
}

其中 onConflict 用于设置当事务中遇到抵触时的策略。

有如下一些参数能够抉择：

  • OnConflictStrategy.REPLACE : 替换旧值，持续以后事务
  • OnConflictStrategy.NONE : 疏忽抵触，持续以后事务
  • OnConflictStrategy.ABORT : 回滚
④@Query 指定参数查问

每次都查表的全副信息这也不是事啊，咱们要用到 where 条件来指定参数查问。

@Dao
interface UserDao {@Query("SELECT * FROM user WHERE age BETWEEN :minAge AND :maxAge")
    fun loadAllUsersBetweenAges(minAge: Int, maxAge: Int): Array<UserEntity>
}

大家能够本人学习一下 SQL 语法~

⑤多表查问

很多业务状况下，咱们是须要同时在多张表中进行查问的。

@Dao
interface UserDao {
    @Query(
        "SELECT * FROM user" +
                "INNER JOIN score ON score.id = user.id"  +
                "WHERE user.name LIKE :userName"
    )
    fun findUsersScoreId(userName: String): List<UserEntity>
}
⑥@Embedded 内嵌对象

咱们能够应用 @Embedded 注解，将一个 Entity 作为属性内嵌到另外一个 Entity，而后咱们就能够像拜访 Column 一样去拜访内嵌的 Entity 啦。

data class Score(
    val id:Int?,
    val score:String?,
)
@Entity(tableName = "user")
data class UserEntity(@PrimaryKey(autoGenerate = true) val id:Int = 0,
    .....
    @Embedded val score: Score?
)
⑦应用 @Relation 注解和 foreignkeys 注解来形容 Entity 之间更简单的关系

能够实现一对多，多对多的关系

⑧预填充数据库

能够查看官网文档：https://developer.android.goo…

⑨类型转换器 TypeConverter

….

Room 配合 LiveData 和 ViewModel

上面咱们通过一个 Room+LiveData+ViewModel 的例子来实现这篇文章的学习吧

话不多说，先上效果图：

①创立 UserEntity
@Entity(tableName = "user")
data class UserEntity(@PrimaryKey(autoGenerate = true) val id: Int = 0,
    @ColumnInfo(name = "name", typeAffinity = ColumnInfo.TEXT) val name: String?,
    @ColumnInfo(name = "age", typeAffinity = ColumnInfo.INTEGER) val age: Int?,
)
②创立对应的 Dao
@Dao
interface UserDao {
    // 增加用户
    @Insert
    fun addUser(vararg userEntity: UserEntity)
​
    // 查找用户
    // 返回 user 表中所有的数据, 应用 LiveData
    @Query("select * from user")
    fun getUserData(): LiveData<List<UserEntity>>}
③创立对应的 Database

代码在最开始的例子中曾经给出了。

④创立 ViewModel
class UserViewModel(userDao: UserDao):ViewModel(){var userLivedata = userDao.getUserData()
}
⑤创立 UserViewModelFactory

咱们在 UserViewModel 类中传递了 UserDao 参数，所以咱们须要有这么个类实现 ViewModelProvider.Factory 接口，以便于将 UserDao 在实例化时传入。

class UserViewModelFactory(private val userDao: UserDao) : ViewModelProvider.Factory {override fun <T : ViewModel?> create(modelClass: Class<T>): T {return UserViewModel(userDao) as T
    }
}
⑥编辑 xml

activity_main:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity">
​
    <EditText
        android:id="@+id/user_name"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:hint="请输出 UserName" />
​
    <EditText
        android:id="@+id/user_age"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:hint="请输出 UserAge" />
​
    <Button
        android:id="@+id/btn_add"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="增加一条 user 数据" />
​
    <ListView
        android:id="@+id/recycler_view"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
    </ListView>
</LinearLayout>

创立一个simple_list_item.xml，用于展现每一条用户数据

<?xml version="1.0" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/userText"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content" />
⑦在 MainActivity 中调用
class MainActivity : AppCompatActivity() {private var userList: MutableList<UserEntity> = arrayListOf()
    private lateinit var arrayAdapter: ArrayAdapter<UserEntity>
    private val userDao by lazy {UserDatabase.getInstance(this).getUserDao()}
    lateinit var viewModel: UserViewModel
    private lateinit var listView: ListView
    private lateinit var editUserName: EditText
    private lateinit var editUserAge: EditText
    private lateinit var addButton: Button
    override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        init()
        arrayAdapter = ArrayAdapter(this, R.layout.simple_list_item, userList)
        listView.adapter = arrayAdapter
        // 实例化 UserViewModel，并监听 LiveData 的变动。viewModel =
            ViewModelProvider(this, UserViewModelFactory(userDao)).get(UserViewModel::class.java)
        viewModel.userLivedata.observe(this, Observer {userList.clear()
            userList.addAll(it)
            arrayAdapter.notifyDataSetChanged()})
        addButton.setOnClickListener {addClick()
        }
    }
​
    // 初始化控件
    private fun init() {editUserName = findViewById(R.id.user_name)
        editUserAge = findViewById(R.id.user_age)
        addButton = findViewById(R.id.btn_add)
        listView = findViewById(R.id.recycler_view)
    }
​
    fun addClick() {if (editUserName.text.toString() == ""|| editUserAge.text.toString() =="") {Toast.makeText(this, "姓名或年龄不能为空", Toast.LENGTH_SHORT).show()
            return
        }
        val user = UserEntity(name = editUserName.text.toString(),
            age = editUserAge.text.toString().toInt()
        )
        thread {userDao.addUser(user)
        }
    }
}

这样一个简略的 Room 配合 LiveData 和 ViewModel 实现页面自动更新的 Demo 就实现啦🌹具体代码能够查看 Git 仓库😉

尾述

看完这篇文章，置信你曾经发现 Room 尽管看上去还是有些繁琐，然而相比拟于 SQLite 还是简略不少了，Room 还能帮你检测 SQL 是否正确哈哈。这篇文章曾经很具体的讲了 Jetpack Room 的大部分用法，不过在看完文章后，你仍需多多实际，置信你很快就能够把握 Room 啦😺 因为我自己能力也无限，文章有不对的中央欢送指出，有问题欢送在评论区留言探讨~

对于我

Hello，我是 Taxze，如果您感觉文章对您有价值，心愿您能给我的文章点个❤️，也欢送关注我的博客。

如果您感觉文章还差了那么点货色，也请通过 关注 督促我写出更好的文章——万一哪天我提高了呢？😝

根底系列：

2022 · 让我带你 Jetpack 架构组件从入门到精通 — Lifecycle

学会应用 LiveData 和 ViewModel，我置信会让你在写业务时变得轻松🌞

当你真的学会 DataBinding 后，你会发现“这玩意真香”!

Navigation — 这么好用的跳转治理框架你确定不来看看?

Room：又要写业务代码了？看看我吧，给你飞个别的感觉！(本文🌟)

以下局部还在码字，连忙点个珍藏吧🔥

2022 · 让我带你 Jetpack 架构组件从入门到精通 — Paging3

2022 · 让我带你 Jetpack 架构组件从入门到精通 — WorkManager

2022 · 让我带你 Jetpack 架构组件从入门到精通 — ViewPager2

2022 · 让我带你 Jetpack 架构组件从入门到精通 — 登录注册页面实战（MVVM）

进阶系列:

协程 + Retrofit 网络申请状态封装

Room 缓存封装

…..

正文完
android
发表至： android
2022-07-15
 0
快服务流量之争如何在快服务中占领一席之地
关于android:如何用Nearby-Service让你的游戏实现近距离联机
关于android:关于Android-10以上无法隐藏应用图标问题探究及解决方案
关于android:华为推送-电商应用如何提高用户购买率推送服务助您一臂之力现在接入更有专人为您解决技术问题