JetPack知识点实战系列八：Room数据库实现增删改查和事务处理

本节我们来利用Room实现歌单标签的增删改查，即安装APP的时候默认添加一些歌单标签存入“我的歌单标签”数据库中，在歌单标签编辑页面可以对“我的歌单标签”进行增删改查，并且能对“我的歌单标签”的歌单进行序列重排。

大体效果如下图所示:

实现功能

本节可能您将学习到如下知识点：

Room的使用方法，包括Entity，Dao，Database的使用等
创建数据库时进行一些初始化操作
网络数据和数据库数据同时获取，然后组装数据
数据库的增删改查事务的实现

添加Room依赖

在app的build.gradle中加入如下依赖

def room_version = "2.2.5"
implementation "androidx.room:room-runtime:$room_version"
kapt "androidx.room:room-compiler:$room_version"
implementation "androidx.room:room-ktx:$room_version"

第一个和第二个是必须的，第三个是Room的Kotlin扩展库，如果Room和协程一起使用的时候需要添加这个依赖。

Room详细介绍

使用Room需要定义先定义Entity，Dao，Database，按照JetPack的分层，ViewModel对Database的操作还有一个Repository层。

接下来我们一个个介绍。

Entity (实体)

Entity可以简单理解为映射的一张表，它的定义如下：

@Entity(tableName = "play_list_tags")
data class PlayListTag(
    @PrimaryKey(autoGenerate = false)
    val id: Int,
    val name: String,
    val type: Int,
    val category: Int,
    val hot: Boolean,
    var draggable: Boolean,  
    var disabled: Boolean,   
    @ColumnInfo (name = "tag_sequence")
    var sequence: Int        // 在数组中的序列
    )

Entity需要用@Entity注解，注解中有一个元素tableName，表示对应的数据库表名。
Entity必须要要有一个主键，可以用@PrimaryKey注解标记主键，autoGenerate表示这个主键是否是自增长
用@ColumnInfo可以给表的列定义一个列名，可以和Entity的属性名不一致

Dao (数据访问对象)

Dao需要定义为Interface，且标记为@Dao注解.

为了比较完整的了解Dao, 我们的PlayListTagDao定义如下：

@Dao
interface PlayListTagDao {

    @Query("SELECT id, name, type, category, hot, draggable, disabled, tag_sequence FROM play_list_tags ORDER BY tag_sequence ASC;")
    fun getAllTags(): LiveData<List<PlayListTagResponse.PlayListTag>>

    @Query("SELECT id, name, type, category, hot, draggable, disabled, tag_sequence FROM play_list_tags ORDER BY tag_sequence ASC;")
    suspend fun getTags(): List<PlayListTagResponse.PlayListTag>

    @Insert(onConflict = OnConflictStrategy.IGNORE)
    suspend fun insertAllTags(tags: List<PlayListTagResponse.PlayListTag>)

    @Insert(onConflict = OnConflictStrategy.IGNORE)
    suspend fun insertTag(tag: PlayListTagResponse.PlayListTag)

    @Update(onConflict = OnConflictStrategy.REPLACE)
    suspend fun updatePlayListTag(tag: PlayListTagResponse.PlayListTag)

    @Delete
    suspend fun deletePlayListTag(tag: PlayListTagResponse.PlayListTag)
    
    @Transaction
    suspend fun updatePlayListTags(tags: List<PlayListTagResponse.PlayListTag>) {
        for (tag in tags) {
            updatePlayListTag(tag)
        }
    }

}

我们来分析下上面这些增删改查和事务的几个方法：

getAllTags有一个注解@Query,表示是一个查询方法，"SELECT id, name, type, category, hot, draggable, disabled, tag_sequence FROM play_list_tags ORDER BY tag_sequence ASC;" 表示查询所有歌单标签的方法；这个方法的返回值是LiveData, 即这个查询方法会异步执行，且只要数据库数据有变化这个LiveData都会通知观察者数据的变化。
getTags和getAllTags一样是查询所有歌单标签的方法，但是返回值是List, 这个函数是suspend函数，也是异步执行，两个方法的差别是数据库数据变化后getTags无法及时监听到变化。需要主动调用才能获取新的数据。
insertAllTags和insertTag都有@Insert注解，表示是插入数据的方法，onConflict元素表示的是如果遇到了冲突的处理策略，我们这里使用的是OnConflictStrategy.IGNORE即忽略冲突。
updatePlayListTag有@Update注解，表示是一个更新数据的方法，更新我们使用的策略是nConflictStrategy.REPLACE即取代旧数据同时继续事务。
deletePlayListTag有@Delete注解，表示是一个删除数据的方法。
updatePlayListTags有@Transaction注解，表示这个方法是一个事务，这个事务的功能是一次更新多个PlayListTag。

Database (数据库)

Database的定义

使用@Database注解可以定义数据库持有者。具体的定义如下:

@Database(version = 1, entities = [PlayListTagResponse.PlayListTag::class], exportSchema = false)
abstract class MusicDatabase : RoomDatabase() {

    abstract fun playListDao(): PlayListTagDao

}

