与房间访问Android中的SQLite数据的问题。 MVVM架构。 Livedata

Question

以下代码是Android的Kotlin中基于MVVM架构的房间实现。

我对数据库的预先填充有问题。我的数据库没有任何数据，也找不到获取或插入数据的解决方案。

IDE不会提出任何汇编问题。

我认为问题是在ViewModel中，但我处于死胡同。

编辑：我看过DB，人口稠密。插入很好，但不是读取的数据。我将尝试修改ViewModel及其关联的 livedata 和 mutableLive 数据。

这是我的数据类：

@Entity(tableName = Constants.DATABASE_NAME)
data class Card(
    @PrimaryKey(autoGenerate = true) @ColumnInfo(name = Constants.COLUMN_NAME_ID) val id: Int?,
    @ColumnInfo(name = Constants.COLUMN_NAME_FAV) val fav: Boolean,
    @ColumnInfo(name = Constants.COLUMN_NAME_DATE) val date: Date,
    @ColumnInfo(name = Constants.COLUMN_NAME_RAW_VALUE) val rawValue: String,
    @ColumnInfo(name = Constants.COLUMN_NAME_STORE_TYPE) val storeType: String,
    @ColumnInfo(name = Constants.COLUMN_NAME_STORE_NAME) val storeName: String,
    @ColumnInfo(name = Constants.COLUMN_NAME_STORE_NOTES) val storeNotes: String
)

这是我的接口dao

@Insert
suspend fun insertNewCard(card: Card) {
}

@Delete
suspend fun deleteCard(card: Card)

@Query("SELECT * FROM ${Constants.DATABASE_NAME}")
fun getAllCards(): LiveData<List<Card>>

• 更新： 这是我的数据库类

@Database(
    entities = [Card::class],
    version = 1,
    exportSchema = true,
    //autoMigrations = [AutoMigration (from = 1, to = 2)]
)
@TypeConverters(Converters::class)

abstract class CardsDatabase : RoomDatabase() {

    abstract fun cardsDao(): CardsDao

    private class CardsDatabaseCallback(private val scope: CoroutineScope)
        : RoomDatabase.Callback() {

        override fun onCreate(db: SupportSQLiteDatabase) {
            super.onCreate(db)
            INSTANCE?.let { database ->
                scope.launch {
                    populateDatabase(database.cardsDao())
                }
            }
        }

        suspend fun populateDatabase(cardsDao: CardsDao) {
            val testCard = Card(null,
                false,
                ((Calendar.getInstance()).time),
                "test",
                "codebar test 1",
                "Prueba tienda",
                "Esta es una tienda de prueba"
            )
            val testCardTwo = Card(null,
                false,
                ((Calendar.getInstance()).time),
                "barcode test 2",
                "codebar",
                "Prueba tienda 2",
                "Esta es una segunda prueba de tienda"
            )
            Log.d("ROOM", "$testCard")
            cardsDao.insertNewCard(testCard)
        }
    }

    companion object {
        @Volatile
        private var INSTANCE: CardsDatabase? = null

        fun getDatabase(context: Context, scope: CoroutineScope): CardsDatabase {
            return INSTANCE ?: synchronized(this) {
                val  instance = Room.databaseBuilder(
                    context.applicationContext,
                    CardsDatabase::class.java,
                    Constants.DATABASE_NAME)
                    .addCallback(CardsDatabaseCallback(scope))
                    .build()
                INSTANCE = instance
                instance
            }

        }
    }

这是存储库类

val allCards: LiveData<List<Card>> = cardsDao.getAllCards()

@Suppress("RedundantSuspendModifier")
@WorkerThread
suspend fun insertCard(card: Card) {
    cardsDao.insertNewCard(card)
}

suspend fun deleteCard(card: Card) {
    cardsDao.deleteCard(card)
}

这是我的ViewModel：

LogCat在这一点上显示为Null livedata。

private val _allCards = MutableLiveData<List<Card>>()

    val allCards : LiveData<List<Card>> = _allCards

    init {
        getAllCards()
        Log.d("ROOM", "${allCards.value}")
    }

    private fun getAllCards() = viewModelScope.launch {

        _allCards.value = cardRepository.allCards.value

        Log.d("ROOM", "_ : ${_allCards.value}")
    }

    fun insertCard(card: Card) = viewModelScope.launch {
        cardRepository.insertCard(card)
        Log.d("ROOM", "inserted: $card")

    }

}

class CardsViewModelFactory(private val repository: CardRepository) :
    ViewModelProvider.Factory {
    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        if (modelClass.isAssignableFrom(CardsViewModel::class.java)) {
            @Suppress("UNCHECKED_CAST")
            return CardsViewModel(repository) as T
        }
        throw IllegalArgumentException("Unknown ViewModel class")
    }

