डेगर के साथ निर्भरता इंजेक्शन का परिचय

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

परिष्कृत परिभाषा के बावजूद, सिद्धांत काफी सरल और तुच्छ है। मुझे यकीन है कि अधिकांश प्रोग्रामर ने एक तरह से या किसी अन्य ने इस पैटर्न को लागू किया, यहां तक ​​कि कभी-कभी इसे साकार किए बिना।

ट्विटर क्लाइंट के एक सरलीकृत (छद्म कोड तक) संस्करण पर विचार करें।

सिद्धांत रूप में, एक निर्भरता आरेख कुछ इस तरह दिखता है:


आइए देखें कि यह कोड में कैसा दिखता है:

public class Tweeter { public void tweet(String tweet) { TwitterApi api = new TwitterApi(); api.postTweet("Test User", tweet); } } public class TwitterApi { public void postTweet(String user, String tweet) { HttpClient client = new OkHttpClient(); HttpUrlConnection connection = client.open("...."); /* post tweet */ } } 

जैसा कि आप देख सकते हैं, इंटरफेस का सेट काफी सरल है, इसलिए हम इसे इस तरह उपयोग करेंगे:

 Tweeter tweeter = new Tweeter(); tweeter.tweet("Hello world!"); 

जबकि सब कुछ ठीक चल रहा है, ट्वीट उड़ रहे हैं - हर कोई खुश है। अब इस सबको परखने की जरूरत है। तुरंत हम नोटिस करते हैं कि किसी भी तरह के परीक्षा परिणाम को वापस करने और हर बार नेटवर्क में न टूटने के लिए एक टेस्ट एक के साथ Http क्लाइंट को बदलने में सक्षम होना अच्छा होगा। इस मामले में, हमें TwitterApi वर्ग से एक Http क्लाइंट बनाने की बाध्यता को हटाने और इस दायित्व को उच्च कक्षाओं में उतारने की आवश्यकता है। हमारा कोड थोड़ा बदल गया है:

 public class Tweeter { private TwitterApi api; public Tweeter(HttpClient httpClient) { this.api = new TwitterApi(httpClient); } public void tweet(String tweet) { api.postTweet("Test User", tweet); } } public class TwitterApi { private HttpClient client; public TwitterApi(HttpClient client) { this.client = client; } public void postTweet(String user, String tweet) { HttpUrlConnection connection = client.open("...."); /* post tweet */ } } 

अब हम देखते हैं कि, यदि आवश्यक हो, तो हम अपने कोड का परीक्षण करते हैं, हम आसानी से एक परीक्षण Http क्लाइंट को "स्थानापन्न" कर सकते हैं जो परीक्षा परिणाम लौटाएगा:

 Tweeter tweeter = new Tweeter(new MockHttpClient); tweeter.tweet("Hello world!"); 

ऐसा लगता है कि यह आसान हो सकता है? वास्तव में, हमने अब "मैन्युअल रूप से" निर्भरता इंजेक्शन पैटर्न को लागू किया है। लेकिन एक "लेकिन" है ऐसी स्थिति की कल्पना करें कि हमारे पास एक टाइमलाइन वर्ग है जो अंतिम n संदेशों को लोड कर सकता है। यह वर्ग TwitterApi का भी उपयोग करता है:

 Timeline timeline = new Timeline(new OkHttpClient(), "Test User"); timeline.loadMore(20); for(Tweet tweet: timeline.get()) { System.out.println(tweet); } 

हमारी कक्षा कुछ इस तरह दिखती है:

 public class Timeline { String user; TweeterApi api; public Timeline(HttpClient httpClient, String user) { this.user = user; this.api = new TweeterApi(httpClient); } public void loadMore(int n){/*.....*/} public List<Tweet> get(){/*.......*/} } 

