Kodein। मूल बातें

मुझे उन लोगों के लिए समझने योग्य मार्गदर्शिकाएँ नहीं Kodein , जिन्होंने पहली बार Kodein को Kodein था, और प्रलेखन सभी स्थानों पर पारदर्शी और सुसंगत नहीं है, इसलिए मैं आपके साथ पुस्तकालय की मुख्य विशेषताओं को साझा करना चाहता हूं। कुछ पुस्तकालय सुविधाओं को जारी किया जाएगा, लेकिन यह मूल रूप से उन्नत हिस्सा है। यहां आपको सामान्य रूप से शुरू करने और Kodein साथ निर्भरताएं लागू करने के लिए सब कुछ मिलेगा Kodein कि आपने लेख पढ़ा। लेख Kodein 5.3.0 पर आधारित है, क्योंकि Kodein 6.0.0 को Support Library 28 या AndroidX आवश्यकता होती है और यह सभी से दूर होगा क्योंकि कई तृतीय-पक्ष लाइब्रेरी अभी तक संगत संस्करण प्रदान नहीं करती हैं।


Kodein निर्भरता इंजेक्शन (DI) को लागू करने के लिए एक पुस्तकालय है। यदि आप इस अवधारणा से परिचित नहीं हैं, तो डैगर 2 के बारे में लेख की शुरुआत पढ़ें, जहां लेखक संक्षेप में डीआई के सैद्धांतिक पहलुओं की व्याख्या करता है।

इस लेख में, हम एंड्रॉइड के उदाहरण के साथ सब कुछ पर विचार करेंगे, लेकिन, डेवलपर्स के अनुसार, कोडिन कोटलिन (जेवीएम, एंड्रॉइड, जेएस, नेटिव) द्वारा समर्थित सभी प्लेटफार्मों पर समान व्यवहार करता है।

स्थापना

इस तथ्य के कारण कि जावा में type erasure , एक समस्या उत्पन्न होती है - कंपाइलर जेनेरिक प्रकार को मिटा देता है। बाइटकोड स्तर पर, List<String> और List<Date> बस List । फिर भी, जेनेरिक प्रकारों के बारे में जानकारी प्राप्त करने का एक तरीका है, लेकिन इसमें बहुत खर्च होंगे और केवल जेवीएम और एंड्रॉइड पर काम करेंगे। इस संबंध में, Kodein डेवलपर्स दो निर्भरताओं में से एक का उपयोग करने का सुझाव देते हैं: एक काम करते समय सामान्यीकृत प्रकारों ( kodein-generic ) के बारे में जानकारी प्राप्त करता है, और दूसरा ( kodein-erased ) नहीं करता है। उदाहरण के लिए, kodein-erased का उपयोग करते समय List<String> और List<Date > को List<*> रूप में सेव किया जाएगा, और kodein-generic का उपयोग kodein-generic सबकुछ निर्दिष्ट प्रकार के साथ ही सेव किया जाएगा, यानी List<String> और List<Date> क्रमशः List<Date> ।

कैसे चुनें?

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

अंततः, यदि आप प्रदर्शन पर DI के प्रभाव के बारे में सोचते हैं, तो सबसे अधिक बार निर्भरता के थोक एक बार बनाए जाते हैं, या बार-बार पुन: उपयोग के लिए निर्भरताएं बनाई जाती हैं, यह संभावना नहीं है कि ऐसे कार्यों से आप अपने आवेदन के प्रदर्शन को बहुत प्रभावित कर सकते हैं।

तो, स्थापित करें:

पहले - build.gradle में रिपॉजिटरी के बीच jcenter () होना चाहिए, अगर यह नहीं है - जोड़ें।

 buildscript { repositories { jcenter() } } 

अगला, निर्भरता ब्लॉक में, ऊपर बताई गई मूल निर्भरता में से एक को जोड़ें:

 implementation "org.kodein.di:kodein-di-generic-jvm:$version" 

 implementation "org.kodein.di:kodein-di-erased-jvm:$version" 

चूंकि हम एंड्रॉइड के बारे में बात कर रहे हैं, इसलिए अधिक निर्भरताएं होंगी। आप निश्चित रूप से, इसके बिना कर सकते हैं, कोडिन सामान्य रूप से कार्य करेगा, लेकिन एंड्रॉइड के लिए उपयोगी अतिरिक्त सुविधाओं को क्यों मना कर सकता है (मैं लेख के अंत में उनके बारे में बात करूंगा)? पसंद आपकी है, लेकिन मैं जोड़ने का प्रस्ताव करता हूं।

यहां भी विकल्प हैं।

सबसे पहले, आप SupportLibrary का उपयोग नहीं कर रहे हैं

 implementation "org.kodein.di:kodein-di-framework-android-core:$version" 

दूसरा - उपयोग

 implementation "org.kodein.di:kodein-di-framework-android-support:$version" 

तीसरा - आप AndroidX का उपयोग कर रहे हैं

 implementation "org.kodein.di:kodein-di-framework-android-x:$version" 

हम निर्भरता पैदा करना शुरू करते हैं

Dagger2 का उपयोग करते Dagger2 , मुझे एप्लिकेशन क्लास में, एप्लिकेशन स्टार्टअप पर निर्भरता बनाने और आरंभ करने के लिए उपयोग किया जाता है।

कोडीन के साथ, यह इस तरह किया जाता है:

 class MyApp : Application() { val kodein = Kodein { /*  */ } } 

निर्भरता की घोषणा हमेशा से शुरू होती है

 bind<TYPE>() with 

टैग

