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<User>
  
  
      @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)表示一旦出现冲突就走替换的原则。

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

查询语句可以返回MaybeSingleObservable or Flowable

fun getUserById(id: String): Maybe<User>
fun getUserById(id: String): Single<User>
fun getUserById(id: String): Observable<User>
fun getUserById(id: String): Flowable<User>  
  • 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()
  }