कोटलिन में डिपेंडेंसी इंजेक्शन (Dependency Injection): पूर्ण गाइड

Kotlin में Dependency Injection का परिचय

Kotlin में आधुनिक डेवलपमेंट में, विशेष रूप से Android एप्लिकेशन बनाते समय, Dependency Injection (DI) सिद्धांत केवल एक अच्छा अभ्यास नहीं, बल्कि एक आवश्यकता बन गया है। निर्भरता इंजेक्शन आपको स्वच्छ, परीक्षण योग्य और स्केलेबल कोड लिखने की अनुमति देता है, जिससे सिस्टम के घटकों के बीच संबंध कम होता है।

इस लेख में, हम समझेंगे कि Dependency Injection क्या है, यह किन समस्याओं का समाधान करता है, और Kotlin में DI को कैसे लागू किया जाए — मैन्युअल दृष्टिकोण से लेकर Hilt और Koin जैसे लोकप्रिय फ्रेमवर्क के उपयोग तक।

Dependency Injection (निर्भरता इंजेक्शन) क्या है?

Dependency Injection एक डिज़ाइन पैटर्न है, जिसमें कोई ऑब्जेक्ट अपनी निर्भरताएँ बाहर से प्राप्त करता है, न कि उन्हें स्वयं बनाता है। क्लास के अंदर val engine = Engine() लिखने के बजाय, हम कंस्ट्रक्टर, मेथड या फील्ड के माध्यम से एक तैयार इंस्टेंस "इंजेक्ट" करते हैं।

DI के बिना एक सरल उदाहरण देखें:

class Car {    private val engine = Engine() // कठोर संबंध

    fun start() {        engine.start()    }}

समस्या: Car क्लास Engine के एक विशिष्ट कार्यान्वयन से कठोर रूप से बंधा हुआ है। इसे परीक्षण और विस्तारित करना कठिन है।

अब कंस्ट्रक्टर के माध्यम से DI का उदाहरण:

class Car(private val engine: Engine) { // निर्भरता बाहर से दी जाती है

    fun start() {        engine.start()    }}

// उपयोगval engine = Engine()val car = Car(engine)car.start()

अब Car को यह नहीं पता कि Engine कैसे बनाया जाता है। हम परीक्षण के लिए इसे आसानी से MockEngine या किसी अन्य कार्यान्वयन से बदल सकते हैं।

Kotlin में DI क्यों महत्वपूर्ण है?

Kotlin, एक आधुनिक भाषा के रूप में, DI के लिए उत्कृष्ट सुविधाएँ प्रदान करता है:

• Null Safety — Kotlin निर्भरताओं के साथ काम करते समय NullPointerException से बचने में मदद करता है।
• संक्षिप्त सिंटैक्स — पैरामीटर वाले कंस्ट्रक्टर DI को स्वाभाविक बनाते हैं।
• Java के साथ संगतता — सभी लोकप्रिय DI-फ्रेमवर्क (Dagger, Hilt) Kotlin को सपोर्ट करते हैं।
• कार्यात्मक शैली — Kotlin DI को लागू करने के लिए लैम्ब्डा और डेलीगेट का उपयोग करने की अनुमति देता है।

Kotlin में DI को लागू करने के तरीके

1. मैन्युअल इंजेक्शन (Manual DI)

सबसे सरल तरीका — कंस्ट्रक्टर के माध्यम से निर्भरताएँ पास करना। छोटे प्रोजेक्ट्स के लिए यह अक्सर पर्याप्त होता है।

class Database(private val connection: Connection)

class UserRepository(private val database: Database)

class UserViewModel(private val userRepository: UserRepository)

// निर्भरताओं की मैन्युअल असेंबलीfun main() {    val connection = Connection("postgres://localhost:5432")    val database = Database(connection)    val repository = UserRepository(database)    val viewModel = UserViewModel(repository)}

कमी: प्रोजेक्ट बढ़ने पर मैन्युअल प्रबंधन बोझिल हो जाता है।

2. Service Locator (एंटीपैटर्न या अस्थायी समाधान)

कभी-कभी Service Locator का उपयोग किया जाता है — एक केंद्रीय ऑब्जेक्ट जो सभी निर्भरताओं को संग्रहीत करता है। हालाँकि, इसे एंटीपैटर्न माना जाता है क्योंकि यह क्लास की वास्तविक निर्भरताओं को छिपाता है।

object ServiceLocator {    private val database = Database()    private val repository = UserRepository(database)        fun provideViewModel() = UserViewModel(repository)}

// उपयोगval viewModel = ServiceLocator.provideViewModel()

3. DI-फ्रेमवर्क: Hilt और Koin

गंभीर प्रोजेक्ट्स के लिए तैयार समाधानों का उपयोग करना बेहतर है। Kotlin/Android के लिए दो सबसे लोकप्रिय पर विचार करें।

Hilt (Dagger पर आधारित)

Hilt, Android के लिए Google की आधिकारिक DI लाइब्रेरी है। यह Dagger पर आधारित है, लेकिन सरलीकृत API के साथ।

// 1. Application में @HiltAndroidApp एनोटेशन@HiltAndroidAppclass MyApplication : Application(
```