डैगर 2 प्राथमिक है (भाग 2)

पिछला हिस्सा

सामग्री

1. विधियों और क्षेत्रों को लागू करें
2. डैगर में विलंबित आरंभीकरण
3. डैगर मॉड्यूल। जब खंजर आपको समझ में नहीं आता है
4. सार नाम दिया। एक ही प्रकार के कई उदाहरण

विधियों और क्षेत्रों को लागू करें

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

विधि कार्यान्वयन उदाहरण:

class Car @Inject constructor(private var engine: Engine){ var key: Key? = null @Inject set } class Key @Inject constructor() 

उपरोक्त उदाहरण में, कुंजी फ़ील्ड के लिए सेट विधि निर्भरता लागू की गई है

खेतों का कार्यान्वयन तीन चरणों में होता है:

1. अमूर्त कारखाने के लिए एम्बेड विधि जोड़ें
2. लागू किए जाने वाले क्षेत्रों को परिभाषित करें
3. निर्भरता को लागू करने के लिए एक अमूर्त वर्ग डैगर कार्यान्वयन में कार्यान्वयन विधियों का उपयोग करें

इसे स्पष्ट रूप से समझना आसान होगा, क्रम में

1. हमारे सार वर्ग में, MainActivity के लिए एक कार्यान्वयन विधि जोड़ें

 @Component interface DaggerComponent { fun getCar(): Car fun getEngine(): Engine fun getFuel(): Fuel fun inject(act: MainActivity) } 

2. उन क्षेत्रों को परिभाषित करें जिन्हें MainActivity में लागू किया जाना चाहिए। इंजेक्ट किए गए फ़ील्ड लेटनीट var होने चाहिए और सभी के लिए दृश्यमान होंगे (सार्वजनिक)

 @Injected lateinit var car: Car 

3. हम गतिविधि क्षेत्रों को लागू करने के लिए अमूर्त वर्ग के जोड़े गए विधि इंजेक्शन () को कहते हैं।

अंत में, हमारी MainActivity class ट्रेस की तरह दिखाई देगी। जिस तरह से:

 class MainActivity : AppCompatActivity() { @Inject lateinit var car: Car override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) DaggerDaggerComponent.create().inject(this) } } 

डैगर में विलंबित आरंभीकरण

जैसा कि आप जानते हैं, एक आवेदन शुरू करते समय, सभी वर्गों के उदाहरणों की हमेशा आवश्यकता नहीं होती है। यह पहले लॉन्च और अधिक को गति देता है। खंजर में एम्बेडेड ऑब्जेक्ट्स के प्रारंभ के 2 प्रकार हैं: प्रदाता <> और आलसी <>

प्रदाता - ऑब्जेक्ट पर पहली कॉल पर इनिशियलाइज़ेशन होता है और प्रत्येक कॉल के साथ ऑब्जेक्ट का एक नया उदाहरण वापस आ जाएगा
आलसी - पहले कॉल पर इनिशियलाइज़ेशन होता है, फिर पहले कैश्ड इंस्टेंस वापस आ जाते हैं

इन प्रकार के आरंभीकरण का उपयोग करने के लिए, प्रारंभिक वस्तुओं को वांछित रूप में "लपेट" करना आवश्यक है।

प्रदाता उपयोग उदाहरण:

 class Engine @Inject constructor(private var fuel: Fuel){ fun start(){ if(fuel!=null){ print("Started!") }else{ print("No more fuel!") } } } class Car @Inject constructor(private var engine: Provider<Engine>){ var key: Key? = null @Inject set fun startCar(){ engine.get().start() } } class Key @Inject constructor() 

हर बार प्राप्त () विधि को कहा जाता है, हमें वांछित वस्तु का एक नया उदाहरण मिलता है।

आलसी का उपयोग करने का एक उदाहरण:

 class Fuel @Inject constructor() { val fuelType = if(BuildConfig.DEBUG){ "benzine" }else{ "diesel" } } class Engine @Inject constructor(private var fuel: Lazy<Fuel>){ fun start(){ if(fuel!=null){ print("Started with ${fuel.get().fuelType}") }else{ print("No more fuel!") } } } 

