Question

您好我有2个应用程序依赖于创建和恢复应用程序数据库的备份，只需将数据库文件复制到SD卡中，然后很难确定如何在关闭它之后重新打开Room Database单例。制作数据库的副本。

构建数据库：

@Database(version = 15, exportSchema = true, entities = [list of entities])
abstract class AppDatabase : RoomDatabase() {

//list of DAOs

companion object {

    @Volatile private var INSTANCE: AppDatabase? = null

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

    private fun buildDatabase(context: Context) =

            Room.databaseBuilder(
                    context.applicationContext,
                    AppDatabase::class.java,
                    "Fazendao.sqlitedb"
            )
            .addMigrations(Migration1315)
            .build()

    }
}

关闭数据库：

fun closeDatabase() {
    if(db.isOpen) {
        db.openHelper.close()
    }
}

使数据库文件复制（在ViewModel中）：

fun exportaBkpObservable(nome: String, auto: String, storage: File, database: File) {
    disposable.clear()
    setFlagsNull()

    flagSubject.onNext(false)

    disposable.add(
            Observable.fromCallable {
                repo.recordBkpName(nome)
            }
            .subscribeOn(Schedulers.io())
            .flatMap {
                return@flatMap try {

                    //closing the database
                    repo.closeDatabase()

                    Observable.just(
                        database.copyTo(File(storage, auto), true)
                    )
                    .flatMap {

                        val myDb = SQLiteDatabase.openOrCreateDatabase(it, null)
                        val ok = myDb.isDatabaseIntegrityOk

                        if(myDb.isOpen) myDb.close()

                        if(ok) {
                            Observable.just(ok)
                        } else {
                            Observable.error<Throwable>(Throwable("CORRUPTED DATABASE"))
                        }
                    }

                } catch (t: Throwable) {
                    Observable.error<Throwable>(t)
                }
            }
            .subscribe(
                    {},
                    {
                        errorFlag = "exportDB: " + it.message
                        errorSubject.onNext("exportDB: " + it.message)
                    },
                    {
                        //trying to reopen database
                        repo.openDatabase()

                        trueFlag = true
                        flagSubject.onNext(true)
                    }
            )
    )

}

repo是注入AppDatabase的存储库，然后在ViewModelFactory中注入。

注射：

object MainInjection {
    private fun providesIORepo(context: Context): IORepo {

        return IORepo(AppDatabase.getInstance(context))
    }

    fun provideIOViewModelFactory(context: Context): IOViewModelFactory {

        val data = providesIORepo(context)

        return IOViewModelFactory(data)
    }
}

在AppCompatActivity onCreate：

val modelFactory = MainInjection.provideIOViewModelFactory(this)
viewModel = ViewModelProviders.of(this, modelFactory).get(IOViewModel::class.java)

重新打开数据库：

fun openDatabase() {
    if(!db.isOpen){
        db.openHelper.writableDatabase
    }
}

现在出现错误消息：

尝试重新打开数据库：

E/ROOM: Invalidation tracker is initialized twice :/.

因此当我尝试从另一个函数访问它时崩溃：

Cannot perform this operation because the connection pool has been closed.

有时在关闭数据库后我也有：

E/ROOM: Cannot run invalidation tracker. Is the db closed?

在这篇文章Incrementally migrate from SQLite to Room中，作者为每次访问都打开并关闭数据库，所以我不明白为什么我的实现不起作用。

那我在哪里错了？有没有办法停用InvalidationTracker？

每次我必须复制数据库文件时，是否应该使用以下代码关闭数据库并清除Room实例。安全吗？：

fun destroyInstance() {

        if (INSTANCE?.isOpen == true) {
            INSTANCE?.close()
        }

        INSTANCE = null
    }

感谢您的关注。

Answer 1

好的，我开始使用以下代码关闭数据库：

fun destroyInstance() {

    if (INSTANCE?.isOpen == true) {
        INSTANCE?.close()
    }

    INSTANCE = null
}

并按如下方式实施导入数据库

fun importaBkpObservable(origin: File, database: File) {
    disposable.clear()
    setFlagsNull()

    flagSubject.onNext(false)

    disposable.add(
            Observable.fromCallable {

                try {

                    repo.closeDatabase()

                    val myDb = SQLiteDatabase.openOrCreateDatabase(origin, null)
                    val ok = myDb.isDatabaseIntegrityOk

                    if (myDb.isOpen) myDb.close()

                    if(ok) {
                        origin.copyTo(database, true)
                    } else {
                        "CORRUPTED DATABASE"
                    }

                } catch (t: Throwable) {
                    t.message
                }
            }
            .subscribeOn(Schedulers.io())
            .subscribe(
                {
                    if(it != null) {
                        if(it is String) {
                            errorFlag = "exportDB: $it"
                            errorSubject.onNext("exportDB: $it")

                        } else {
                            trueFlag = true
                            flagSubject.onNext(true)
                        }

                    } else {
                        errorFlag = "exportDB: GENERIC"
                        errorSubject.onNext("exportDB: GENERIC")
                    }
                },
                {
                    errorFlag = "exportDB: ${it.message}"
                    errorSubject.onNext("exportDB: ${it.message}")
                }
            )
    )

}

我曾经通过startActivityForResult（）从我的主要活动导航到导入/导出活动，但现在已经更改为startActivity（）在此调用之后完成我的主要活动。导入/导出完成后，我使用startActivity（）调用主活动，然后完成导入/导出活动。

这样我的主要活动ViewModel再次使用新的AppDatabase实例进行实例化，并且一切正常。

我查看过Android Profiler，经过几次导入和导出后，内存使用量介于90 MB到130 MB之间，与之前没有关闭数据库时相同，所以我想我没有遇到某种类型内存泄漏或累积Room数据库实例。

我还应该检查什么？

Answer 2

在Java中，您只需在onDestroy回调中将其关闭：

@Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy: --------");
        if(roomDatabase!=null){
          if(roomDatabase.isOpen()) {
            roomDatabase.close();
          }
          roomDatabase=null;
        }
    }

如何正确关闭并重新打开Room数据库

2 个答案: