Jetpack之Room的使用

Jetpack之Room的使用 Room的使用

Room 在 SQLite 上提供了一个抽象层，以便在充分利用 SQLite 的强大功能的同时，获享更强健的数据库访问机制。

如何配置

...
apply plugin: 'kotlin-kapt' 
...
​
dependencies {
    ...
    kapt "androidx.room:room-compiler:$rootProject.roomVersion"
    implementation "androidx.room:room-runtime:$rootProject.roomVersion"
    implementation "androidx.room:room-ktx:$rootProject.roomVersion"  //目前最新版本是2.3.0
    // 一些支持RxJava的配置可参考
    //implementation "androidx.room:room-rxjava2:$rootProject.roomVersion"
​
    // optional - RxJava3 support for Room
    //implementation "androidx.room:room-rxjava3:$rootProject.roomVersion"
​
    ...
}

Room 包含 3 个主要组件：

• 数据库：包含数据库持有者，并作为应用已保留的持久关系型数据的底层连接的主要接入点。

  使用 @Database 注释的类应满足以下条件：

  • 是扩展 RoomDatabase的抽象类。
  • 在注释中添加与数据库关联的实体列表。
  • 包含具有 0 个参数且返回使用 @Dao注释的类的抽象方法。

  在运行时，您可以通过调用 Room.databaseBuilder() 或 Room.inMemoryDatabaseBuilder()获取 Database的实例。

• Entity：表示数据库中的表。

• DAO：包含用于访问数据库的方法。

应用使用 Room 数据库来获取与该数据库关联的数据访问对象 (DAO)。然后，应用使用每个 DAO 从数据库中获取实体，然后再将对这些实体的所有更改保存回数据库中。 最后，应用使用实体来获取和设置与数据库中的表列相对应的值。

Room 不同组件之间的关系如图 1 所示：

下面以sunflower中的例子作为讲解：

数据库

@Database(entities = [GardenPlanting::class, Plant::class], version = 1, exportSchema = false)
@TypeConverters(Converters::class)
abstract class AppDatabase : RoomDatabase() {
    abstract fun gardenPlantingDao(): GardenPlantingDao  //这是一个Dao类，用于查询数据库中的表
    abstract fun plantDao(): PlantDao  //这是一个Dao类，用于查询数据库中的表
​
    companion object {
​
        // For Singleton instantiation
        @Volatile private var instance: AppDatabase? = null
​
        // 创建一个单例
        fun getInstance(context: Context): AppDatabase {
            return instance ?: synchronized(this) {
                instance ?: buildDatabase(context).also { instance = it }
            }
        }
​
        // Create and pre-populate the database. See this article for more details:
        // https://medium.com/google-developers/7-pro-tips-for-room-fbadea4bfbd1#4785
        private fun buildDatabase(context: Context): AppDatabase {
            return Room.databaseBuilder(context, AppDatabase::class.java, DATAbase_NAME).build()
        }
    }
}

实例类

​
@Entity(
    tableName = "garden_plantings",//这里是一个数据库的表名（注意：不区分大小写，所以建议用小写）
    foreignKeys = [
        ForeignKey(entity = Plant::class, parentColumns = ["id"], childColumns = ["plant_id"])
    ],//外键
    indices = [Index("plant_id")] //用来指定索引列表
)
data class GardenPlanting(
    // 这个列名在数据库中存储的时候为plant_id,我们使用的时候通过plantId来访问，列名也是不区分大小写的
    @ColumnInfo(name = "plant_id") val plantId: String,
    //val plantId: String,这个列名在数据库中存储的时候为plantid
​
    
    @ColumnInfo(name = "plant_date") val plantDate: Calendar = Calendar.getInstance(),
​
    
    @ColumnInfo(name = "last_watering_date")
    val lastWateringDate: Calendar = Calendar.getInstance()
) {
    @PrimaryKey(autoGenerate = true)
    @ColumnInfo(name = "id")
    var gardenPlantingId: Long = 0
}
​
// 这是第二个实体类
@Entity(tableName = "plants")
data class Plant(
    @PrimaryKey @ColumnInfo(name = "id") val plantId: String,
    val name: String,
    val description: String,
    val growZoneNumber: Int,
    val wateringInterval: Int = 7, // how often the plant should be watered, in days
    val imageUrl: String = ""
) {
​
    
    fun shouldBeWatered(since: Calendar, lastWateringDate: Calendar) =
        since > lastWateringDate.apply { add(DAY_OF_YEAR, wateringInterval) }
​
    override fun toString() = name
}
​
​

DAO类

@Dao
interface GardenPlantingDao {
    @Query("SELECt * FROM garden_plantings")
    fun getGardenPlantings(): Flow>
​
    // SQL语句引用传递的参数直接使用 ：符号进行引用。
    @Query("SELECt EXISTS(SELECT 1 FROM garden_plantings WHERe plant_id = :plantId LIMIT 1)")
    fun isPlanted(plantId: String): Flow
​
    
