前言

即学即用Android Jetpack系列Blog的目的是通过学习Android Jetpack完成一个简单的Demo，本文是即学即用Android Jetpack系列Blog的第四篇。

我们在日常的工作中，免不了和数据打交道，因此，存储数据便是一项很重要的工作，在此之前，我使用过GreenDao、DBFlow等优秀的ORM数据库框架，但是，这些框架都不是谷歌官方的，现在，我们有了谷歌官方的Room数据库框架，看看它能够给我们带来什么?

语言：Kotlin
Demo地址：https://github.com/mCyp/Hoo

目录

目录

一、介绍

友情提示
官方文档：Room
谷歌实验室：官方教程
SQL语法：SQLite教程

谷歌官方的介绍：

The Room persistence library provides an abstraction layer over SQLite to allow for more robust database access while harnessing the full power of SQLite.

简单来说：Room是一个基于SQLite的强大数据库框架。

1. Room优点

可是它强大在哪里呢？

• 使用编译时注解，能够对@Query和@Entity里面的SQL语句等进行验证。
• 与SQL语句的使用更加贴近，能够降低学习成本。
• 对RxJava 2的支持（大部分都Android数据库框架都支持），对LiveData的支持。
• @Embedded能够减少表的创建。

二、实战

我们的目标结构：

目标ER图

第一步 添加依赖

模块层的build.gradle添加：

apply plugin: 'kotlin-kapt'

dependencies {
    // ... 省略无关

    // room
    implementation "androidx.room:room-runtime:$rootProject.roomVersion"
    implementation "androidx.room:room-ktx:$rootProject.roomVersion"
    kapt "androidx.room:room-compiler:$rootProject.roomVersion"
    androidTestImplementation "androidx.room:room-testing:$rootProject.roomVersion"
}

项目下的build.gradle添加：

ext {
   roomVersion = '2.1.0-alpha06'
   //... 省略无关
}

第二步 创建表（实体）

这里我们以用户表和收藏记录表为例，用户表：

/**
 * 用户表
 */
@Entity(tableName = "user")
data class User(
    @ColumnInfo(name = "user_account") val account: String // 账号
    , @ColumnInfo(name = "user_pwd") val pwd: String // 密码
    , @ColumnInfo(name = "user_name") val name: String
    , @Embedded val address: Address // 地址
    , @Ignore val state: Int // 状态只是临时用，所以不需要存储在数据库中
) {
    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name = "id")
    var id: Long = 0
}

收藏记录表：

/**
 * 喜欢的球鞋
 */
@Entity(
    tableName = "fav_shoe"
    , foreignKeys = [ForeignKey(entity = Shoe::class, parentColumns = ["id"], childColumns = ["shoe_id"])
        , ForeignKey(entity = User::class, parentColumns = ["id"], childColumns = ["user_id"])
    ],indices = [Index("shoe_id")]
)
data class FavouriteShoe(
    @ColumnInfo(name = "shoe_id") val shoeId: Long // 外键 鞋子的id
    , @ColumnInfo(name = "user_id") val userId: Long // 外键 用户的id
    , @ColumnInfo(name = "fav_date") val date: Date // 创建日期

) {
    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name = "id")
    var id: Long = 0
}

对于其中的一些注解，你可能不是很明白，解释如下：

最后一个可能解释的不明，我们直接看例子就好，如我们的用户表，里面有一个变量address，它是一个Address类：

/**
 * 地址
 */
data class Address(
    val street:String,val state:String,val city:String,val postCode:String
)

通常情况下，如果我们想这些字段存储在数据库中，有两种方法：

• 重新创建一个表进行一对一关联，但是多创建一个表显得麻烦。
• 在用户表中增加字段，可是使用第二种方式映射出来的对象又显得不那么面向对象。

@Embedded解决了第二种方式中问题，既不需要多创建一个表，又能将数据库中映射的对象看上去面向对象。

放上Shoe表，后面会用到：

/**
 * 鞋表
 */
@Entity(tableName = "shoe")
data class Shoe(
    @ColumnInfo(name = "shoe_name") val name: String // 鞋名
    , @ColumnInfo(name = "shoe_description") val description: String// 描述
    , @ColumnInfo(name = "shoe_price") val price: Float // 价格
    , @ColumnInfo(name = "shoe_brand") val brand: String // 品牌
    , @ColumnInfo(name = "shoe_imgUrl") val imageUrl: String // 图片地址
) {
    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name = "id")
    var id: Long = 0
}

