在kotlin中使用房间作为单身人士

Question

我正在尝试使用Room作为单身人士，所以我不必再调用Room.databaseBuilder() - 这是昂贵的 - 不止一次。

@Database(entities = arrayOf(
        Price::class,
        StationOrder::class,
        TicketPrice::class,
        Train::class,
        TrainCategory::class
), version = 2)
@TypeConverters(Converters::class)
abstract class AppDatabase : RoomDatabase() {

    abstract fun dao(): TrainDao

companion object {
        fun createDatabase(context: Context): AppDatabase
                = Room.databaseBuilder(context, AppDatabase::class.java, "trains.db").build()
    }
}

---

注意：

1. 无法使用Object，因为Room需要使用abstract class。
2. 单例必须是线程安全的，因为多个线程可能同时访问它。
3. 必须能够把Context作为一个论据。

---

我查看了所有类似的StackOverflow问题，但没有一个能满足我的要求

Singleton with argument in Kotlin不是线程安全的

Kotlin - Best way to convert Singleton DatabaseController in Android不是线程安全的

Kotlin thread save native lazy singleton with parameter使用对象

Answer 1

我找到了一个解决方案，所以这里是未来我和任何可能遇到同样问题的人的答案。

---

经过一番研究，我发现我有两种选择。

1. 使用Double-checked locking
2. 使用Initialization-on-demand holder idiom

所以我考虑实施其中一个，但这在kotlin太多的样板代码中感觉不对：p

---

所以经过更多的研究，我偶然发现了this great article，它提供了一个很好的解决方案，它使用双重检查锁定，但是以一种稀疏的方式。

我的代码变成这样：

companion object : SingletonHolder<AppDatabase, Context>({
       Room.databaseBuilder(it, AppDatabase::class.java, "train.db").build()
})

来自文章：

可重用的Kotlin实现：

我们可以封装逻辑来懒惰地创建和初始化带有SingletonHolder类中的参数的单例。为了使该逻辑线程安全，我们需要实现一个同步算法，并且最有效的算法 - 也是最难做到的 - 是双重检查锁定算法。

open class SingletonHolder<T, A>(creator: (A) -> T) {
    private var creator: ((A) -> T)? = creator
    @Volatile private var instance: T? = null

    fun getInstance(arg: A): T {
        val i = instance
        if (i != null) {
            return i
        }

        return synchronized(this) {
            val i2 = instance
            if (i2 != null) {
                i2
            } else {
                val created = creator!!(arg)
                instance = created
                creator = null
                created
            }
        }
    }
}

---

额外：如果你想要Singleton有两个参数

open class SingletonHolder2<out T, in A, in B>(creator: (A, B) -> T) {
    private var creator: ((A, B) -> T)? = creator
    @Volatile private var instance: T? = null

    fun getInstance(arg0: A, arg1: B): T {
        val i = instance
        if (i != null) return i

        return synchronized(this) {
            val i2 = instance
            if (i2 != null) {
                i2
            } else {
                val created = creator!!(arg0, arg1)
                instance = created
                creator = null
                created
            }
        }
    }
}

Answer 2

在这种特殊情况下，我会使用Dagger 2或其他依赖注入库，如Koin或Toothpick。所有三个图书馆都允许提供单身人士的依赖性。

这是Dagger 2模块的代码：

@Module
class AppModule constructor(private val context: Context) {
    @Provides
    @Singleton
    fun providesDatabase(): AppDatabase {
        return Room.databaseBuilder(
                context,
                AppDatabase::class.java,
                "train.db")
                .build()
    }
}

AppComponent：

@Singleton
@Component(modules = arrayOf(
        AppModule::class
))
interface AppComponent {
    fun inject(viewModel: YourViewModel)
    fun inject(repository: YourRepository)
}

应用程序类提供注入：

class App : Application() {
    companion object {
        private lateinit var appComponent: AppComponent
        val component: AppComponent get() = appComponent
    }

    override fun onCreate() {
        super.onCreate()
        initializeDagger()
    }

    private fun initializeDagger() {
        component = DaggerAppComponent.builder()
                .appModule(AppModule(this))
                .build()
    }
}

然后将您的数据库作为单例注入您需要的任何地方（例如在您的应用程序的repository中）：

@Inject lateinit var appDatabase: AppDatabase

init {
    App.component.inject(this)
}

Answer 3

你可以使用Kotlin标准库

fun <T> lazy(LazyThreadSafetyMode.SYNCHRONIZED, initializer: () -> T): Lazy

companion object {
    private lateinit var context: Context
    private val database: AppDatabase by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
        Room.databaseBuilder(context, AppDatabase::class.java, "trains.db").build()
    }
    fun getDatabase(context: Context): AppDatabase {
        this.context = context.applicationContext
        return database
    }
}

就个人而言，我通常会在Application中添加依赖ApplicationContext的单例，例如：

<!-- AndroidManifest.xml -->
<manifest>
  <application android:name="MyApplication">
...

class MyApplication : Application() {
    val database: AppDatabase by lazy {
        Room.databaseBuilder(this, AppDatabase::class.java, "train.db").build()
    }
}

您甚至可以定义一个扩展方法，以便像context.database一样轻松访问。

val Context.database
    get() =
        generateSequence(applicationContext) {
       (it as? ContextWrapper)?.baseContext
       }.filterIsInstance<MyApplication>().first().database

Answer 4

这是我想出来的......

@Database(entities = [MyEntity::class], version = dbVersion, exportSchema = true)
abstract class AppDB : RoomDatabase() {

// First create a companion object with getInstance method
    companion object {
        fun getInstance(context: Context): AppDB = 
    Room.databaseBuilder(context.applicationContext, AppDB::class.java, dbName).build()
    }

    abstract fun getMyEntityDao(): MyEntityDao
}

// This is the Singleton class that holds the AppDB instance 
// which make the AppDB singleton indirectly
// Get the AppDB instance via AppDBProvider through out the app
object AppDBProvider {

private var AppDB: AppDB? = null

    fun getInstance(context: Context): AppDB {
        if (appDB == null) {
            appDB = AppDB.getInstance(context)
        }
       return appDB!!
    }

}

Answer 5

kotlin中的单身人士真的很容易做到这一点

companion object {
    @JvmStatic
    val DATABASE_NAME = "DataBase"

    @JvmField
    val database = Room.databaseBuilder(App.context(), DataBase::class.java, DataBase.DATABASE_NAME).build()

}