कोडीन निर्भरता टैगिंग Dagger2 से Qualifier लिए कार्यक्षमता में समान विशेषता है। Dagger2 आपको या तो अलग Qualifier या @Named("someTag") , जो वास्तव में Qualifier भी है। नीचे की रेखा सरल है - इस तरह आप एक ही प्रकार की दो निर्भरता को अलग करते हैं। उदाहरण के लिए, आपको स्थिति के आधार पर ontext एप्लिकेशन या किसी विशिष्ट Activity का ontext प्राप्त करने की आवश्यकता होती है, इसलिए आपको निर्भरता की घोषणा करते समय इसके लिए टैग निर्दिष्ट करने की आवश्यकता होती है। Kodein टैग के बिना एक निर्भरता की घोषणा करने की अनुमति देता है, यह आधार एक होगा और यदि आप निर्भरता प्राप्त करते समय टैग निर्दिष्ट नहीं करते हैं, तो हम इसे प्राप्त करेंगे, दूसरों को टैग करने की आवश्यकता है और जब निर्भरता प्राप्त होती है, तो टैग को निर्दिष्ट करने की आवश्यकता होगी।

 val kodein = Kodein { bind<Context>() with ... bind<Context>(tag = "main_activity") with ... bind<Context>(tag = "sale_activity") with ... } 

tag पैरामीटर Any प्रकार का है, इसलिए आप केवल स्ट्रिंग्स से अधिक उपयोग कर सकते हैं। लेकिन याद रखें कि टैग के रूप में उपयोग की जाने वाली कक्षाएं equals और hashCode विधियों को लागू करना चाहिए। किसी फ़ंक्शन को नामित तर्क के रूप में टैग को पास करना हमेशा आवश्यक होता है, भले ही आप एक निर्भरता बनाएं या प्राप्त करें।

निर्भरता इंजेक्शन के प्रकार

Kodein में निर्भरता प्रदान करने के लिए कई तरीके हैं, Kodein आवश्यक के साथ Kodein करते हैं - Kodein बनाना। सिंगलटन Kodein के निर्मित उदाहरण के ढांचे के भीतर Kodein ।

पेश है सिंगलटन

एक उदाहरण से शुरू करते हैं:

 val kodein = Kodein { bind<IMyDatabase>() with singleton { RoomDb() } } 

इस प्रकार हम IMyDatabase प्रदान करते हैं, जिसके पीछे IMyDatabase एक उदाहरण छिपा होगा। निर्भरता के पहले अनुरोध पर RoomDb का एक उदाहरण बनाया जाएगा, जब तक कि एक नया Kodein उदाहरण नहीं Kodein तब तक इसे Kodein से Kodein नहीं जाएगा। एक सिंगलटन को सिंक्रोनाइज़ किया जाता है, लेकिन यदि वांछित है, तो इसे अनसिंक्रनाइज़ किया जा सकता है। इससे उत्पादकता में वृद्धि होगी, लेकिन आपको उन जोखिमों को समझना चाहिए जो पालन करते हैं।

 val kodein = Kodein { bind<IMyDatabase>() with singleton(sync = false) { RoomDb() } } 

यदि आपको पहली कॉल पर निर्भरता उदाहरण बनाने की आवश्यकता नहीं है, लेकिन Kodein इंस्टेंस बनाने के तुरंत बाद, किसी अन्य फ़ंक्शन का उपयोग करें:

 val kodein = Kodein { bind<IMyDatabase>() with eagerSingleton { RoomDb() } } 

निर्भरता की एक नई मिसाल कायम करना

एक नया उदाहरण प्राप्त करने के लिए एक निर्भरता का उपयोग करते हुए लगातार एकल नहीं, बल्कि लगातार एकल बनाना संभव है। इसके लिए, provider फ़ंक्शन का उपयोग किया जाता है:

 val kodein = Kodein { bind<IMainPresenter>() with provider { QuantityPresenter() } } 

इस मामले में, हर बार जब हम एक IMainPresenter निर्भरता का अनुरोध करते हैं, तो IMainPresenter एक नया उदाहरण बनाया जाएगा।

लगातार निर्भरता का एक नया उदाहरण बनाएं और मापदंडों को निर्भरता के निर्माता के पास करें

पिछले उदाहरण के अनुसार, निर्भरता जोड़ने पर आप हर बार इसका एक नया उदाहरण प्राप्त कर सकते हैं, लेकिन निर्भरता बनाने के लिए पैरामीटर निर्दिष्ट कर सकते हैं। पैरामीटर अधिकतम 5 हो सकते हैं। इस व्यवहार के लिए, factory विधि का उपयोग करें।

 val kodein = Kodein { bind<IColorPicker>() with factory { r: Int, g: Int, b: Int, a: Int -> RgbColorPicker(r, g, b, a) } } 

हर बार हम मापदंडों के आधार पर कैश्ड उदाहरण बनाते हैं

पिछले पैराग्राफ को पढ़ते हुए, आप सोच सकते हैं कि हर बार नए उदाहरण प्राप्त करने के लिए अच्छा नहीं होगा, जबकि दिए गए मापदंडों के अनुसार, लेकिन उसी पैरामीटर पर निर्भरता का एक ही उदाहरण प्राप्त करना।

 val kodein = Kodein { bind<IRandomIntGenerator>() with multiton { from: Int, to: Int -> IntRandom(from, to) } } 

उपरोक्त उदाहरण में, जब हम पहली बार मापदंडों 5 और 10 साथ निर्भरता प्राप्त करते हैं 10 तो हम IntRandom(5, 10) का एक नया उदाहरण IntRandom(5, 10) , जब हम उसी मापदंडों के साथ निर्भरता को फिर से कहते हैं, तो हमें पहले बनाया उदाहरण मिलेगा। इस प्रकार, आलसी आरंभीकरण के साथ सिंगलटन से एक map प्राप्त किया जाता है। factory के मामले में तर्क, अधिकतम 5 हैं ।

एकल के साथ के रूप में, आप यहाँ सिंक्रनाइज़ेशन को अक्षम कर सकते हैं।

 val kodein = Kodein { bind<IRandomIntGenerator>() with multiton(sync = false) { from: Int, to: Int -> IntRandom(from, to) } } 

कोडीन में नरम और कमजोर लिंक का उपयोग करना

multiton या multiton का उपयोग करके निर्भरता प्रदान करते समय multiton आप संग्रहीत उदाहरण के प्रकार को निर्दिष्ट कर सकते हैं। सामान्य स्थिति में, जिसे हमने ऊपर माना है - यह सामान्य strong लिंक होगा। लेकिन soft और weak लिंक का उपयोग करना संभव है। यदि आप इन अवधारणाओं के लिए नए हैं, तो यहां एक नज़र डालें ।