第三步 创建Dao

有了数据库，我们现在需要建立数据处理的方法，就是数据的增删查改。如果想声明一个Dao，只要在抽象类或者接口加一个@Dao注解就行。

增

@Insert注解声明当前的方法为新增的方法，并且可以设置当新增冲突的时候处理的方法。

用到增的地方有很多，Demo中本地用户的注册、鞋子集合的新增和收藏的新增，这里我们选择具有代表性的shoeDao：

/**
 * 鞋子的方法
 */
@Dao
interface ShoeDao {
    // 省略...
    // 增加一双鞋子
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insertShoe(shoe: Shoe)

    // 增加多双鞋子
    // 除了List之外，也可以使用数组
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    fun insertShoes(shoes: List<Shoe>)
}

删

@Delete注解声明当前的方法是一个删除方法。

用法与@Insert类似，同样以ShoeDao为例：

/**
 * 鞋子的方法
 */
@Dao
interface ShoeDao {
    // 省略...
    // 删除一双鞋子
    @Delete
    fun deleteShoe(shoe: Shoe)

    // 删除多个鞋子
    // 参数也可以使用数组
    @Delete
    fun deleteShoes(shoes:List<Shoe>)
}

改

@Update注解声明当前方法是一个更新方法

用法同样与@Insert类似：

/**
 * 鞋子的方法
 */
@Dao
interface ShoeDao {
    // 省略...
    // 更新一双鞋
    @Update
    fun updateShoe(shoe:Shoe)

    // 更新多双鞋
    // 参数也可以是集合
    @Update
    fun updateShoes(shoes:Array<Shoe>)
}

查

增删改是如此的简单，查是否也是如此的简单呢？答案是否定的，Room的查很接近原生的SQL语句。@Query注解不仅可以声明这是一个查询语句，也可以用来删除和修改，不可以用来新增。

简单查询
除了简单查询，这里还有如何配合LiveData和RxJava 2。

@Dao
interface ShoeDao {

    // 查询一个
    @Query("SELECT * FROM shoe WHERE id=:id")
    fun findShoeById(id: Long): Shoe?

    // 查询多个 通过品牌查询多款鞋 
    @Query("SELECT * FROM shoe WHERE shoe_brand=:brand")
    fun findShoesByBrand(brand: String): List<Shoe>

    // 模糊查询 排序 同名鞋名查询鞋
    @Query("SELECT * FROM shoe WHERE shoe_name LIKE :name ORDER BY shoe_brand ASC")
    fun findShoesByName(name:String):List<Shoe>

    // 配合LiveData 返回所有的鞋子
    @Query("SELECT * FROM shoe")
    fun getAllShoesLD(): LiveData<List<Shoe>>

    // 配合LiveData 通过Id查询单款鞋子
    @Query("SELECT * FROM shoe WHERE id=:id")
    fun findShoeByIdLD(id: Long): LiveData<Shoe>

    // 配合RxJava 通过Id查询单款鞋子
    @Query("SELECT * FROM shoe WHERE id=:id")
    fun findShoeByIdRx(id: Long): Flowable<Shoe>

    // 省略...
}

查询多个的时候，可以返回List和数组，还可以配合LiveData和RxJava 2。当然，更多的查询可以参考SQL语法。

复合查询
因为本Demo并没有引入RxJava 2，所以本文基本以LiveData为例。

@Dao
interface ShoeDao {
    // 省略...
    // 根据收藏结合 查询用户喜欢的鞋的集合 内联查询
    @Query(
        "SELECT shoe.id,shoe.shoe_name,shoe.shoe_description,shoe.shoe_price,shoe.shoe_brand,shoe.shoe_imgUrl " +
                "FROM shoe " +
                "INNER JOIN fav_shoe ON fav_shoe.shoe_id = shoe.id " +
                "WHERE fav_shoe.user_id = :userId"
    )
    fun findShoesByUserId(userId: Long): LiveData<List<Shoe>>
}

第四步 创建数据库

