Kotlin Common篇之五 Room

首发于公众号: DSGtalk1989

我们选择使用google的官方ORM框架room

先引入依赖

//database room
  implementation "androidx.room:room-runtime:2.1.0-alpha06"
  implementation "androidx.room:room-rxjava2:2.1.0-alpha06"
  kapt "androidx.room:room-compiler:2.1.0-alpha06"

这里要注意哦，你可以直接使用Room库，不需要依赖rxjava2。但是本身Room的操作都是阻塞的，是同步调用，不结合的话，我们需要通过自己的方式去进行线程切换，异步回调等操作，所以此处建议使用跟Rxjava结合的方式来使用Room

然后创建一个数据类User

@Entity(tableName = "users")
  data class User(
      @PrimaryKey
      @ColumnInfo(name = "userid")
      val id: String = UUID.randomUUID().toString(),
      @ColumnInfo(name = "username")
      val name: String
  )

几个注解类的理解比较简单，@Entity(tableName = "users")表示表名叫做users，如果没有指定，就是用类名User作为表名。@PrimaryKey用来设置主键，务必唯一，此处使用的UUID，当然也可以使用@PrimaryKey(autoGenerate = true)结合int类型来做自增长主键。

创建相应的数据操作类UserDao

@Dao
  interface UserDao {
  
      @Query("SELECT * FROM users WHERE userid = :id")
      fun getUserById(id: String): Flowable
  
  
      @Insert(onConflict = OnConflictStrategy.REPLACE)
      fun insertUser(user: User): Completable
  
  
      @Query("DELETE FROM users")
      fun deleteAllUsers()
  
      @Delete
      fun deleteUser(user: User)
  }

同样存在一些注解理解，首先接口上面只要注解一个@Dao即可。在具体方法上，加上@Query注解，跟上具体的sql语句即可，结合rxjava，直接可以拿到包裹结果的Observable或者Flowable对象。很明显的@Insert和@Delete分别对应的插入和删除，跟在@Insert后面的(onConflict = OnConflictStrategy.REPLACE)表示一旦出现冲突就走替换的原则。

插播一下，针对查询语句的返回对象，和非查询语句的返回对象我们做如下说明。

查询语句可以返回Maybe，Single，Observable or Flowable

fun getUserById(id: String): Maybe
fun getUserById(id: String): Single
fun getUserById(id: String): Observable
fun getUserById(id: String): Flowable  

• Maybe

  如果查询不到，Maybe触发complete；如果查询到用户，Maybe触发success；

• Single

  如果查询不到，Maybe触发error；如果查询到用户，Maybe触发success，然后触发complete；

• Observable & Flowable

  如果查询不到，Observable & Flowable什么都不触发；如果查询到用户，Observable & Flowable触发next；有意思的是，这两个对象会对数据库保持持续的观察，一旦数据库有变动会再次出发next，自始至终不会触发complete。

创建数据库抽象类，包含着user这张表的数据库对象

@Database(entities = [User::class], version = 1)
  abstract class UsersDatabase : RoomDatabase() {
      abstract fun userDao(): UserDao
  
      companion object {
  
          @Volatile
          private var INSTANCE: UsersDatabase? = null
  
          fun getInstance(context: Context): UsersDatabase =
              INSTANCE ?: synchronized(this) {
                  INSTANCE ?: buildDatabase(context).also { INSTANCE = it }
              }
  
          private fun buildDatabase(context: Context) =
              Room.databaseBuilder(
                  context.applicationContext,
                  UsersDatabase::class.java, "Sample.db"
              )
                  .build()
      }
  }

这里依然有比较明显的格式要求与书写习惯，略微有些晦涩，我们一个一个看。

第一个@Database表示这是一个数据库抽象类，第一个属性entities表示这个数据库里面包含了几个实体，然后是version表示这是数据库的第几个版本。

整个类需要抽象并且继承RoomDatabase，同时将我们刚才定义的数据操作类UserDao写成同名抽象方法（此处的抽象方法和上面的entities注意对应起来）直接理解成规范即可，框架会帮我们自动生成相应实现。

下面是一个比较经典的单例实现。具体分析可见Kotlin的伴生对象()

其中出现了比较经典的基础操作符also用法

INSTANCE ?: buildDatabase(context).also { INSTANCE = it }

如果INSTANCE为空，就去调用buildDatabase方法，同时将结果返回给外面的getInstance方法，并且将结果也赋值给INSTANCE对象，我们来捋一捋，通常没有这个操作符的话，我们的代码应该是这样的。

fun getInstanceNoAlso(context: Context): UsersDatabase =
          INSTANCE ?: synchronized(this) {
              if (INSTANCE == null){
                  INSTANCE = buildDatabase(context)
              }
              INSTANCE!!
          }

就比较丑陋了，完全没有上面那中一气呵成的感觉，并且最后还要来个INSTANCE!!，明显感觉不开心。

最后在需要调用的地方直接

UsersDatabase.getInstance(this).userDao().getUserById("test")

注：由于考虑到直接使用application即可，所以我们其实并不一定要传入context对象，所以我们优化一下的话UsersDatabase的单例可以简单如斯

companion object {

      val instance: UsersDatabase by lazy {
          buildDatabase()
      }

      private fun buildDatabase() =
          Room.databaseBuilder(
              FrameApplication.instance,
              UsersDatabase::class.java, "Sample.db"
          )
              .build()
  }