प्रत्येक बार प्राप्त () विधि को कहा जाता है, हमें एक ही उदाहरण मिलता है।

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

 import dagger.Lazy 

डैगर मॉड्यूल। जब खंजर आपको समझ में नहीं आता है

कई बार ऐसा होता है जब कोई खंजर आपके इरादों को समझ नहीं पाता है। उदाहरण के लिए, हमारी कार कक्षा में टाइप (इंटरफ़ेस) ड्राइवर का एक क्षेत्र है, जो इवानोव वर्ग द्वारा विरासत में मिला है

जब आप किसी इंटरफ़ेस प्रकार के साथ किसी फ़ील्ड को कार्यान्वित करने का प्रयास करते हैं, तो आपको "प्रोवाइड-एनोटेट किए गए तरीकों के बिना" प्रदान नहीं किया जा सकता है।

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

उपरोक्त समस्या को हल करने के लिए, एक मॉड्यूल बनाएं:

 @Module interface DaggerModul { @Binds fun bindDriver(driver: Ivanov): Driver } class Ivanov @Inject constructor(): Driver 

बाइंडड्राइवर विधि में, हम इंटरफ़ेस को इनिशियलाइज़ करने के तरीके के बारे में बताते हैं।

इसके अलावा घटक में आपको सभी मौजूदा डैगर मॉड्यूल को सूचीबद्ध करना होगा

 @Component(modules = [DaggerModul::class]) interface DaggerComponent { … } 

हमारे वर्ग के इंजन के लिए मान लीजिए कि थर्ड-पार्टी लाइब्रेरी सिलेंडर (इंटरफ़ेस) के क्षेत्र का उपयोग किया जाता है। डैगर के लिए इस तरह के क्षेत्र का वर्णन कैसे करें यदि यह स्पष्ट नहीं है कि रनटाइम में किस वर्ग को शुरू किया जाएगा?

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

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

 @Module object DaggerModuleObject { @Provides @JvmStatic fun getBoschCylinder(): Cylinder = BoschCylinder() } 

इस प्रकार, हम डैगर को बताते हैं कि सिलेंडर फील्ड को इनिशियलाइज़ करते समय, हमें बॉश सिलिंडर क्लास का एक उदाहरण चाहिए।

सार नाम दिया । एक ही प्रकार के कई उदाहरण

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

ट्रेस के साथ प्रोजेक्ट बनाने का प्रयास करते समय। मॉड्यूल को त्रुटि मिलेगी "(हमारी कक्षा) रंग कई बार बंधा हुआ है"

 @Provides @JvmStatic fun getColorRed():Color = Color("red") @Provides @JvmStatic fun getColorBlue():Color = Color("blue") 

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

 @JvmStatic @Provides fun getColor(): Color = Color("") @Provides @Named("blueColor") @JvmStatic fun getColorBlue(): Color{ return Color("blue") } @JvmStatic @Named("redColor") @Provides fun getColorRed(): Color = Color("red") 

पहली विधि डिफ़ॉल्ट है, इसके बिना खंजर वर्ग की अनुपस्थिति के बारे में शपथ लेगा "एक इंजेक्टर निर्माता या एक प्रोवेड-एनोटेट विधि के बिना प्रदान नहीं किया जा सकता है"

निम्न दो विधियाँ एक ही वर्ग के उदाहरणों को लौटाती हैं। यह सही स्थानों पर इस वर्ग के कार्यान्वयन को जोड़ने और एनोटेशन नामांकित के साथ कॉल करने के लिए बनी हुई है

 class Door @Inject constructor() { @Named("blueColor") @Inject lateinit var color:Color } class Car @Inject constructor(private var engine: Provider<Engine>, private var door: Door, var driver: Driver){ var key: Key? = null @Inject set @Inject @Named("redColor") lateinit var color: Color fun startCar(){ engine.get().start() } } class Key @Inject constructor() 

स्रोत कोड