    @Transaction
    @Query("SELECt * FROM plants WHERe id IN (SELECt DISTINCT(plant_id) FROM garden_plantings)")
    fun getPlantedGardens(): Flow>
​
    //如果我们需要向表中插入一条数据,我们直接定义一个方法并用 @Insert注解标注就可以：
    @Insert(onConflict = OnConflictStrategy.REPLACe)
    suspend fun insertGardenPlanting(gardenPlanting: GardenPlanting): Long
​
    //如果需要删除表的数据则使用 @Delete注解：使用主键来查找要删除的实体。
    @Delete
    suspend fun deleteGardenPlanting(gardenPlanting: GardenPlanting)
    
    //还有update注解，这里就不一一列举了
}
​

@Dao
interface PlantDao {
    @Query("SELECT * FROM plants ORDER BY name")
    fun getPlants(): Flow>
​
    @Query("SELECt * FROM plants WHERe growZoneNumber = :growZoneNumber ORDER BY name")
    fun getPlantsWithGrowZoneNumber(growZoneNumber: Int): Flow>
​
    @Query("SELECt * FROM plants WHERe id = :plantId")
    fun getPlant(plantId: String): Flow
​
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertAll(plants: List)
}

以上就是整一个数据库的设计了。那么怎么使用呢？下面还是通过sunflow里面的例子来讲解一下。

  首先看一张MVVM的架构图，从架构图中可以看出，和Room直接交互的一层的Repository层。因为room是给应用提供数据的。而Repository层的功能，正是给应用提供数据。

@Singleton
class PlantRepository @Inject constructor(private val plantDao: PlantDao) {
​
    fun getPlants() = plantDao.getPlants()   //这里的getPlants()的返回值是Flow>，也就是PlantDao里面getPlants的返回值
​
    fun getPlant(plantId: String) = plantDao.getPlant(plantId)
​
    fun getPlantsWithGrowZoneNumber(growZoneNumber: Int) =
        plantDao.getPlantsWithGrowZoneNumber(growZoneNumber)
}
​

  首先这一段代码对于没有接触过Hilt依赖注入库的同学看起来有一点难理解。但是无关紧要，这里只需要知道，在这个PlantRepository中，通过plantDao去数据库中查找相关的数据，并且返回。 至于plantDao是怎么实例化来的，@Singleton是什么意思 @Inject是什么意思，通通不需要管。现在仓库层有了，那么接下来就是viewmodel去仓库拿东西了。所以接下来看一下viewmodel层是怎么实现的

@HiltViewModel
class PlantListViewModel @Inject internal constructor(
    plantRepository: PlantRepository,
    private val savedStateHandle: SavedStateHandle
) : ViewModel() {
    ...
    private val growZone: MutableStateFlow = MutableStateFlow(
        savedStateHandle.get(GROW_ZONE_SAVED_STATE_KEY) ?: NO_GROW_ZONE
    )
​
    val plants: LiveData> = growZone.flatMapLatest { zone ->
        if (zone == NO_GROW_ZONE) {
            plantRepository.getPlants()
        } else {
            plantRepository.getPlantsWithGrowZoneNumber(zone)
        }
    }.asLiveData()
​
    init {
        viewModelScope.launch {
            growZone.collect { newGrowZone ->
                savedStateHandle.set(GROW_ZONE_SAVED_STATE_KEY, newGrowZone)
            }
        }
    }
    ...
}
​

viewmodel里面的代码对于很多不熟悉jetpack同学来说看起来是很蒙圈的，但是无关紧要，我们只要简单分析plants这个方法就可以，知道他是用来做什么的。至于相关的flow或者其他的知识点，可以先忽略。

plants是一个LivaData数据类型的数据，LiveData数据最大的特点就是，如果数据源发生变化了，那么他会主动通知观察这个LiveData的观察者。 那么这个plants是用来做什么的？首先plantRepository.getPlants()和 plantRepository.getPlantsWithGrowZoneNumber(zone)都是PlantRepository里面的方法，而上面讲到，PlantRepository其实就是从数据库里面去拿数据。所以可以知道plants其实就是从数据库里面取出来的数据，只不过数据库取出来的是Flow>，这里经过转换变成了LiveData> 。那么现在就剩下UI层观察这个plants整一个链路就完整了。

@AndroidEntryPoint
class PlantListFragment : Fragment() {
    ...
    private val viewModel: PlantListViewModel by viewModels()
​
    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        
        subscribeUi(adapter)
​
    }
    
    // 这里去观察viewModel.plants，当viewmodel的plants发生变化的时候会主动调用 adapter.submitList(plants)
    private fun subscribeUi(adapter: PlantAdapter) {
        viewModel.plants.observe(viewLifecycleOwner) { plants ->
            adapter.submitList(plants)
        }
    }
    ...
}
​

以上就是room在项目中的简单使用了。关于room的知识点还有块比较重要的就是数据库版本的升级，这一块知识点网上有一位老哥写的非常的不错。链接贴在下面了。如果在有关room方面有什么不懂的，欢迎留言探讨。

这一篇博客涉及到很多jetpack的知识点。之后我都会写一些博客专门讲解，欢迎大家的关注。谢谢。

关于数据库版本的升级请参考：https://juejin.cn/post/6844903889611800584#heading-5

sunflower的地址：https://github.com/android/sunflower