परिचय

DI के लिए Android विकास परंपरागत रूप से डैगर 2 का उपयोग करता है , जो एक बहुत शक्तिशाली कोड जनरेशन फ्रेमवर्क है। लेकिन एक समस्या है: शुरुआती लोगों के लिए इसका उपयोग करना मुश्किल है। DI सिद्धांत स्वयं सरल और सीधे हैं, लेकिन डैगर उन्हें उलझा देते हैं। आप प्रोग्रामर की साक्षरता में पूर्ण गिरावट के बारे में शिकायत कर सकते हैं, लेकिन इससे समस्या गायब नहीं होगी।

कोटलिन के आगमन के साथ, सुविधाजनक चीजों को लिखना संभव हो गया जो जावा का उपयोग करना लगभग असंभव होगा। इन चीजों में से एक कोइन था , जो एक डीआई नहीं है, बल्कि एक सर्विस लोकेटर है, जिसे कई लोगों द्वारा पैटर्न-विरोधी माना जाता है , यही कारण है कि कई लोग इसे सिद्धांत रूप में उपयोग नहीं करते हैं। लेकिन व्यर्थ में, क्योंकि इसमें बहुत ही संक्षिप्त एपीआई है जो कोड को लिखने और बनाए रखने को सरल बनाता है।

इस लेख में, मैं शुरुआती लोगों को डिपेंडेंसी इंजेक्शन और सेवा लोकेटर के बीच अंतर का पता लगाने में मदद करना चाहता हूं, लेकिन खुद कोइन नहीं।

निर्भरता अन्तःक्षेपण

सबसे पहले, निर्भरता इंजेक्शन क्या है? सरल शब्दों में, यह तब होता है जब कोई वस्तु स्वयं को बनाने या निकालने के बजाय बाहर से निर्भरता स्वीकार करती है। मैं एक उदाहरण दूंगा। मान लीजिए हमारे पास एक इंटरफ़ेस है Engine, इसका कार्यान्वयन, और यह भी एक वर्ग है Carजो निर्भर करता है Engine। DI के बिना, यह इस तरह लग सकता है

interface Engine
class DefaultEngine: Engine

class Car {
  private val engine: Engine = DefaultEngine()
}

fun main() {
  val car = Car()
}

यदि हम CarDI दृष्टिकोण का उपयोग करके कक्षा को फिर से लिखते हैं , तो यह हो सकता है:

class Car(private val engine: Engine)

fun main() {
  val car = Car(DefaultEngine())
}

यह सरल है - वर्ग को Carयह नहीं पता है कि कार्यान्वयन कहां से आता है Engine, जबकि इसे लागू करना बहुत आसान है, बस इसे कंस्ट्रक्टर के पास भेज दें।

सेवा लोकेटर

Service Locator. – , . Koin ServiceLocator, , API.

object ServiceLocator {
  fun <reified T> register(factory: () -> T) { ... }
  fun <reified T> resolve(): T { ... }
}

, . :

interface Engine
class DefaultEngine: Engine

class Car {
  private val engine: Engine = ServiceLocator.resolve()
}

fun main() {
  ServiceLocator.register<Engine> { DefaultEngine() }
  val car = Car()
}

DI, Car , , – Car, . :

interface ServiceLocator {
  fun <reified T> register(factory: () -> T)
  fun <reified T> resolve(): T
}

class DefaultServiceLocator: ServiceLocator { ... }

class Car(private val serviceLocator: ServiceLocator) {
  private val engine = serviceLocator.resolve<Engine>()
}

fun main() {
  val serviceLocator = DefaultServiceLocator()
  serviceLocator.register<Engine> { DefaultEngine() }
  val car = Car(serviceLocator)
}

, Car , . .. . :

class Car(private val engine: Engine)

fun main() {
  ServiceLocator.register<Engine> { DefaultEngine() }
  val car = Car(ServiceLocator.resolve<Engine>())
}

यह शुद्ध निर्भरता इंजेक्शन है। कोइन के साथ, यह इस तरह दिखेगा:

interface Engine
class DefaultEngine: Engine
class Car(private val engine: Engine)

fun carModule() = module {
  factory<Engine> { DefaultEngine() }
  factory { Car(get<Engine>()) }
}

fun main() {
  val koin = startKoin {
    modules(carModule())
  }.koin

  val car = koin.get<Car>()
}

काश, हम अभी भी निर्भरता के लिए कोइन से संपर्क करने की जरूरत है, लेकिन यह किसी भी तरह से निर्भरता इंजेक्शन के सिद्धांतों का विरोध नहीं करता है।

अपडेट करें अनुरोध द्वाराkranid मैं डैगर 2 पर सबसे सरल उदाहरण दूंगा।

interface Engine
class DefaultEngine: Engine
class Car @Inject constructor(private val engine: Engine)

@Module
class AppModule {
  @Provides
  fun provideEngine(): Engine = DefaultEngine()
}

@Component(modules = [AppModule.class])
interface AppComponent {
  fun car(): Car
}

fun main() {
  // DaggerAppComponent –  ,   Dagger
  val daggerComponent = DaggerAppComponent.create()
  val car = daggerComponent.car()
}