सब कुछ ठीक लगता है - हमने ट्वीटर वर्ग के साथ एक ही दृष्टिकोण का उपयोग किया - ऑब्जेक्ट बनाते समय एचटीपी क्लाइंट को निर्दिष्ट करना संभव बना दिया, जो हमें नेटवर्क पर निर्भर हुए बिना इस मॉड्यूल का परीक्षण करने की अनुमति देता है। लेकिन! क्या आपने देखा कि हमने कितना कोड डुप्लिकेट किया और हमें एप्लिकेशन के "हेड" से Http क्लाइंट को "पुश" कैसे करना है? बेशक, आप डिफ़ॉल्ट कंस्ट्रक्टर जोड़ सकते हैं जो एक वास्तविक एचटीपी क्लाइंट बनाएंगे और केवल परीक्षण के लिए एक कस्टम कंस्ट्रक्टर का उपयोग करेंगे, लेकिन यह समस्या को हल नहीं करता है, लेकिन केवल इसे प्रच्छन्न करता है।

आइए देखें कि हम इस स्थिति को कैसे सुधार सकते हैं।

कटार

डैगर एक ओपन सोर्स डिपेंडेंसी इंजेक्शन लाइब्रेरी है, जो ओक्टेट, रेट्रोफिट, पिकासो और कई अन्य एंड्रॉइड डेवलपर्स के लिए जाना जाता है।

डैगर के मुख्य लाभ (समान गाइस की तुलना में):

• सभी निर्भरताओं का स्थैतिक विश्लेषण
• संकलन चरण में कॉन्फ़िगरेशन त्रुटियों का पता लगाना (न केवल रनटाइम में)
• प्रतिबिंब की कमी, जो विन्यास प्रक्रिया को बहुत तेज करती है
• बहुत कम मेमोरी लोड

डैगर में, निर्भरता कॉन्फ़िगरेशन प्रक्रिया 3 बड़े ब्लॉकों में विभाजित है:

• निर्भरता के ग्राफ का आरंभीकरण (ObjectGraph)
• निर्भरता अनुरोध ( @Inject )
• निर्भरता संतुष्टि ( @Module / @Provides )

निर्भरता का अनुरोध करें

@Inject को किसी एक फ़ील्ड को इनिशियलाइज़ करने के लिए कहने के लिए, आपको केवल @Inject एनोटेशन जोड़ना होगा:

 @Inject private HttpClient client; 

... और सुनिश्चित करें कि यह वर्ग निर्भरता ग्राफ में जोड़ा गया है (उस पर बाद में)

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

डैगर को यह बताने के लिए कि कौन सा ग्राहक बनाने के लिए, आपको "मॉड्यूल" बनाने की आवश्यकता है - एनोटेट @Module वर्ग:

 @Module public class NetworkModule{...} 

यह वर्ग अनुप्रयोग द्वारा अनुरोध की गई निर्भरता के "संतोषजनक" भाग के लिए जिम्मेदार है। इस वर्ग में, आपको तथाकथित "प्रदाता" बनाने की आवश्यकता है - एक विधि जो एक HttpClient उदाहरण (एनोटेट @Provide ) @Provide :

 @Module(injects=TwitterApi.class) public class NetworkModule { @Provides @Singleton HttpClient provideHttpClient() { return new OkHttpClient(); } } 

हमने डैगर को बताया कि उन्होंने @ @Inject एनोटेशन के माध्यम से HttpClient के लिए पूछने वाले के लिए OkHttpClient बनाया

यह ध्यान देने योग्य है कि काम करने के लिए संकलन-समय सत्यापन के लिए, आपको उन सभी वर्गों (इंजेक्शन पैरामीटर में) को निर्दिष्ट करना होगा जो इस निर्भरता के लिए पूछते हैं। हमारे मामले में, HttpClient केवल TwitterApi वर्ग द्वारा आवश्यक है।
@Singleton डैगर को केवल 1 ग्राहक उदाहरण बनाने और इसे कैश करने के लिए कहता है।

रचना की गिनती

अब ग्राफ बनाने के लिए आगे बढ़ते हैं। ऐसा करने के लिए, मैंने Injector क्लास बनाया, जो एक (या अधिक) मॉड्यूल के साथ ग्राफ को इनिशियलाइज़ करता है। एंड्रॉइड एप्लिकेशन के संदर्भ में, एप्लिकेशन बनाते समय ऐसा करना सबसे अधिक सुविधाजनक है (हम एप्लिकेशन से विरासत में प्राप्त करते हैं और onCreate() ओवरलोड onCreate() )। इस उदाहरण में, मैंने एक TweeterApp क्लास बनाई जिसमें बाकी घटक हैं (ट्वीटर और टाइमलाइन)

 public class Injector { public static ObjectGraph graph; public static void init(Object... modules) { graph = ObjectGraph.create(modules); } public static void inject(Object target) { graph.inject(target); } } public class TweeterApp { public static void main(String... args) { Injector.init(new NetworkModule()); Tweeter tweeter = new Tweeter(); tweeter.tweet("Hello world"); Timeline timeline = new Timeline("Test User"); timeline.loadMore(20); for(Tweet tweet: timeline.get()) { System.out.println(tweet); } } } 