@Database注解中的version表示数据库版本号，entities中表示的是实体列表，我们目前只有一个实体类PlayListTagResponse.PlayListTag，exportSchema设置为false。
Database为抽象类，且继承自RoomDatabase。
playListDao为抽象方法，返回PlayListTagDao，即我们上面定义的Dao.

Database的初始化

Database的初始化需要先使用Room.databaseBuilder方法，这个方法几个参数：

Room.databaseBuilder(application, MusicDatabase::class.java, "music_database")
                    .build()

参数一：context，我们可以使用Application
参数二：Class，即我们定义的Database的class
参数三：name, 这个参数表示的就是数据库的名字

Room.databaseBuilder方法生成的RoomDatabase.Builder对象调用build方法就生成了MusicDatabase对象

一般为了方便使用，我们可以在MusicDatabase类里面定义一个静态方法初始化一个单例对象。

修改后的代码如下：

@Database(version = 1, entities = [PlayListTagResponse.PlayListTag::class], exportSchema = false)
abstract class MusicDatabase : RoomDatabase() {
    
    abstract fun playListDao(): PlayListTagDao

    companion object {
        @Volatile
        private var INSTANCE: MusicDatabase? = null
        fun getInstance(application: Application): MusicDatabase {
            val tempInstance = INSTANCE
            if (tempInstance != null) {
                return tempInstance
            }
            synchronized(this) {
                val instance = Room.databaseBuilder(application, MusicDatabase::class.java, "music_database")
                    .build()
                INSTANCE = instance
                return instance
            }
        }
    }
}

上面代码的companion object里面的getInstance方法就返回了MusicDatabase的单例对象INSTANCE。

Repository (仓库)

仓库相对简单，就是调用Dao的方法，比较简单。

所有的数据库操作应该是异步的，所以和Dao对应，PlayListTagRepository中所有的方法也是suspend函数。

class PlayListTagRepository(private val dao: PlayListTagDao) {


    suspend fun getTags(): List<PlayListTagResponse.PlayListTag> {
        return dao.getTags()
    }

    fun getAllTags(): LiveData<List<PlayListTagResponse.PlayListTag>> {
        return dao.getAllTags()
    }

    suspend fun insertAllTags(tags: List<PlayListTagResponse.PlayListTag>) {
        return dao.insertAllTags(tags)
    }

    suspend fun insertTag(tag: PlayListTagResponse.PlayListTag) {
        return dao.insertTag(tag)
    }

    suspend fun deletePlayListTag(tag: PlayListTagResponse.PlayListTag) {
        return dao.deletePlayListTag(tag)
    }

    suspend fun updatePlayListTag(tag: PlayListTagResponse.PlayListTag) {
        return dao.updatePlayListTag(tag)
    }

    suspend fun updatePlayListTags(tags: List<PlayListTagResponse.PlayListTag>) {
        dao.updatePlayListTags(tags)
    }

}

DataBase创建时插入数据

RoomDatabase.Callback回调函数可以在数据库创建时，或者数据库打开的时候进行一些操作，我们需要在数据库创建时候添加一些默然的5个歌单标签，包括推荐，官方，精品，华语和流行。

private class MusicDatabaseCallBack: RoomDatabase.Callback() {
    // 1
    override fun onCreate(db: SupportSQLiteDatabase) {
        super.onCreate(db)
        INSTANCE?.let {
            val list = listOf(
                PlayListTagResponse.PlayListTag(-10, "推荐", 0, 0, hot = false, draggable = false, disabled = false, sequence = 0),
                PlayListTagResponse.PlayListTag(-20, "官方", 0, 0, hot = false, draggable = false, disabled = false, sequence = 1),
                PlayListTagResponse.PlayListTag(-30, "精品", 0, 0, hot = false, draggable = false, disabled = false, sequence = 2),
                PlayListTagResponse.PlayListTag(5001, "华语", 0, 0, hot = false, draggable = true, disabled = false, sequence = 3),
                PlayListTagResponse.PlayListTag(1, "流行", 0, 1, hot = false, draggable = true, disabled = false, sequence = 4)
            )
            // 2
            GlobalScope.launch {
                it.playListDao().insertAllTags(list)
            }
        }
    }
}

onCreate在数据库创建时会调用，这里我们插入默认的数据
GlobalScope.launch实现异步插入。

接下来修改Database的初始化方法，添加addCallback传入MusicDatabaseCallBack。

val instance = Room.databaseBuilder(application, MusicDatabase::class.java, "music_database")
                    // 回调函数
                    .addCallback(MusicDatabaseCallBack())
                    .build()

Room实现歌单广场界面标签的Tab

歌单广场界面的标签根据数据库存储的标签列表展示，由于默认增加了5个标签，所以如果没有编辑的话，默认展示的就是这5个从数据库获取的标签，即：推荐，官方，精品，华语和流行。

添加一个PlayListSquareViewModel类，获取所有的歌单标签。

class PlayListSquareViewModel(application: Application): AndroidViewModel(application) {

    private val playListTagRepository: PlayListTagRepository

