डेजर-आधारित प्रोजेक्ट को डैगर

Question

पर माइग्रेट करना मेरे पास वेनिला गिइस का उपयोग करके एक गिइस आधारित प्रोजेक्ट है; कोई असिस्टेड इंजेक्शन नहीं, कोई एओपी नहीं, कोई अतिरिक्त प्लगइन गुइस इत्यादि का विस्तार नहीं करता है। एंड्रॉइड पर इसे अधिक आसानी से चलाने के लिए, डैगर बेहतर समाधान की तरह दिखता है। प्रत्येक वर्ग की निर्भरता और @Inject एनोटेशन के साथ एक कन्स्ट्रक्टर है। कोई फ़ील्ड या विधि इंजेक्शन का उपयोग नहीं किया जाता है।

मॉड्यूल काफी सरल (Guice एक overkill बनाने) और ज्यादातर की तरह बाइंडिंग शामिल हैं निम्नलिखित:

class SomethingModule extends AbstractModule { 

    protected void configure() { 
    Bind(Handler.class) 
     .annotatedWith(Names.named("something")) 
     .to(SomeImplementation.class); 
    } 
    } 

} 

और बाद में निम्नलिखित की तरह इस्तेमाल किया:

Injector inj = Guice.createInjector(new SomethingModule()); 
... = inj.getInstance(SampleInterface.class); 
// and rest of the code. 

दुर्भाग्य से, मैं नहीं कर सकता मेरे सिर को Daggers terminology के आसपास प्राप्त करें। क्या आप मुझे एक गेज मॉड्यूल के प्रत्यक्ष अनुवाद/रूपांतरण के साथ एक डैगर मॉड्यूल में मार्गदर्शन कर सकते हैं?

डैगर है:

• डैगर के अवयव।
• डैगर मॉड्यूल।
• @Provides
• @Inject

Guice है:

• @Inject
• @Named (या किसी भी कस्टम एनोटेशन, अगर सही ढंग से लागू)।
• हमारे मॉड्यूल AbstractModule का विस्तार कर रहे हैं। मॉड्यूल में
• @Provides।
• गुइस Injector मॉड्यूल से बनाया गया।

ये कैसे संबंधित हैं?

अद्यतन: EpicPandaForce के अच्छे उत्तर के अलावा, these slides भी मदद कर सकता है।

Answer 1

Bind(Handler.class) 
.annotatedWith(Names.named("something")) 
.to(SomeImplementation.class); 

@Module 
public class SomethingModule { 
    @Provides 
    @Named("something") 
    //scope if needed 
    public Handler handler() { 
     return new SomeImplementation(); 
    } 
} 

कौन सा एक "Injector" (घटक) करने के लिए बाध्य किया जाएगा करने के लिए अनुवाद होगा:

@Component(modules={SomethingModule.class}) 
//scope if needed 
public interface SomethingComponent { 
    @Named("something") 
    Handler handler(); 

    void inject(ThatThingy thatThingy); 
} 

कौन सा एक "इंजेक्टर" आप के साथ बनाने के लिए वह यह है कि एपीटी-जेनरेटेड बिल्डर:

SomethingComponent somethingComponent = DaggerSomethingComponent.builder() 
              .somethingModule(new SomethingModule()) //can be omitted, has no params 
              .build(); 
somethingComponent.inject(thatThingy); 

कहाँ कि thingy

public class ThatThingy { 
    @Inject 
    @Named("something") 
    Handler handler; 
} 

अवयव है आम तौर पर गुंजाइश प्रति मौजूद हैं, तो उदाहरण के @ApplicationScope के लिए है एक "इंजेक्टर" (घटक)। स्कोपिंग सबकंपोनेंट्स और घटक निर्भरताओं के साथ हासिल की जा सकती है।

महत्वपूर्ण तथ्य, एक घटक में प्रावधान विधियां हैं (जो निर्भरताएं हैं जो घटक निर्भरताओं का उपयोग करते समय घटित घटकों के लिए विरासत में हैं), और void inject(X x); स्वरूपित विधियां। फ़ील्ड इंजेक्शन प्रति कंक्रीट प्रकार के लिए यह आवश्यक है। उदाहरण के लिए एक बेस क्लास केवल खुद, और इसके सबक्लास को इंजेक्ट कर सकता है। हालांकि आप protected abstract void injectThis() नामक एक विधि लिख सकते हैं जो उप-वर्ग पर .inject(this) को भी कॉल करेगा।

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

@Module(includes={ThoseModule.class, TheseModule.class}) 
public class SomethingModule { 
    @Provides 
    @Singleton 
    public Whatever whatever(Those those, These these) { 
     return new Whatever(those, these); 
    } 
} 

public class Whatever { 
    Those those; 
    These these; 

    public Whatever(Those those, These these) { 
     this.those = those; 
     this.these = these; 
    } 
} 

@Component(modules={SomethingModule.class}) 
@Singleton 
public interface SomethingComponent { 
    These these(); 
    Those those(); 
    Whatever whatever(); 
}