अब निर्भरता क्वेरी पर वापस:

 public class TwitterApi { @Inject private HttpClient client; public TwitterApi() { //     Injector.inject(this); //   ""  client  Dagger' } public void postTweet(String user, String tweet) { HttpUrlConnection connection = client.open("...."); /* post tweet */ } } 

सूचना Injector.inject(Object) । यह निर्भरता ग्राफ में वर्ग को जोड़ने के लिए आवश्यक है। यानी अगर हमारे पास कक्षा में कम से कम एक @Inject है, तो हमें इस वर्ग को ग्राफ में जोड़ना होगा। नतीजतन, हमारे ग्राफ में सभी कक्षाएं होनी चाहिए जो निर्भरताएं पूछती हैं (इनमें से प्रत्येक वर्ग को ObjectGraph.inject() ) + मॉड्यूल बनाना चाहिए जो इन निर्भरताओं को पूरा करते हैं (आमतौर पर ग्राफ के प्रारंभिक चरण में जोड़ा जाता है)।

अब अपने मूल कार्य पर वापस - सब कुछ परीक्षण करने के लिए। हमें किसी तरह हेटस्टैक को बदलने में सक्षम होना चाहिए। NetworkModule मॉड्यूल इस निर्भरता को संतुष्ट करने के लिए ज़िम्मेदार है (हम्म - मैंने अभी देखा कि यह कितना दिलचस्प लगता है):

 @Provides @Singleton HttpClient provideHttpClient() { return new OkHttpClient(); } 

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

 @Provides @Singleton HttpClient provideHttpClient() { if(Config.isDebugMode()) { return new MockHttpClient(); } return new OkHttpClient(); } 

लेकिन एक विकल्प और भी अधिक सुरुचिपूर्ण है। डैगर में, आप ऐसे मॉड्यूल बना सकते हैं जो निर्भरता प्रदान करने वाले कार्यों को ओवरराइड करते हैं। ऐसा करने के लिए, मॉड्यूल में overrides=true जोड़ें:

 @Module(overrides=true, injects=TwitterApi.class) public class MockNetworkModule { @Provides @Singleton HttpClient provideHttpClient() { return new MockHttpClient(); } } 

अब तक जो भी करना है वह इस मॉड्यूल को इनिशियलाइज़ेशन स्टेज पर ग्राफ में जोड़ना है:

 public class TweeterApp { public static void main(String... args) { Injector.init(new NetworkModule(), new MockNetworkModule()); Tweeter tweeter = new Tweeter(); tweeter.tweet("Hello world"); Timeline timeline = new Timeline("Test User"); timeline.loadMore(20); for(Tweet tweet: timeline.get()) { System.out.println(tweet); } } } 

अब हमारे सभी अनुरोध टेस्ट Http क्लाइंट के माध्यम से जाएंगे।

यह Dagger'a की सभी विशेषताएं नहीं हैं - मैंने इस पुस्तकालय का उपयोग करने के लिए संभावित परिदृश्यों में से केवल एक का वर्णन किया है। किसी भी मामले में, प्रलेखन का एक विचारशील पढ़ना अपरिहार्य है।

विषय पर उपयोगी सामग्री की सूची:

• निर्भरता इंजेक्शन का सामान्य विवरण
• परियोजना की आधिकारिक साइट
• लाइब्रेरी डेवलपर्स के साथ Google हैंगआउट वीडियो
• GitHub पर एक पुस्तकालय का उपयोग करने का मेरा छोटा उदाहरण
• Devoxx सम्मेलन में जेक व्हार्टन की प्रस्तुति से स्लाइड (उन्होंने बाद में वीडियो पोस्ट करने का वादा किया)