这是应用程序类别：

private val applicationScope = CoroutineScope(SupervisorJob())

private val database by lazy { CardsDatabase.getDatabase(this, applicationScope) }
val repository by lazy { CardRepository(database.cardsDao()) }

最后，在主动行动中观察到：

cardsViewModel.allCards.observe(this) { cards ->
        cards?.let { adapter.setData(it) }
}

Answer 1

我的版本。

它可以与 classPath'org.jetbrains.kotlin：Kotlin-Gradle-Plugin：1.6.21'

添加到 build> build.gradle ：

plugins {
   id 'kotlin-kapt'
} 

dependencies {
   def room_version = "2.4.2"
   implementation "androidx.room:room-runtime:$room_version"
   kapt "androidx.room:room-compiler:$room_version"
   implementation "androidx.room:room-ktx:$room_version"
   testImplementation "androidx.room:room-testing:$room_version"
}

创建 entity.class：

@Entity(tableName = "cards")
data class CardEntity(
   @PrimaryKey(autoGenerate = true)
   val id: Int = 0,
   val data: String
)

创建 dao.class

@Dao
interface CardDAO {

   @Insert
   suspend fun insert(cardEntity: CardEntity): Long

   @Delete
   suspend fun delete(cardEntity: CardEntity): Int

   @Update
   suspend fun update(cardEntity: CardEntity): Int

   @Query("SELECT * FROM cards WHERE id = :id")
   fun getDataById(id:Int): Flow<CardEntity?>

   @Query("SELECT * FROM cards")
   fun getAll(): Flow<List<CardEntity>>

}

创建 database.class ：
对于工作，您应该使用Singleton

@Database(
   entities = [
       CardEntity::class
   ],
   version = 1
)
abstract class MyDatabase : RoomDatabase() {

   companion object {
       private var INSTANCE: MyDatabase? = null

       fun get(context: Context): MyDatabase {
           if (INSTANCE == null) {
               INSTANCE = Room.databaseBuilder(context, MyDatabase::class.java, 
               "testBase").build()
           }
           return INSTANCE as MyDatabase
       }
   }

   abstract fun cardDAO(): CardDAO

}

Test testDatabase.class ：

@RunWith(AndroidJUnit4::class)
class TestDatabase {

   lateinit var db: MyDatabase

   @Before
   fun createDB() {
       val appContext = 
       InstrumentationRegistry.getInstrumentation().targetContext
       db = Room.inMemoryDatabaseBuilder(appContext, 
       MyDatabase::class.java).build()
   }

   @After
   @Throws(IOException::class)
   fun closeDB() {
       db.close()
   }

   private fun setData() = runBlocking {
       db.cardDAO().insert(CardEntity(data = "1"))
       db.cardDAO().insert(CardEntity(data = "2"))
       db.cardDAO().insert(CardEntity(data = "3"))
       db.cardDAO().insert(CardEntity(data = "4"))
       db.cardDAO().insert(CardEntity(data = "5"))
   }

   @Test
   fun test() = runBlocking {
       setData()

       Assert.assertEquals(db.cardDAO().getAll().first().size, 5)
       val flowIdFirst = db.cardDAO().getDataById(1)
       Assert.assertEquals(flowIdFirst.first()?.data, "1")
       Assert.assertEquals(db.cardDAO().getDataById(2).first()?.data, "2")
       Assert.assertEquals(db.cardDAO().getDataById(3).first()?.data, "3")
       Assert.assertEquals(db.cardDAO().getDataById(4).first()?.data, "4")
       Assert.assertEquals(db.cardDAO().getDataById(5).first()?.data, "5")
       Assert.assertTrue(db.cardDAO().update(CardEntity(1, "my new data")) > 0)
       Assert.assertEquals(flowIdFirst.first()?.data, "my new data")
       Assert.assertTrue(db.cardDAO().delete(CardEntity(1,"")) > 0)
       Assert.assertEquals(flowIdFirst.first(), null)
   }
}

Answer 2

问题是在Dao中创建的Livedata。要修复它：

• 从dao中删除Livedata以返回列表：

@Query("SELECT * FROM ${Constants.DATABASE_NAME}")
 suspend fun getAllCards(): List<Card>

• 从存储库中，使悬挂式有趣的乐趣可以访问DAO并获取列表，然后删除Livedata类型。

suspend fun getAllCards() : List<Card> = cardsDao.getAllCards()

• 更改访问ViewModel中存储库的方法。它可以正常工作。

private fun getAllCards() = viewModelScope.launch {
        _allCards.value = cardRepository.getAllCards()
 }  

已解决。