DITranquillity के साथ निर्भरता इंजेक्शन

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

यह ट्यूटोरियल निम्नलिखित पुस्तकालय सुविधाओं को कवर करेगा:

• पंजीकरण टाइप करें
• प्रारंभिक तैनाती
• एक चर में एम्बेड करना
• घटक चक्रीय निर्भरता
• UIStoryboard साथ पुस्तकालय का उपयोग करना

घटक विवरण

अनुप्रयोग में मुख्य घटक शामिल होंगे: ViewController , Router , Presenter , Networking - ये किसी भी iOS अनुप्रयोग में बहुत सामान्य घटक हैं।

ViewController और Router एक-दूसरे को चक्रीय रूप से पेश किया जाएगा।

ट्रेनिंग

सबसे पहले, Xcode में एक सिंगल व्यू एप्लिकेशन बनाएं, कोकोआपोड्स का उपयोग करके DITranquillity जोड़ें। फ़ाइलों की आवश्यक पदानुक्रम बनाएं, फिर Main.storyboard में एक दूसरा नियंत्रक जोड़ें और StoryboardSegue का उपयोग करके इसे कनेक्ट करें। परिणामस्वरूप, निम्न फ़ाइल संरचना प्राप्त की जानी चाहिए:

निम्नानुसार कक्षाओं में निर्भरता बनाएं:

 protocol Presenter: class { func getCounter(completion: @escaping (Int) -> Void) } class MyPresenter: Presenter { private let networking: Networking init(networking: Networking) { self.networking = networking } func getCounter(completion: @escaping (Int) -> Void) { // Implementation } } 

 protocol Networking: class { func fetchData(completion: @escaping (Result<Int, Error>) -> Void) } class MyNetworking: Networking { func fetchData(completion: @escaping (Result<Int, Error>) -> Void) { // Implementation } } 

 protocol Router: class { func presentNewController() } class MyRouter: Router { unowned let viewController: ViewController init(viewController: ViewController) { self.viewController = viewController } func presentNewController() { // Implementation } } 

 class ViewController: UIViewController { var presenter: Presenter! var router: Router! } 

प्रतिबंध

अन्य वर्गों के विपरीत, ViewController हमारे द्वारा नहीं बनाया गया है, लेकिन UIStoryboard.instantiateViewController कार्यान्वयन के अंदर UIKit पुस्तकालय द्वारा, इसलिए, स्टोरीबोर्ड का उपयोग करते हुए, हम UIStoryboard.instantiateViewController का उपयोग करके UIViewController के वारिसों पर निर्भरता को इंजेक्ट नहीं कर सकते हैं। तो यह UIView और UITableViewCell के वारिसों के साथ है।

ध्यान दें कि प्रोटोकॉल के पीछे छिपी हुई वस्तुओं को सभी वर्गों में एम्बेड किया गया है। यह निर्भरता को लागू करने के मुख्य कार्यों में से एक है - कार्यान्वयन पर निर्भरता बनाने के लिए नहीं, बल्कि इंटरफेस पर। यह भविष्य में पुन: उपयोग या परीक्षण घटकों के लिए अलग-अलग प्रोटोकॉल कार्यान्वयन प्रदान करने में मदद करेगा।

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

सिस्टम के सभी घटक बनने के बाद, हम वस्तुओं को आपस में जोड़ते हैं। DITranquillity में, प्रारंभिक बिंदु DIContainer , जो container.register(...) . DIContainer container.register(...) पद्धति का उपयोग करके पंजीकरण जोड़ता है। निर्भरता को भागों में अलग करने के लिए, DIFramework और DIPart , जिसे लागू किया जाना चाहिए। सुविधा के लिए, हम केवल एक ApplicationDependency निर्भरता वर्ग बनाएंगे, जो DIFramework को लागू DIFramework और सभी निर्भरताओं के लिए एक पंजीकरण स्थान के रूप में काम करेगा। DIFramework इंटरफ़ेस आपको केवल एक विधि - load(container:) लागू करने की आवश्यकता है।

 class ApplicationDependency: DIFramework { static func load(container: DIContainer) { // registrations will be placed here } } 

आइए सबसे सरल साइनअप से शुरू करें जिसकी कोई निर्भरता नहीं है - MyNetworking

 container.register(MyNetworking.init) 

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

इसी तरह, MyPresenter और MyRouter रजिस्टर करें।

 container.register1(MyPresenter.init) container.register1(MyRouter.init) 

नोट: ध्यान दें कि यह register नहीं है जिसका उपयोग किया गया है, लेकिन register1 । दुर्भाग्य से, यह इंगित करना आवश्यक है कि क्या ऑब्जेक्ट में एक और केवल एक निर्भरता है इनिशियलाइज़र में। यही है, अगर 0 या दो या अधिक निर्भरताएं हैं, तो आपको बस register का उपयोग करने की आवश्यकता है। यह प्रतिबंध स्विफ्ट संस्करण 4.0 और उच्चतर का एक बग है।

यह हमारे ViewController पंजीकरण का समय है। यह ऑब्जेक्ट्स को इनिशियलाइज़र के माध्यम से नहीं, बल्कि सीधे वेरिएबल में इंजेक्ट करता है, इसलिए पंजीकरण विवरण थोड़ा और बदल जाएगा।

 container.register(ViewController.self) .injection(cycle: true, \.router) .injection(\.presenter) 

प्रपत्र \.presenter का सिंटैक्स SwiftKeyPath है, जिसके लिए यह निर्भरता को संक्षिप्त रूप से लागू करना संभव है। चूंकि Router और ViewController एक-दूसरे पर चक्रीय रूप से निर्भर ViewController , इसलिए आपको स्पष्ट रूप से इस cycle: true का उपयोग करके संकेत करना चाहिए cycle: true । पुस्तकालय स्वयं एक स्पष्ट संकेत के बिना इन निर्भरताओं को हल कर सकते हैं, लेकिन यह आवश्यकता इसलिए शुरू की गई थी ताकि ग्राफ़ पढ़ने वाले व्यक्ति को तुरंत समझ में आ जाए कि निर्भरता श्रृंखला में चक्र हैं। यह भी ध्यान दें कि ViewController.init नहीं ViewController.init , लेकिन ViewController.self । यह सीमा अनुभाग में ऊपर वर्णित किया गया था।

विशेष विधि का उपयोग करके UIStoryboard को पंजीकृत करना भी आवश्यक है।

 container.registerStoryboard(name: "Main") 

अब हमने एक स्क्रीन के लिए संपूर्ण निर्भरता ग्राफ का वर्णन किया है। लेकिन इस ग्राफ की अभी तक कोई पहुंच नहीं है। आपको एक DIContainer बनाना होगा जो आपको इसमें ऑब्जेक्ट्स एक्सेस करने की अनुमति देता है।

 static let container: DIContainer = { let container = DIContainer() // 1 container.append(framework: ApplicationDependency.self) // 2 assert(container.validate(checkGraphCycles: true)) // 3 return container }() 

1. कंटेनर को प्रारंभ करें
2. इसमें ग्राफ का विवरण जोड़ें।
3. हम जांचते हैं कि हमने सब कुछ सही किया। यदि कोई गलती की जाती है, तो आवेदन निर्भरता को हल करने के दौरान नहीं, बल्कि ग्राफ़ बनाते समय तुरंत क्रैश हो जाएगा

फिर आपको कंटेनर को एप्लिकेशन का प्रारंभिक बिंदु बनाने की आवश्यकता है। ऐसा करने के लिए, AppDelegate प्रोजेक्ट सेटिंग्स में लॉन्च बिंदु के रूप में Main.storyboard को निर्दिष्ट करने के बजाय didFinishLaunchingWithOptions में didFinishLaunchingWithOptions विधि को लागू करते हैं।

 func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool { window = UIWindow(frame: UIScreen.main.bounds) let storyboard: UIStoryboard = ApplicationDependency.container.resolve() window?.rootViewController = storyboard.instantiateInitialViewController() window?.makeKeyAndVisible() return true } 

लांच

पहली शुरुआत में, एक गिरावट आएगी और सत्यापन निम्नलिखित कारणों से विफल हो जाएगा:

• कंटेनर को Router , Presenter , Networking के प्रकार नहीं मिलेंगे, क्योंकि हमने केवल ऑब्जेक्ट पंजीकृत किए हैं। यदि हम कार्यान्वयन को नहीं, बल्कि इंटरफेस को एक्सेस देना चाहते हैं, तो हमें स्पष्ट रूप से इंटरफेस को निर्दिष्ट करना होगा
• कंटेनर को समझ में नहीं आता है कि चक्रीय निर्भरता को कैसे हल किया जाए, क्योंकि यह स्पष्ट रूप से इंगित करने के लिए आवश्यक है कि हर बार ग्राफ़ के हल होने पर किन वस्तुओं को फिर से नहीं बनाया जाना चाहिए।

पहली त्रुटि को ठीक करना आसान है - एक विशेष विधि है जो आपको यह निर्दिष्ट करने की अनुमति देती है कि किस प्रोटोकॉल के तहत कंटेनर में विधि उपलब्ध है।

 container.register(MyNetworking.init) .as(check: Networking.self) {$0} 

पंजीकरण को निम्नानुसार बताते हुए, हम कहते हैं: Networking प्रोटोकॉल के माध्यम से MyNetworking ऑब्जेक्ट सुलभ है। यह प्रोटोकॉल के तहत छिपी सभी वस्तुओं के लिए किया जाना चाहिए। {$0} कंपाइलर द्वारा प्रकारों की सही जांच के लिए जोड़ते हैं।

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

 container.register(ViewController.self) .injection(cycle: true, \.router) .injection(\.presenter) .lifetime(.objectGraph) container.register1(MyRouter.init) .as(check: Router.self) {$0} .lifetime(.objectGraph) 

पुनरारंभ करने के बाद, कंटेनर सफलतापूर्वक सत्यापन पास करता है और हमारा ViewController निर्मित निर्भरता के साथ खुलता है। आप viewDidLoad में एक विराम बिंदु डाल सकते हैं और सुनिश्चित कर सकते हैं।

स्क्रीन के बीच संक्रमण

इसके बाद, दो छोटे वर्ग बनाएं, SecondViewController और SecondPresenter , स्टोरीबोर्ड में SecondViewController जोड़ें और उनके बीच एक "RouteToSecond" , जिसमें पहचानकर्ता "RouteToSecond" , जो आपको पहले से दूसरा नियंत्रक खोलने की अनुमति देता है।

नई कक्षाओं में से प्रत्येक के लिए हमारी ApplicationDependency निर्भरता में दो और पंजीकरण जोड़ें:

 container.register(SecondViewController.self) .injection(\.secondPresenter) container.register(SecondPresenter.init) 

हमें .as निर्दिष्ट करने की कोई आवश्यकता नहीं है, क्योंकि हमने प्रोटोकॉल के पीछे SecondPresenter को छिपाया नहीं था, लेकिन सीधे कार्यान्वयन का उपयोग करें। फिर, पहले नियंत्रक के viewDidAppear विधि में, हम performSegue(withIdentifier: "RouteToSecond", sender: self) , कॉल करते हैं, प्रारंभ करते हैं, दूसरा नियंत्रक खुलता है, जिसमें दूसरे performSegue(withIdentifier: "RouteToSecond", sender: self) को चिपका दिया जाना चाहिए। जैसा कि आप देख सकते हैं, कंटेनर ने UIStoryboard से एक दूसरे नियंत्रक का निर्माण देखा और सफलतापूर्वक निर्भरता को कम कर दिया।

निष्कर्ष

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

संदर्भ

गिटहब लाइब्रेरी में पूर्ण नमूना कोड

गीथुब पर निपुणता

अंग्रेजी लेख