इस प्रकार, आपके सिंगलेटोन्स को अनुप्रयोग जीवन चक्र के भाग के रूप में पुनः बनाया जा सकता है, या नहीं भी हो सकता है।

 val kodein = Kodein { bind<IMyMap>() with singleton(ref = softReference) { WorldMap() } bind<IClient>() with singleton(ref = weakReference) { id -> clientFromDB(id) } } 

प्रत्येक स्ट्रीम के लिए अलग सिंगलटन

यह एक ही सिंगलटन है, लेकिन निर्भरता का अनुरोध करने वाले प्रत्येक थ्रेड के लिए, एक सिंगलटन बनाया जाएगा। ऐसा करने के लिए, परिचित पैरामीटर ref उपयोग करें।

 val kodein = Kodein { bind<Cache>() with singleton(ref = threadLocal) { LRUCache(16 * 1024) } } 

लगातार निर्भरता के रूप में स्थिरांक

आप निर्भरता के रूप में स्थिरांक प्रदान कर सकते हैं। प्रलेखन इस तथ्य पर ध्यान आकर्षित करता है कि Kodein साथ आपको विरासत या इंटरफेस के बिना सरल प्रकार के स्थिरांक Kodein , उदाहरण के लिए आदिम या डेटा वर्ग।

 val kodein = Kodein { constant(tag = "maxThread") with 8 constant(tag = "serverURL") with "https://my.server.url" 

प्रकार को बदले बिना निर्भरता बनाएँ

उदाहरण के लिए, आप एक सिंगलटन के रूप में निर्भरता प्रदान करना चाहते हैं, लेकिन इसे इंटरफ़ेस के पीछे छिपाएं नहीं। bind करते समय आप टाइप को निर्दिष्ट नहीं कर सकते bind और इसके बजाय from उपयोग with ।

 val kodein = Kodein { bind() from singleton { Gson() } 

ऊपर दिए गए उदाहरण में निर्भरता में फ़ंक्शन का रिटर्न प्रकार होगा, अर्थात, एक Gson प्रकार निर्भरता Gson जाएगी।

सुपरक्लास या इंटरफ़ेस की उप-निर्भरता बनाएँ

Kodein किसी विशेष वर्ग या वर्गों के वंशजों के लिए अलग-अलग तरीकों से निर्भरता प्रदान करने की अनुमति देता है जो एकल इंटरफ़ेस लागू करते हैं।

 val kodein = Kodein { bind<Animal>().subTypes() with { animalType -> when (animalType.jvmType) { Dog::class.java -> eagerSingleton { Dog() } else -> provider { WildAnimal(animalType) } } } 

Animal वर्ग या तो एक .subtypes या इंटरफ़ेस हो सकता है, .subtypes का उपयोग .subtypes हम टाइप TypeToken<*> animalType एक animalType टाइप प्राप्त करते हैं, जिससे हम पहले से ही एक जावा वर्ग प्राप्त कर सकते हैं और इसके आधार पर, विभिन्न तरीकों से एक निर्भरता प्रदान करते हैं। यह सुविधा उपयोगी हो सकती है यदि आप कई मामलों के लिए निर्माता पैरामीटर के रूप में TypeToken या उसके डेरिवेटिव का उपयोग करते हैं। इस प्रकार भी आप विभिन्न प्रकारों के लिए एक ही निर्भरता सृजन के साथ अनावश्यक कोड से बच सकते हैं।

पैरामीटर के रूप में अन्य निर्भरता की आवश्यकता है जो निर्भरता बनाएँ

अक्सर, हम केवल एक निर्भरता के रूप में मापदंडों के बिना एक वर्ग नहीं बनाते हैं, लेकिन एक वर्ग बनाते हैं, जिसके लिए हमें निर्माणकर्ता को पैरामीटर पारित करने की आवश्यकता होती है।

 class ProductGateway(private val api: IProductApi, private val dispatchers: IDispatchersContainer) : IProductGateway 

पहले से Kodein में बनाई गई निर्भरता के साथ एक वर्ग बनाने के लिए Kodein एक उदाहरण () फ़ंक्शन कॉल को मापदंडों के रूप में पारित करने के लिए पर्याप्त है। इस मामले में, सृजन का क्रम महत्वपूर्ण नहीं है।

 bind<IDispatchersContainer>() with singleton { DispatchersContainer() } bind<IProductGateway>() with singleton { ProductGateway(instance(), instance()) } bind<IProductApi>() with singleton { ProductApi() } 

instance() बजाय instance() provider() या factory() को कॉल किया जा सकता है; हम निर्भरता प्राप्त करने और कार्यान्वित करने पर अनुभाग में इन तरीकों पर करीब से नज़र डालेंगे।

पहले से बनाई गई निर्भरता पद्धति को कॉल करके एक निर्भरता बनाएं

यह बहुत अच्छा नहीं लगता है, लेकिन आप instance<TYPE> कॉल कर सकते हैं एक वर्ग जिसे हम पहले से ही प्रदान करते हैं और एक नई निर्भरता प्राप्त करने के लिए इस वर्ग की विधि को कॉल कर सकते हैं।

 bind<DataSource>() with singleton { MySQLDataSource() } bind<Connection>() with provider { instance<DataSource>().openConnection() } 

मॉड्यूल

Dagger2 का उपयोग करते Dagger2 , मैं Dagger2 निर्भरता को Dagger2 लिए उपयोग किया जाता हूं। Kodein , पहली नज़र में, सब कुछ बहुत अच्छा नहीं लगता है। आपको Application वर्ग में बहुत अधिक निर्भरता बनाने की आवश्यकता है, और मैं वास्तव में इसे पसंद नहीं करता। लेकिन एक समाधान है, Kodein आपको मॉड्यूल बनाने की अनुमति भी देता है, और फिर उन्हें उन जगहों पर कनेक्ट करता है जहां आवश्यक हो।

  val appModule = Kodein.Module("app") { bind<Gson>() with singleton { provideGson() } bind<HttpClient>() with singleton { provideHttpClient() } } val kodein: Kodein = Kodein { import(appModule) bind<ISchedulersContainer>() with singleton { SchedulersContainer() } //   } 

लेकिन सावधान रहें, मॉड्यूल सिर्फ कंटेनर हैं जो निर्भरता प्राप्त करने के तरीकों की घोषणा करते हैं; वे स्वयं कक्षाएं नहीं बनाते हैं। इसलिए, यदि आप मॉड्यूल में एक सिंगलटन के रूप में निर्भरता की प्राप्ति की घोषणा करते हैं, और फिर इस मॉड्यूल को Kodein दो अलग-अलग उदाहरणों में आयात करते हैं, तो आपको दो अलग-अलग एकल, Kodein प्रति एक उदाहरण Kodein ।

साथ ही, प्रत्येक मॉड्यूल का नाम अद्वितीय होना चाहिए। हालांकि, यदि आपको किसी अन्य प्रोजेक्ट से मॉड्यूल आयात करने की आवश्यकता है, तो नाम की विशिष्टता की गारंटी देना मुश्किल है, इसके लिए, आप मॉड्यूल का नाम बदल सकते हैं या इसके नाम में एक उपसर्ग जोड़ सकते हैं।

 import(apiModule.copy(name = "firstAPI")) import(secondApiModule.copy(prefix = "secondAPI-")) 

मैं तब काम करता था जब मॉड्यूल एक-दूसरे पर निर्भर होते हैं और किसी प्रकार का पदानुक्रम बनाते हैं। Kodein प्रत्येक मॉड्यूल को Kodein एक बार आयात कर सकते हैं, इसलिए, यदि आप दो मॉड्यूलों को आयात करने का प्रयास करते हैं जिनके पास एक Kodein में समान निर्भर मॉड्यूल हैं, तो अनुप्रयोग क्रैश हो जाएगा। समाधान सरल है - आपको आयात करने के लिए importOnce(someModule) कॉल का उपयोग करने की आवश्यकता है, जो यह जांच करेगा कि क्या समान नाम वाला मॉड्यूल पहले आयात किया गया है, और यदि आवश्यक हो तो आयात करें।

उदाहरण के लिए, ऐसे मामलों में, एप्लिकेशन क्रैश हो जाएगा:

  val appModule = Kodein.Module("app") { bind<Gson>() with singleton { provideGson() } } val secondModule = Kodein.Module("second") { import(appModule) } val thirdModule = Kodein.Module("third") { import(appModule) } val kodein: Kodein = Kodein { import(secondModule) import(thirdModule) } 

  val appModule = Kodein.Module("app") { bind<Gson>() with singleton { provideGson() } } val secondModule = Kodein.Module("second") { importOnce(appModule) } val thirdModule = Kodein.Module("third") { import(appModule) } val kodein: Kodein = Kodein { import(secondModule) import(thirdModule) } 

लेकिन अगर importOnce कॉल दूसरे कनेक्शन के प्रयास पर है, तो सब कुछ काम करेगा। सावधान रहें।

  val appModule = Kodein.Module("app") { bind<Gson>() with singleton { provideGson() } } val secondModule = Kodein.Module("second") { import(appModule) } val thirdModule = Kodein.Module("third") { importOnce(appModule) } val kodein: Kodein = Kodein { import(secondModule) import(thirdModule) } 

विरासत

यदि आप एक ही मॉड्यूल का दो बार उपयोग करते हैं, तो अलग-अलग निर्भरताएं बनाई जाएंगी, लेकिन Subcomponents में Dagger2 Subcomponents समान व्यवहार और व्यवहार को लागू करने के Subcomponents में Dagger2 ? सब कुछ सरल है, आपको बस Kodein उदाहरण से विरासत में लेने की आवश्यकता है और आपको वारिस में माता-पिता की सभी निर्भरताओं तक पहुंच मिलेगी।

 val kodein: Kodein = Kodein { bind<ISchedulersContainer>() with singleton { SchedulersContainer() } //   } val subKodein = Kodein { extend(kodein) //   } 

परिभाषा

डिफ़ॉल्ट रूप से, आप निर्भरता को ओवरराइड नहीं कर सकते, अन्यथा उपयोगकर्ता एप्लिकेशन के गलत तरीके से काम करने के कारणों की तलाश में पागल हो जाएंगे। लेकिन bind फ़ंक्शन के अतिरिक्त पैरामीटर का उपयोग करके ऐसा करना संभव है। यह कार्यक्षमता उपयोगी होगी, उदाहरण के लिए, परीक्षण के आयोजन के लिए।

 val kodein = Kodein { bind<Api>() with singleton { ApiImpl() } /* ... */ bind<Api>(overrides = true) with singleton { OtherApiImpl() } } 

डिफ़ॉल्ट रूप से, मॉड्यूल और उनकी निर्भरता को Kodein ऑब्जेक्ट में पहले से घोषित निर्भरता को ओवरराइड नहीं कर सकते हैं, लेकिन जब एक मॉड्यूल का आयात करते हैं, तो आप संकेत कर सकते हैं कि मौजूदा निर्भरताएं इसकी निर्भरता को ओवरराइड कर सकती हैं, और इस मॉड्यूल के अंदर आप पहले से ही निर्भरता को निर्दिष्ट कर सकते हैं जो अन्य ओवरराइड कर सकते हैं।

यह बहुत स्पष्ट नहीं है, आइए उदाहरणों का उपयोग करें। इन मामलों में, एप्लिकेशन क्रैश हो जाएगा:

  val appModule = Kodein.Module("app") { bind<Gson>() with singleton { provideGson() } } val kodein: Kodein = Kodein { bind<Gson>() with singleton { provideGson() } import(appModule) } 

  val appModule = Kodein.Module("app") { bind<Gson>() with singleton { provideGson() } } val kodein: Kodein = Kodein { bind<Gson>() with singleton { provideGson() } import(appModule, allowOverride = true) } 

और इसमें, मॉड्यूल निर्भरता Kodein ऑब्जेक्ट में घोषित निर्भरता को ओवरराइट करती है।

  val appModule = Kodein.Module("app") { bind<Gson>(overrides = true) with singleton { provideGson() } } val kodein: Kodein = Kodein { bind<Gson>() with singleton { provideGson() } import(appModule, allowOverride = true) } 

लेकिन अगर आप वास्तव में चाहते हैं और आप समझते हैं कि आप क्या कर रहे हैं, तो आप एक मॉड्यूल बना सकते हैं, अगर Kodein ऑब्जेक्ट के साथ समान निर्भरताएं हैं, तो उन्हें फिर से परिभाषित करेगा और एप्लिकेशन क्रैश नहीं होगा। हम मॉड्यूल के लिए allowSilentOverride पैरामीटर का उपयोग करते हैं।

 val testModule = Kodein.Module(name = "test", allowSilentOverride = true) { bind<EmailClient>() with singleton { MockEmailClient() } } 

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

निर्भरता को पुनः प्राप्त करना और इंजेक्शन लगाना

अंत में, हमें पता चला कि कई तरह से निर्भरता की घोषणा कैसे की जाती है, यह जानने का समय है कि उन्हें अपनी कक्षाओं में कैसे लाया जाए।

Kodein डेवलपर्स निर्भरता प्राप्त करने के दो तरीके साझा करते हैं - injection और retieval । संक्षेप में, injection तब होता है जब वर्ग सभी निर्भरता प्राप्त करता है जब इसे बनाया जाता है, retrieval , निर्माता में, और retrieval तब होती है जब वर्ग अपनी निर्भरता प्राप्त करने के लिए स्वयं जिम्मेदार होता है।

injection का उपयोग करते समय injection आपकी कक्षा को Kodein बारे में कुछ भी नहीं पता है और कक्षा में कोड क्लीनर है, लेकिन यदि आप retrieval उपयोग करते हैं, तो आपके पास निर्भरता को अधिक लचीले ढंग से प्रबंधित करने का अवसर है। retrieval के मामले में retrieval सभी निर्भरताएं आलसी प्राप्त की जाती हैं, केवल निर्भरता के लिए पहली अपील के समय।

निर्भरता का उपयोग करने के लिए Kodein तरीके

Kodein वर्ग की एक आवृत्ति में तीन विधियाँ होती हैं जो एक निर्भरता, एक निर्भरता कारखाना, या एक निर्भरता प्रदाता - instance() , factory() और provider() क्रमशः लौटाती हैं। इस प्रकार, यदि आप एक factory या provider का उपयोग करके एक निर्भरता प्रदान करते हैं, तो आप न केवल फ़ंक्शन निष्पादन का परिणाम प्राप्त कर सकते हैं, बल्कि फ़ंक्शन भी कर सकते हैं। याद रखें कि आप सभी विविधताओं में टैग का उपयोग कर सकते हैं।

  val kodein: Kodein = Kodein { bind<BigDecimal>() with factory { value: String -> BigDecimal(value) } bind<Random>() with provider { Random() } } private val number: BigDecimal by instance(arg = "23.87") private val numberFactory: (value: String) -> BigDecimal by factory() private val random: Random by instance() private val randomProvider: () -> Random by provider() 

कंस्ट्रक्टर के माध्यम से निर्भरता इंजेक्शन

जैसा कि आप पहले से ही समझ चुके हैं, यह injection बारे में होगा। लागू करने के लिए, आपको पहले कक्षा के सभी आश्रितों को इसके निर्माता में ले जाना चाहिए, और फिर kodein.newInstance को कॉल करके कक्षा का एक उदाहरण बनाना kodein.newInstance

 class ProductApi(private val client: HttpClient, private val gson: Gson) : IProductApi class Application : Application() { val kodein: Kodein = Kodein { bind<Gson>() with singleton { provideGson() } bind<HttpClient>() with singleton { provideHttpClient() } } private val productApi: IProductApi by kodein.newInstance { ProductApi(instance(), instance()) } } 

अशक्त गुणों में निर्भरता इंजेक्शन

यह अच्छी तरह से हो सकता है कि आपको पता नहीं है कि क्या कोई निर्भरता घोषित की गई है। यदि Kodein उदाहरण में निर्भरता घोषित नहीं की Kodein , तो ऊपर दिए गए उदाहरण से कोड को Kodein.NotFoundException में परिणाम होगा। यदि आप परिणाम के रूप में null प्राप्त करना चाहते हैं, अगर कोई निर्भरता नहीं है, तो इसके लिए तीन सहायक कार्य हैं: instanceOrNull() factoryOrNull() , factoryOrNull() और providerOrNull() ।

 class ProductApi(private val client: HttpClient?, private val gson: Gson) : IProductApi class Application : Application() { val kodein: Kodein = Kodein { bind<Gson>() with singleton { provideGson() } } private val productApi: IProductApi by kodein.newInstance { ProductApi(instanceOrNull(), instance()) } } 

कक्षा के अंदर निर्भरता प्राप्त करें।

जैसा कि पहले ही उल्लेख किया गया है, उस स्थिति में जब हम retrieval उपयोग करते हैं, सभी निर्भरता का प्रारंभ डिफ़ॉल्ट रूप से आलसी है। यह आपको केवल तब ही निर्भरता प्राप्त करने की अनुमति देता है जब उन्हें जरूरत होती है, और सिस्टम में पैदा होने वाली कक्षाओं में निर्भरता मिलती है।

Activity , Fragment और अन्य कक्षाएं अपने स्वयं के जीवन चक्र के साथ, यह उनके बारे में है।

Activity में निर्भरता को लागू करने के लिए Activity हमें केवल कोडीन के उदाहरण के लिए एक लिंक की आवश्यकता है, जिसके बाद हम अच्छी तरह से ज्ञात विधियों का उपयोग कर सकते हैं। वास्तव में, आपने पहले ही ऊपर retrieval उदाहरण देखे हैं, आपको बस एक संपत्ति की घोषणा करने और इसे कार्यों में से एक को सौंपने की आवश्यकता है: instance() , factory() या provider()

 private val number: BigDecimal by kodein.instance(arg = "23.87") private val numberFactory: (value: String) -> BigDecimal by kodein.factory() private val random: Random? by kodein.instanceOrNull() private val randomProvider: (() -> Random)? by kodein.providerOrNull() 

कारखानों में पैरामीटर पारित करना

आपने पहले ही देखा है कि कारखाने में एक पैरामीटर पास करने के लिए, यह instance फ़ंक्शन के arg पैरामीटर का उपयोग करने के लिए पर्याप्त है।लेकिन क्या होगा यदि कई पैरामीटर हैं (मैंने पहले कहा था कि एक कारखाने में 5 पैरामीटर हो सकते हैं )? आपको बस उस पैरामीटर को एक argवर्ग पास करना होगा Mजिसमें ओवरलोडेड निर्माता हैं और 2 से 5 तर्क ले सकते हैं।

 val kodein = Kodein { bind<IColorPicker>() with factory { r: Int, g: Int, b: Int, a: Int -> RgbColorPicker(r, g, b, a) } } val picker: IColorPicker by kodein.instance(arg = M(255, 211, 175, 215)) 

बल निर्भरता आरंभीकरण

जैसा कि उन्होंने कहा - डिफ़ॉल्ट रूप से, आरंभीकरण आलसी है, लेकिन आप एक ट्रिगर बना सकते हैं, इसे एक संपत्ति, कई गुणों या एक संपूर्ण उदाहरण से बाँध सकते हैं, Kodeinइस ट्रिगर को खींचने के बाद और निर्भरता को प्रारंभिक किया जाएगा।

 val myTrigger = KodeinTrigger() val gson: Gson by kodein.on(trigger = myTrigger).instance() /*...*/ myTrigger.trigger() //     Gson 

 val myTrigger = KodeinTrigger() val kodeinWithTrigger = kodein.on(trigger = myTrigger) val gson: Gson by kodeinWithTrigger.instance() /*...*/ myTrigger.trigger() //        kodeinWithTrigger 

आलसी कोडीन उदाहरण निर्माण

इससे पहले, हमने लगातार स्पष्ट रूप से एक उदाहरण बनाया है Kodein, लेकिन LazyKodeinनिर्माणकर्ता में एक फ़ंक्शन लेने वाले वर्ग का उपयोग करके इस संपत्ति के आरंभीकरण को स्थगित करना संभव है जो किसी वस्तु को वापस करना चाहिए Kodein।

यह दृष्टिकोण उपयोगी हो सकता है यदि, उदाहरण के लिए, यह ज्ञात नहीं है कि किसी दिए गए कोडीन उदाहरण से निर्भरता की आवश्यकता है या नहीं।

 val kodein: Kodein = LazyKodein { Kodein { bind<BigDecimal>() with factory { value: String -> BigDecimal(value) } bind<Random>() with provider { Random() } } } private val number: BigDecimal by kodein.instance(arg = "13.4") /* ... */ number.toPlainString() //     kodein    

कोडीन.लाजी के लिए एक कॉल एक समान परिणाम का नेतृत्व करेगा।

  val kodein: Kodein = Kodein.lazy { bind<BigDecimal>() with factory { value: String -> BigDecimal(value) } bind<Random>() with provider { Random() } } private val number: BigDecimal by kodein.instance(arg = "13.4") /* ... */ number.toPlainString() //     kodein    

कोडीन देरी शुरुआत

विलंबित आरंभीकरण के लिए, Kodeinएक वस्तु मौजूद है LateInitKodein। आप इस ऑब्जेक्ट को बना सकते हैं, इसके लिए गुणों के निर्माण को निर्दिष्ट baseKodeinकर सकते हैं , और आप ऑब्जेक्ट को इनिशियलाइज़ करने के बाद, उस पर प्रॉपर्टी सेट करते हैं , जिसके बाद आप पहले से ही आश्रितों तक पहुँच प्राप्त कर सकते हैं।

 val kodein = LateInitKodein() val gson: Gson by kodein.instance() /*...*/ kodein.baseKodein = /*     Kodein */ /*...*/ gson.fromJson(someStr) 

निर्दिष्ट प्रकार के सभी उदाहरण प्राप्त करें

आप कोडिन को निर्दिष्ट प्रकार के उदाहरण और इसके सभी वंशजों के रूप में पूछ सकते हैं List। सब कुछ केवल निर्दिष्ट टैग के भीतर है। ऐसा करने के लिए, वहाँ तरीके हैं allInstances, allProviders, allFactories।

  val kodein: Kodein = Kodein { bind<Number>() with singleton { Short.MAX_VALUE } bind<Double>() with singleton { 12.46 } bind<Double>("someTag") with singleton { 43.89 } bind<Int>() with singleton { 4562 } bind<Float>() with singleton { 136.88f } } val numbers: List<Number> by kodein.allInstances() 

यदि आप लॉग पर प्रिंट करते हैं, तो आप वहां देखेंगे [32767, 136.88, 4562, 12.46]। टैग के साथ निर्भरता सूची में नहीं है।

कोडीनवेयर इंटरफेस का उपयोग करके निर्भरता अधिग्रहण को सरल बनाएं

यह इंटरफ़ेस आपको टाइप संपत्ति को ओवरराइड करने के लिए बाध्य करता है Kodein, और बदले में उदाहरण के लिए उपलब्ध सभी कार्यों तक पहुंच प्रदान करता है Kodein।

 class MyApplication : Application(), KodeinAware { override val kodein: Kodein = Kodein { bind<Number>() with singleton { Short.MAX_VALUE } bind<Double>() with singleton { 12.46 } bind<Double>("someTag") with singleton { 43.89 } bind<Int>() with singleton { 4562 } bind<Float>() with singleton { 136.88f } } val numbers: List<Number> by allInstances() } 

जैसा कि आप देख सकते हैं, अब आप पहले के by allInstances()बजाय बस लिख सकते हैं by kodein.allInstances()

, हमने पहले ही निर्भरता प्राप्त करने के लिए ट्रिगर के बारे में बात की थी। इंटरफ़ेस में, KodeinAwareआप एक ट्रिगर को ओवरराइड कर सकते हैं और इस ट्रिगर को कॉल करने पर सभी घोषित निर्भरताएं प्राप्त कर सकते हैं।

 class MyApplication : Application(), KodeinAware { override val kodein: Kodein = Kodein { bind<Number>() with singleton { Short.MAX_VALUE } bind<Double>() with singleton { 12.46 } bind<Double>("someTag") with singleton { 43.89 } bind<Int>() with singleton { 4562 } bind<Float>() with singleton { 136.88f } } override val kodeinTrigger = KodeinTrigger() val numbers: List<Number> by allInstances() override fun onCreate() { super.onCreate() kodeinTrigger.trigger() } } 

चूँकि निर्भरताओं तक पहुँच और उदाहरण Kodeinआलसी है, आप उदाहरण को Kodeinकोटलिन में अंतर्निहित फ़ंक्शन के लिए आरम्भ कर सकते हैं lazy। इस तरह का दृष्टिकोण उनके संदर्भ के आधार पर कक्षाओं में उपयोगी हो सकता है, उदाहरण के लिए, में Activity।

 class CategoriesActivity : Activity(), KodeinAware { override val kodein: Kodein by lazy { (application as MyApplication).kodein } private val myFloat: Float by instance() 

उसी कारणों के लिए, आप एक संशोधक का उपयोग कर सकते हैं lateinit।

 class CategoriesActivity : Activity(), KodeinAware { override lateinit var kodein: Kodein private val myFloat: Float by instance() override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) kodein = (application as MyApplication).kodein } 

गुणों के प्रतिनिधित्व के बिना निर्भरता तक पहुंच

यदि किसी कारण से आप प्रॉपर्टी डेलिगेशन का उपयोग नहीं करना चाहते हैं, तो आप डायरेक्ट से DKodein(डायरेक्ट से) एक्सेस का उपयोग कर सकते हैं । मुख्य अंतर यह होगा कि अब आलसी आरंभीकरण नहीं होगा instance, कॉल के समय निर्भरता तुरंत प्राप्त होगी , providerऔर इसी तरह के कार्य। आप DKodeinइसे मौजूदा कोडीन उदाहरण से प्राप्त कर सकते हैं या खरोंच से निर्माण कर सकते हैं ।

 class MyApplication : Application(), KodeinAware { override val kodein: Kodein = Kodein { bind<BigDecimal>() with singleton { BigDecimal.TEN } } val directKodein: DKodein = kodein.direct val directKodein2: DKodein = Kodein.direct { bind<BigDecimal>() with singleton { BigDecimal.ONE } } val someNumber:BigDecimal = directKodein.instance() val someNumber2:BigDecimal = directKodein2.instance() 

कोडीन का उपयोग ढांचे में किया जा सकता है KodeinAware, और DKodeinढांचे DKodeinAwareमें आप प्रयोग कर सकते हैं।

किसी भी संदर्भ में निर्भरता प्राप्त करें

एक वस्तु से एक Kodeinही प्रकार की कई निर्भरताएँ प्राप्त करने के लिए, हमने पहले से ही तर्कों के साथ टैग और कारखानों का उपयोग करने के विकल्प की जांच की है, लेकिन एक और बात है - एक संदर्भ का उपयोग करने के लिए (और यह वह संदर्भ नहीं है जो Android में है)।

टैग के साथ निर्भरता से अंतर:

• किसी फ़ंक्शन के अंदर एक टैग का उपयोग नहीं किया जा सकता है जिसमें हम एक निर्भरता बनाते हैं
• संदर्भ का उपयोग करते समय, हमारे पास निर्भरता निर्माण फ़ंक्शन में संदर्भ उदाहरण तक पहुंच होती है

अक्सर, संदर्भ के बजाय, आप एक तर्क के साथ एक कारखाने का उपयोग कर सकते हैं, और डेवलपर्स Kodeinयह करने की सलाह देते हैं यदि आप अनिश्चित हैं कि क्या उपयोग किया जाए। लेकिन संदर्भ उपयोगी हो सकता है, उदाहरण के लिए, जब आप एक ही प्रकार के दो तर्क नहीं दे सकते।

उदाहरण के लिए, आपके पास Activityऔर Presenter, और आप चाहते हैं, एक वस्तु का उपयोग करके Kodein, विभिन्न प्रकार की विभिन्न निर्भरता प्रदान करने के लिए, वे किस वर्ग में प्राप्त होते हैं, इस पर निर्भर करता है। नेतृत्व करने के लिए Activityऔर Presenterएक प्रकार के लिए - आप एक वैकल्पिक इंटरफेस की जरूरत है, और कारखाने के परिणामस्वरूप तर्क के प्रकार की जांच करनी होगी। योजना बहुत सुविधाजनक नहीं है। इसलिए, हम संदर्भ का उपयोग करने का तरीका देखते हैं:

 class MyApplication : Application(), KodeinAware { override val kodein: Kodein = Kodein { bind<BigDecimal>() with contexted<CategoriesActivity>().provider { context.getActivityBigDecimal() } bind<BigDecimal>() with contexted<CategoriesPresenter>().factory { initialValue:BigDecimal -> context.getPresenterBigDecimal(initialValue) } } } class CategoriesActivity : Activity(), AppKodeinAware { fun getActivityBigDecimal() = BigDecimal("16.34") private val activityBigDecimal: BigDecimal by kodein.on(context = this).instance() } class CategoriesPresenter : AppKodeinAware { fun getPresenterBigDecimal(initialValue: BigDecimal) = initialValue * BigDecimal.TEN private val presenterBigDecimal: BigDecimal by kodein.on(context = this).instance(arg = BigDecimal("31.74")) } 

एक उदाहरण, निश्चित रूप से, कानों के ऊपर खींच लिया जाएगा और वास्तविक व्यवहार में यह संभावना नहीं है कि आप ऐसी स्थिति का सामना करेंगे, लेकिन यह उदाहरण दिखाता है कि संदर्भ कैसे काम करता है।

एक निर्भरता की घोषणा करने के लिए, आप निर्दिष्ट नहीं करते हैं with provider(), लेकिन with contexted<OurContextClass>().provider, OurContextClassकक्षा का प्रकार कहां है, इसका एक उदाहरण एक संदर्भ के रूप में कार्य करेगा। contextedकेवल प्रदाता या कारखाने हो सकते हैं।

फ़ंक्शन में इस संदर्भ तक पहुंच जो निर्भरता लौटाता है नामांकित चर के माध्यम से किया जाता है context।

किसी संदर्भ से निर्भरता प्राप्त करने के लिए, आपको पहले Kodeinफ़ंक्शन के माध्यम से ऑब्जेक्ट के लिए संदर्भ निर्दिष्ट करना होगा on(), और फिर निर्भरता का अनुरोध करना होगा।

इसी तरह, संदर्भ का उपयोग मामले में किया जाता है injection।

 private val productApi: IProductApi by kodein.on(context = someContext).newInstance { ProductApi(instance(), instance()) } } 

Android एक्सटेंशन

लेख की शुरुआत में, मैंने विस्तार के विकल्पों पर विचार करने का वादा किया Android। जैसा कि हमने ऊपर चर्चा की थी, इसका
उपयोग Kodeinकरने से कुछ भी नहीं रोकता है, लेकिन आप सब कुछ परिमाण के क्रम को अधिक सुविधाजनक बना सकते हैं।

एंड्रॉइड के लिए अंतर्निहित कोडीन

एक बहुत ही उपयोगी चीज एंड्रॉइड के लिए तैयार एक मॉड्यूल है। इसे कनेक्ट करने के लिए, वर्ग के लिए आवश्यक है कि वह संपत्ति को Applicationलागू करने KodeinAwareऔर प्रारंभिक रूप से Kodein(उदाहरण का उपयोग करने के लिए Application) शुरू करे। बदले में, आपको बड़ी संख्या में घोषित निर्भरताएं मिलती हैं जो आपको कक्षा से मिल सकती हैं Application, जिसमें आपकी ज़रूरत की सभी चीजें शामिल हैं Context। कैसे कनेक्ट करें - एक उदाहरण देखें।

 class MyApplication : Application(), KodeinAware { override val kodein = Kodein.lazy { import(androidModule(this@MyApplication)) //  } val inflater: LayoutInflater by instance() } 

आप देख सकते हैं - आप उदाहरण के लिए, प्राप्त कर सकते हैं LayoutInflater। मॉड्यूल में घोषित निर्भरता की पूरी सूची के लिए - यहां देखें ।

यदि आप एंड्रॉइड कक्षाओं के बाहर इन निर्भरताओं को प्राप्त करना चाहते हैं जो उनके संदर्भ से अवगत हैं, तो संदर्भ स्पष्ट रूप से निर्दिष्ट करें।

 val inflater: LayoutInflater by kodein.on(context = getActivity()).instance() 

निकटतम Kodein के माध्यम से जल्दी से माता-पिता कोदिन प्राप्त करें ()

यह सरल है, एंड्रॉइड में, कुछ ऑब्जेक्ट दूसरों पर निर्भर करते हैं। शीर्ष स्तर पर अनुप्रयोग है, जिसके तहत गतिविधि है, फिर टुकड़ा है। आप गतिविधि में लागू कर सकते हैं KodeinAware, और एक आरंभ के रूप में, कॉल कर सकते हैं closestKodein()और इस तरह से एक उदाहरण Kodeinप्राप्त कर सकते हैं Application।

 class MyActivity : Activity(), KodeinAware { override val kodein by closestKodein() val ds: DataSource by instance() } 

closestKodeinआप इसे एंड्रॉइड कक्षाओं के बाहर भी प्राप्त कर सकते हैं, लेकिन आपको एक एंड्रॉइड संदर्भ चाहिए, जिससे आप फ़ंक्शन को कॉल कर सकते हैं। यदि आप इसका उपयोग करते हैं KodeinAware, तो इसके लिए संदर्भ निर्दिष्ट करें (संबंधित संपत्ति को ओवरराइड करें और फ़ंक्शन को एंड्रॉइड संदर्भ पास करें kcontext())।

 class MyController(androidContext: Context) : KodeinAware { override val kodein by androidContext.closestKodein() override val kodeinContext = kcontext(androidContext) val inflater: LayoutInflater by instance() } 

गतिविधि में एक अलग कोडीन बनाएं

यह गतिविधि में मूल कोडिन से विरासत में लेना और उसका विस्तार करना अच्छी तरह से आवश्यक हो सकता है। समाधान काफी सरल है।

 class MyActivity : Activity(), KodeinAware { private val parentKodein by closestKodein() override val kodein: Kodein by Kodein.lazy { extend(parentKodein) /*   */ } } 

कोडीन जो विन्यास परिवर्तन से गुजर रहा है

हाँ, आप कर सकते हैं। इसके लिए एक फंक्शन है retainedKodein। इसका उपयोग करते समय, Kodeinएक कॉन्फ़िगरेशन परिवर्तन के बाद ऑब्जेक्ट को फिर से बनाया नहीं जाएगा।

 class MyActivity : Activity(), KodeinAware { private val parentKodein by closestKodein() override val kodein: Kodein by retainedKodein { extend(parentKodein) } } 

लेख में क्या नहीं कहा गया है?

मैंने पूरा होने का नाटक नहीं किया था, और मैं खुद कुछ चीजों को अच्छी तरह से नहीं समझता कि उन्हें बताने की कोशिश करूं। यहां मूल सिद्धांतों को जानकर आप स्वयं क्या सीख सकते हैं, इसकी एक सूची है:

• कार्यक्षेत्र
• उदाहरण बाँधना
• मल्टी बाध्यकारी
• पहले से ही कॉलबैक
• बाहरी स्रोत
• मिटाया हुआ संस्करण नुकसान
• कॉन्फ़िगर करने योग्य कोडीन
• जेएसआर -330 कम्पैटिबिलिटी

अच्छी तरह से और प्रलेखन के लिए लिंक:

• कोर 5.3
• Android 5.3
• प्रारंभ पृष्ठ

पढ़ने के लिए धन्यवाद, मुझे आशा है कि लेख आपके लिए उपयोगी होगा!