    init {

        val tagDao = MusicDatabase.getInstance(application).playListDao()
        playListTagRepository = PlayListTagRepository(tagDao)

    }

    /* 返回所有的Tag */
    fun getAllTags(): LiveData<List<PlayListTagResponse.PlayListTag>> {
        return playListTagRepository.getAllTags()
    }

}

PlayListSquareViewModel继承自AndroidViewModel，持有一个PlayListTagRepository对象

AndroidViewModel继承自ViewModel并且持有一个Application对象，这个Application对象刚好创建是Database对象需要的context。

getAllTags返回所有的歌单标签，并且当数据库中的歌单列表变化后能实时发送给监听者新的数据。

PlayListSquareFragment获取数据

<!-- PlayListSquareFragment.kt -->
private val viewModel by viewModels<PlayListSquareViewModel>()

override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
    super.onViewCreated(view, savedInstanceState)

    // 获取我的Tags
    viewModel.getAllTags().observe(viewLifecycleOwner, Observer { tags ->
        var playListNamesArray = tags.map { it.name }
        // ...
    })

}

经过修改后，得到的效果如下图所示：

歌单广场界面

Room实现歌单标签编辑界面的增删改查

歌单标签编辑界面有些特殊，我的标签列表是从数据库中获取的，而所有的标签列表是从网络获取的。所以界面的展示需要同时从两个Repository仓库获取数据.

歌单编辑界面

ViewModel实现网络和数据库同时获取数据

class PlaylistTagViewModel(application: Application) : AndroidViewModel(application) {
    // 1
    public val playListTagRepository: PlayListTagRepository
    // 2
    private var _tagList: MutableLiveData<Pair<List<PlayListTagResponse.PlayListTag>, List<PlaylistTagSection>>> = MutableLiveData()
    val tagList: LiveData<Pair<List<PlayListTagResponse.PlayListTag>, List<PlaylistTagSection>>> = _tagList

    init {
        val tagDao = MusicDatabase.getInstance(application).playListDao()
        playListTagRepository = PlayListTagRepository(tagDao)
        queryTagsWithDatabaseAndNetwork()
    }

    private fun queryTagsWithDatabaseAndNetwork() {

        viewModelScope.launch(Dispatchers.IO) {
            try {
                // 3
                val networkRequest = async { PlaylistRepository.getPlaylistTags() }
                val databaseRequest = async { playListTagRepository.getTags() }

                val networkResponse = networkRequest.await()
                val databaseResponse = databaseRequest.await()

                // 4
                val section = mutableListOf(
                    PlaylistTagSection(0, "语种", mutableListOf()),
                    PlaylistTagSection(1, "风格", mutableListOf()),
                    PlaylistTagSection(2, "场景", mutableListOf()),
                    PlaylistTagSection(3, "情感", mutableListOf()),
                    PlaylistTagSection(4, "主题", mutableListOf())
                )
                for (tag in networkResponse.tags) {
                    when (tag.category) {
                        0 -> {
                            section[0].list.add(tag)
                        }
                        1 -> {
                            section[1].list.add(tag)
                        }
                        2 -> {
                            section[2].list.add(tag)
                        }
                        3 -> {
                            section[3].list.add(tag)
                        }
                        4 -> {
                            section[4].list.add(tag)
                        }
                    }
                }
                // 5
                withContext(Dispatchers.Main) {
                    _tagList.value = Pair(databaseResponse, section)
                }

            } catch (e: Exception) {

            }

        }
    }
}

代码解释如下：

playListTagRepository利用PlayListTagDao来操作数据库
tagList是数据库和网络数据的组合数据，被提供给Fragment进行界面的展示
用async和await的组合，将两个来源的数据获取都异步进行，且互不阻塞
当两个来源的数据都获得后，进行数据的装配
将数据分发到主线程，刷新界面

增加标签

private fun addMyTag(tag: PlayListTagResponse.PlayListTag) {
    //...
    tag.sequence = mTags.size - 1
    GlobalScope.launch {
        viewModel.playListTagRepository.insertTag(tag)
    }
}

删除标签

private fun removeMyTag(position: Int) {
    //...
    val willDeleteTag = mTags[position]
    GlobalScope.launch {
        viewModel.playListTagRepository.deletePlayListTag(willDeleteTag)
    }
}

两个标签交换位置 - 用事务修改标签

fun onItemMove(fromPosition: Int, toPosition: Int) {
    Collections.swap(mTags, fromPosition - 1, toPosition - 1)
    // 数据库中进行替换
    mTags[toPosition-1].sequence = toPosition - 1
    mTags[fromPosition-1].sequence = fromPosition - 1
    // 用APP的生命周期
    GlobalScope.launch {
        withContext(Dispatchers.IO) {
            viewModel.playListTagRepository.updatePlayListTags(
                listOf(
                    mTags[fromPosition - 1],
                    mTags[toPosition - 1]
                )
            )
        }
    }
}

至此功能就完成了。文中列出了Room相关的关键代码，如果对其他的代码有疑问，可以参阅前面的文章。