Использование комнаты как синглтона в Котлине

После некоторых исследований я обнаружил, что у меня есть два варианта.

1. Блокировка с двойной проверкой
2. Идиома держателя инициализации по запросу

Я думал о реализации одного из них, но это не подходило для Kotlin — слишком много шаблонного кода.

После дополнительных исследований я наткнулся на эту замечательную статью, в которой отличное решение, использующее блокировку с двойной проверкой, но элегантно.

companion object : SingletonHolder<AppDatabase, Context>({
       Room.databaseBuilder(it.applicationContext, 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
            }
        }
    }
}

В этом конкретном случае я бы прибегнул к использованию Dagger 2 или какой-либо другой библиотеке внедрения зависимостей, такой как Коины или Зубочистка. Все три библиотеки позволяют предоставлять зависимости как синглтоны.

Вот код модуля 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()
    }
}

Компонент приложения:

@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()
    }
}

А затем вставьте свою базу данных как singleton туда, где она вам нужна (например, в вашем приложении репозиторий):

@Inject lateinit var appDatabase: AppDatabase

init {
    App.component.inject(this)
}

Вы можете использовать стандартную библиотеку Kotlin

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

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
    }
}

Однако лично я обычно добавляю синглтоны, зависящие от 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

Используется @Volatile для безопасности потоков.

public abstract class AppDatabase : RoomDatabase() {

   abstract fun trainDao(): trainDao

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

        fun getDatabase(context: Context): Db = INSTANCE ?: synchronized(this){
            val instance = Room.databaseBuilder(
            context.applicationContext,
            AppDatabase ::class.java,
            "train-db"
          ).build()
          INSTANCE = instance
          instance
        }
   }
}

взято с: https://developer.android.com/codelabs/android-room-with-a-view-kotlin#7

Вот как я понял...

@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!!
    }

}

синглтон в котлине очень прост, просто сделайте это

companion object {
    @JvmStatic
    val DATABASE_NAME = "DataBase"

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

}