创建一个数据库对象是一件非常消耗资源，使用单例可以避免过多的资源消耗。

/**
 * 数据库文件
 */
@Database(entities = [User::class,Shoe::class,FavouriteShoe::class],version = 1,exportSchema = false)
abstract class AppDataBase:RoomDatabase() {
    // 得到UserDao
    abstract fun userDao():UserDao
    // 得到ShoeDao
    abstract fun shoeDao():ShoeDao
    // 得到FavouriteShoeDao
    abstract fun favouriteShoeDao():FavouriteShoeDao

    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,"jetPackDemo-database")
                .addCallback(object :RoomDatabase.Callback(){
                    override fun onCreate(db: SupportSQLiteDatabase) {
                        super.onCreate(db)

                        // 读取鞋的集合
                        val request = OneTimeWorkRequestBuilder<ShoeWorker>().build()
                        WorkManager.getInstance(context).enqueue(request)
                    }
                })
                .build()
        }
    }
}

@Database注解声明当前是一个数据库文件，注解中entities变量声明数据库中的表（实体），以及其他的例如版本等变量。同时，获取的Dao也必须在数据库类中。完成之后，点击build目录下的make project，系统就会自动帮我创建AppDataBase和xxxDao的实现类。

第五步 简要封装

这里有必要提醒一下，在不使用LiveData和RxJava的前提下，Room的操作是不可以放在主线程中的。这里选择比较有示范性的UserRepository：

/**
 * 用户处理仓库
 */
class UserRepository private constructor(private val userDao: UserDao) {
    //...

    /**
     * 登录用户 本地数据库的查询
     */
    fun login(account: String, pwd: String):LiveData<User?>
            = userDao.login(account,pwd)

    /**
     * 注册一个用户 本地数据库的新增
     */
    suspend fun register(email: String, account: String, pwd: String):Long {
        return withContext(IO) {
             userDao.insertUser(User(account, pwd, email))
        }
    }

    companion object {
        @Volatile
        private var instance: UserRepository? = null
        fun getInstance(userDao: UserDao): UserRepository =
            // ...
    }
}

register()方法是一个普通方法，所以它需要在子线程使用，如代码所见，通过协程实现。login()是配合LiveData使用的，不需要额外创建子线程，但是他的核心数据库操作还是在子线程中实现的。

现在，你就可以愉快的操作本地数据库了。

三、更多

除了上面的基本使用技巧之外，还有一些不常用的知识需要我们了解。

1. 类型转换器

我们都知道，SQLite支持的类型有：NULL、INTEGER、REAL、TEXT和BLOB，对于Data类，SQLite还可以将其转化为TEXT、REAL或者INTEGER，如果是Calendar类呢？Room为你提供了解决方法，使用@TypeConverter注解，我们使用谷歌官方Demo-SunFlower例子：

class Converters {
    @TypeConverter fun calendarToDatestamp(calendar: Calendar): Long = calendar.timeInMillis

    @TypeConverter fun datestampToCalendar(value: Long): Calendar =
            Calendar.getInstance().apply { timeInMillis = value }
}

然后在数据库声明的时候，加上@TypeConverters(Converters::class)就行了：

@Database(...)
@TypeConverters(Converters::class)
abstract class AppDatabase : RoomDatabase() {
    //...
}

2. 数据库迁移

Room的数据库迁移实在是麻烦，同查询一样，需要使用到SQL语句，但比查询麻烦的多。感兴趣的各位可以参考下面的文章：

《Understanding migrations with Room》 谷歌工程师写的
《Android Room 框架学习》

四、总结

总结

参考文章：

《Android Room 框架学习》
《7 Steps To Room》

🚀如果觉得本文不错，可以查看Android Jetpack系列的其他文章：

第一篇：《即学即用Android Jetpack - Navigation》
第二篇：《即学即用Android Jetpack - Data Binding》
第三篇：《即学即用Android Jetpack - ViewModel & LiveData》
第五篇：《即学即用Android Jetpack - Paging》
第六篇：《即学即用Android Jetpack - WorkManger》
第七篇：《即学即用Android Jetpack - Startup》
第八篇：《即学即用Android Jetpack - Paging 3》
项目总结篇：《学习Android Jetpack? 实战和教程这里全都有！》