डैगर 1 की plus()विधि कुछ ऐसी है जिसका मैंने पिछले अनुप्रयोगों में काफी बार उपयोग किया है, इसलिए मैं उन स्थितियों को समझता हूं, जहां आप मूल ग्राफ़ बाइंडिंग के लिए पूर्ण पहुंच के साथ एक उपसमुच्चय चाहते हैं।
किस स्थिति में उप-निर्भर निर्भरता के बजाय घटक निर्भरता का उपयोग करना फायदेमंद होगा और क्यों?
जवाबों:
घटक निर्भरता - जब आप दो घटकों को स्वतंत्र रखना चाहते हैं तो इसका उपयोग करें।
उपसंपादक - इसका उपयोग तब करें जब आप दो घटकों को युग्मित रखना चाहते हैं।
मैं घटक निर्भरता और सब- कम्यूटर को समझाने के लिए नीचे दिए गए उदाहरण का उपयोग करूंगा । उदाहरण के बारे में ध्यान देने योग्य कुछ बिंदु हैं:
SomeClassA1बिना किसी निर्भरता के बनाया जा सकता है। ModuleAप्रदान करता है और विधि के SomeClassA1माध्यम से उदाहरण provideSomeClassA1()।SomeClassB1के बिना नहीं बनाया जा सकता SomeClassA1। केवल ModuleBएक उदाहरण प्रदान कर सकता है SomeClassB1यदि एक उदाहरण विधि के SomeClassA1तर्क के रूप में पारित किया जाता है provideSomeClassB1()।@Module
public class ModuleA {
@Provides
public SomeClassA1 provideSomeClassA1() {
return new SomeClassA1();
}
}
@Module
public class ModuleB {
@Provides
public SomeClassB1 provideSomeClassB1(SomeClassA1 someClassA1) {
return new SomeClassB1(someClassA1);
}
}
public class SomeClassA1 {
public SomeClassA1() {}
}
public class SomeClassB1 {
private SomeClassA1 someClassA1;
public SomeClassB1(SomeClassA1 someClassA1) {
this.someClassA1 = someClassA1;
}
}डैगर के कहने गुजर का ख्याल रखना होगा SomeClassA1करने के लिए एक तर्क के रूप provideSomeClassB1()में विधि ModuleBजब भी घटक / उप-घटक घोषणा ModuleBआरंभ नहीं हो जाता। हमें डैगर को निर्देश देने की आवश्यकता है कि निर्भरता को कैसे पूरा किया जाए। यह या तो घटक निर्भरता या उपसंयोजक का उपयोग करके किया जा सकता है ।
घटक निर्भरता उदाहरण में निम्नलिखित बातों पर ध्यान दें:
ComponentBएनोटेशन dependenciesपर विधि के माध्यम से निर्भरता को परिभाषित करना है @Component। ComponentAघोषित करने की आवश्यकता नहीं है ModuleB। यह दो घटकों को स्वतंत्र रखता है।public class ComponentDependency {
@Component(modules = ModuleA.class)
public interface ComponentA {
SomeClassA1 someClassA1();
}
@Component(modules = ModuleB.class, dependencies = ComponentA.class)
public interface ComponentB {
SomeClassB1 someClassB1();
}
public static void main(String[] args) {
ModuleA moduleA = new ModuleA();
ComponentA componentA = DaggerComponentDependency_ComponentA.builder()
.moduleA(moduleA)
.build();
ModuleB moduleB = new ModuleB();
ComponentB componentB = DaggerComponentDependency_ComponentB.builder()
.moduleB(moduleB)
.componentA(componentA)
.build();
}
}निम्नलिखित बिंदुओं को SubComponent उदाहरण में नोट करें:
ComponentBकि निर्भरता को परिभाषित नहीं किया गया है ModuleA, यह स्वतंत्र रूप से नहीं रह सकता है। यह उस घटक पर निर्भर हो जाता है जो प्रदान करेगा ModuleA। इसलिए इसमें एक @Subcomponentएनोटेशन है।ComponentAModuleBइंटरफ़ेस विधि के माध्यम से घोषित किया गया है componentB()। यह दो घटकों को युग्मित करता है। वास्तव में, ComponentBकेवल के माध्यम से आरंभ किया जा सकता है ComponentA।public class SubComponent {
@Component(modules = ModuleA.class)
public interface ComponentA {
ComponentB componentB(ModuleB moduleB);
}
@Subcomponent(modules = ModuleB.class)
public interface ComponentB {
SomeClassB1 someClassB1();
}
public static void main(String[] args) {
ModuleA moduleA = new ModuleA();
ComponentA componentA = DaggerSubComponent_ComponentA.builder()
.moduleA(moduleA)
.build();
ModuleB moduleB = new ModuleB();
ComponentB componentB = componentA.componentB(moduleB);
}
}SomeClassB1पर निर्भर है SomeClassA1। ComponentAस्पष्ट रूप से निर्भरता को परिभाषित किया है।" ==> क्या आपका मतलब है " ComponentBनिर्भरता को स्पष्ट रूप से परिभाषित करना है"?
SomeClassB1पर निर्भर है SomeClassA1। ComponentAस्पष्ट रूप से निर्भरता को परिभाषित करने की आवश्यकता नहीं है।" आपका मतलब था " ComponentBनिर्भरता को स्पष्ट रूप से परिभाषित करने की आवश्यकता नहीं है।"
प्रलेखन के अनुसार :
Component Dependencyआपको घटक निर्भरता के माध्यम से प्रावधान विधियों के रूप में उजागर केवल बाइंडिंग तक पहुंच प्रदान करता है, अर्थात आपके पास केवल उन प्रकारों तक पहुंच होती है जो माता-पिता में घोषित होते हैं Component।
SubComponentयह घोषित होने पर आपको अपने माता-पिता से पूरे बाध्यकारी ग्राफ तक पहुंच प्रदान करता है, यानी आपके पास इसके Moduleएस में घोषित सभी वस्तुओं तक पहुंच है ।
आइए कहते हैं, आप एक ApplicationComponentसब युक्त Androidसंबंधित सामान ( LocationService, Resources, SharedPreference, आदि)। आप यह भी चाहते हैं कि एपीआई के साथ सौदा करने के DataComponentलिए आप जहां दृढ़ता के लिए चीजों का प्रबंधन WebServiceकरते हैं। केवल एक चीज जिसकी आपमें कमी DataComponentहै Application Context, वह है ApplicationComponent। सबसे आसान तरीका है एक पाने के लिए Contextसे DataComponentपर निर्भरता होगा ApplicationComponent। आपको यह सुनिश्चित करने की आवश्यकता है कि आपके पास Contextस्पष्ट रूप से घोषित किया गया है ApplicationComponentक्योंकि आपके पास केवल घोषित सामान तक पहुंच है। इस मामले में, कोई मैनुअल काम नहीं है, जिसका अर्थ है कि आपको Submodulesमाता Component- पिता में निर्दिष्ट करने की आवश्यकता नहीं है और स्पष्ट रूप से अपने सबमॉडल को मूल मॉड्यूल में जोड़ें:
MySubcomponent mySubcomponent = myComponent.plus(new ChildGraphModule("child!")); // No need!
अब जब कि इस मामले में जहां आप इंजेक्षन करना चाहते हैं पर विचार WebServiceसे DataComponentऔर LocationServiceसे ApplicationComponentअपने में Fragmentउपयोग करते हुए जो बांध @Submodule plusऊपर सुविधा। यहाँ पर ठंडी बात यह है कि जिस घटक से आप बंधे हुए हैं ( ApplicationComponent) को न तो एक्सपोज़ करने की आवश्यकता है WebServiceऔर न ही LocationServiceआपके पास पूरे ग्राफ तक पहुँच है।
@Submodule। क्या यह एक टाइपो है?
classesउदाहरण के रूप में कम और सटीक बिंदु को चित्रित करने के लिए अधिक चित्रों के लिए मदद करेगा ।
यहाँ घटक और उप-समूह की अधिक समझ के लिए स्क्रीनशॉट के साथ कोड उदाहरण है:
घटक:
उप-घटक:
और चित्रमय आरेख:
स्रोत: लिंक
एक और बात जो मुझे अब तक महसूस नहीं हुई, वह है:
@Subcomponentउदाहरण में वास्तव में एक मूल घटक होता है (हालाँकि विभिन्न घटक एक ही @Subcomponentहो सकते हैं और उसी उदाहरण के माता-पिता हो सकते हैं)@Componentशून्य, एक या कई "जनक" घटकों के माध्यम से घोषित हो सकता है घटक निर्भरता