Dagger 2 获得自己的 Room 实例

Question

我想向房间数据库添加回调以填充初始数据。

@Provides
@Singleton
fun provideRoom(context: Context): MyRoomDatabase {
    return Room.databaseBuilder(context, MyRoomDatabase::class.java, "my_database")
        .fallbackToDestructiveMigration()
        .addCallback(object : RoomDatabase.Callback() {
            @Override
            override fun onCreate(db: SupportSQLiteDatabase) {
                super.onCreate(db)

            }
        })
        .build()
}

为此，我需要回调中的数据库实例来访问 DAO 以插入数据。 这是如何工作的？

编辑：

我想要达到的目标： Create initial data for the room database at the app installation

我的Callback Class：

class RoomCallback(
 var myRoomDatabase : MyRoomDatabase
)  : RoomDatabase.Callback()  {
override fun onCreate(db: SupportSQLiteDatabase) {
    myRoomDatabase.basicItemDao().insertList(
        listOf(
            BasicItem(),
            BasicItem()
        )
    )
}

}

我如何提供RoomDatabase 和RoomCallback：

@Provides
@Singleton
fun provideRoom(context: Context, roomCallback: RoomCallback): MyRoomDatabase {
    return Room.databaseBuilder(context, MyRoomDatabase::class.java, "my_database")
        .fallbackToDestructiveMigration()
        .addCallback(roomCallback)    
        .build()
}

@Provides
@Singleton
fun provideRoomCallback(myRoomDatabase: MyRoomDatabase): RoomCallback {
    return RoomCallback(myRoomDatabase)
}

问题： - RoomCallback 和 RoomDatabase 实例需要另一个实例。

Answer 1

更新：使用Kotlin Coroutine 和Dagger2

晚会，但对于未来的读者来说，在创建时或打开时预填充您的数据库非常容易。确保您已经在gradle 文件中为Coroutine 添加了依赖项。首先创建您的数据库，如：

    /**
     * Main database.
     */
    @Database(
        entities = [
            Login::class],
        version = 1,
        exportSchema = false
    )
    abstract class AppDatabase : RoomDatabase() {
        abstract fun loginDao(): LoginDao

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

            fun getInstance(app: Application): AppDatabase = INSTANCE ?: synchronized(this) {
            INSTANCE ?: buildDatabase(app).also { INSTANCE = it }
        }

        private fun buildDatabase(app: Application) =
            Room.databaseBuilder(app,
                AppDatabase::class.java,
                "your database name")
            .addCallback(object : Callback() {
                // Pre-populate the database after onCreate has been called. If you want to prepopulate at opening time then override onOpen function instead of onCreate.
                override fun onCreate(db: SupportSQLiteDatabase) {
                    super.onCreate(db)
                    // Do database operations through coroutine or any background thread
                    val handler = CoroutineExceptionHandler { _, exception ->
                        println("Caught during database creation --> $exception")
                    }

                    CoroutineScope(Dispatchers.IO).launch(handler) {
                        prePopulateAppDatabase(getInstance(app).loginDao())
                    }
                }
            })
            .build()

        suspend fun prePopulateAppDatabase(loginDao: LoginDao) {
            val admin = Login(0, "Administrator", "1234", 1, isActive = true, isAdmin = true, isLogged = false)
            loginDao.insertLoginData(admin)
        }
    }
}

然后您可以通过将以下代码放置在您的匕首 AppModule 或您希望的单独数据库模块中来提供单例实例。

@Singleton
@Provides
fun provideDb(app: Application): AppDatabase {
    return AppDatabase.getInstance(app)
}

@Singleton
@Provides
fun provideLoginDao(db: AppDatabase): LoginDao {
    return db.loginDao()
}

就是这样，你完成了。在任何地方注入你的单例数据库对象，例如：

@Inject lateinit var loginDao: LoginDao

然后使用它。

Answer 2

先设置数据库

@Database(
    entities = [User::class],
    version = VERSION_CODE
)
abstract class DatabaseManager : RoomDatabase() {
    abstract fun userDao(): UserDao
}

现在创建一个数据库模块

@Module
class DatabaseModule {

    @Singleton
    @Provides
    fun provideRoomDatabase(@ApplicationContext context: Context): RoomDatabase {
        return Room.databaseBuilder(context, RoomDatabase::class.java, "dbName")
            .setJournalMode(JournalMode.TRUNCATE)
            .build()
    }
}

您可以创建一个单独的模块或在DatabaseModule 中添加一个方法，它自提供dao 对象。比如说我有一个UserDao 然后

@Module
class UserModule {

    @Singleton
    @Provides
    fun provideDao(database: DatabaseManager): UserDao {
        return database.userDao()
    }
}