Dagger 2 - какова цель класса аннотации @Singleton

@Singleton (и любая другая аннотация области) делает ваш класс единственным экземпляром в вашем графике зависимостей (это означает, что этот экземпляр будет «одиночным», пока существует объект Component).

Короче говоря, каждый раз, когда вы вводите @Singleton аннотированный класс (с аннотацией @Inject), он будет одним и тем же экземпляром, пока вы вводите его из одного и того же компонента.

Для получения дополнительной информации я ссылаюсь на свое сообщение в блоге о том, как аннотации @Singleton и других областей видимости работают в Dagger 2: http://frogermcs.github.io/dependency-injection-with-dagger-2-custom-scopes/

@Singleton на самом деле не создает синглтон, это просто Scope, рекомендуется не использовать @Singleton, поскольку это вводит в заблуждение, создается впечатление, что мы фактически получаем синглтон, но это не так.

Допустим, вы аннотируете зависимость своей базы данных с помощью @Singleton и связываете с помощью Component, теперь предположим, что вы инициализируете этот Component в Activities A и B, у вас будут разные экземпляры вашей базы данных в ваших двух Activities, чего большинство людей не хочет .

Как с этим справиться?

Инициализируйте свой Component один раз в классе Application и обращайтесь к нему статически в других местах, таких как Activities или Fragments, теперь это может скоро выйти из-под контроля, если у вас больше 20 Component's, поскольку вы не можете инициализировать все из них в своем классе Application, это приведет к также замедлите время запуска вашего приложения.

На мой взгляд, лучшее решение - создать реальный Singleton, либо с двойной проверкой, либо с другими вариантами, и использовать его статически как getInstance() и использовать его под @Provides в вашем модуле.

Я знаю, что это тоже разбивает мне сердце, но, пожалуйста, поймите, что @Singleton на самом деле не Singleton, это Scope.

Что такое синглтон?

Шаблон Singleton в Android

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

Аннотация @Singleton в Dagger

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

Назначение синглтона

Чтобы предоставить единственный экземпляр класса в графе зависимостей (компонент). компонент обычно инициализируется на уровне приложения, поскольку он выполняет только компоненты в течение всего времени существования приложения и доступен для всех действий и фрагментов.

Возьмем пример:

CoffeeComponent.kt

@Singleton
@Component
interface CoffeeComponent {

  fun getCoffeeMaker():CoffeeMaker
  fun inject(activityA: ActivityA)
  fun inject(activityB: ActivityB)
}

CoffeeMaker.kt

@Singleton
class CoffeeMaker @Inject constructor()

CoffeeAplication.kt

class CoffeeApplication : Application() {

  private val component by lazy {
    DaggerCoffeeComponent.builder().build()
  }

  fun getAppComponent(): CoffeeComponent = component
}

Рекомендуемая практика

Всегда идите на ленивую инициализацию вашего компонента.
Сценарий: скажем, вы - команда, решившая добавить экран подключения / обучения или включить какой-либо другой дизайн, который не требует компонента во время начальных экранов, это поможет минимизировать запуск задерживать. Всегда помните, инициализация компонента стоит дорого.

ActivityA.kt

import dagger.Lazy

class ActivityA: AppCompatActivity() {

  @Inject
  lateinit var coffeeMaker1:Lazy<CoffeeMaker>
  @Inject
  lateinit var coffeeMaker2:Lazy<CoffeeMaker>
  private val component by lazy {
    (application as CoffeeApplication).getAppComponent()
}
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    btn_activityB.setOnClickListener { startActivity(Intent(this, NewActivity::class.java)) }

    component.inject(this)

    println("Activity A CoffeeMaker 1 - ${coffeeMaker1.get()}")
    println("Activity A CoffeeMaker 2 - ${coffeeMaker2.get()}")
  }
}

Если ваш класс дорого строить, используйте ленивую инициализацию кинжала, пожалуйста, не путайте ее с ленивой kotlin. Вы должны импортировать

import dagger.Lazy

@Inject
lateinit var coffeeMaker1:Lazy<CoffeeMaker>

ActivityB.kt

class ActivityB: AppCompatActivity() {

@Inject
lateinit var coffeeMaker1:Lazy<CoffeeMaker>
@Inject
lateinit var coffeeMaker2:Lazy<CoffeeMaker>
private val component by lazy { 
(application as CoffeeApplication).getAppComponent() }

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_new)
    component.inject(this)

    println("Activity B CoffeeMaker 1 - ${coffeeMaker1.get()}")
    println("Activity B CoffeeMaker 2 - ${coffeeMaker2.get()}")
}
}

вы получите вывод журнала как

Примечание.

If you want to share a singleton instance between activities, lazily initialize them in the application level, if you initialize them in an activity you will end up with different instance as the components are different

Ну, вы можете вручную создать аннотацию, которая поможет создать объект singleton.

@Scope
@Retention(RetentionPolicy.CLASS)
public @interface MyApplicationScope {
}

Когда @MyApplicationScope аннотация добавляется с аннотацией @Provides, это заставляет кинжал создать объект только один раз и использовать тот же объект в будущем. Не забудьте добавить эту аннотацию в интерфейс компонента, иначе во время компиляции вы получите ошибку, связанную с областью видимости.

Если вы используете аннотацию @Singleton, вы можете создавать новые объекты каждый раз, когда будете создавать свой компонент с помощью .build().

@Singleton наследует @Scope, поэтому в документации говорится

Identifies scope annotations. A scope annotation applies to a class * containing an injectable constructor and governs how the injector reuses * instances of the type. By default, if no scope annotation is present, the * injector creates an instance (by injecting the type's constructor), uses * the instance for one injection, and then forgets it. If a scope annotation * is present, the injector may retain the instance for possible reuse in a * later injection. If multiple threads can access a scoped instance, its * implementation should be thread safe. The implementation of the scope * itself is left up to the injector. <p>In the following example, the scope annotation {@code @Singleton} ensures * that we only have one Log instance: * * <pre> * &#064;Singleton * class Log { * void log(String message) { ... } * }</pre>

Вы правильно поняли? какую бы аннотацию вы ни использовали или создаете пользовательскую, и они наследуют от @Scope, это будет гарантировать как синглтон.