( चित्रण )

प्रत्येक टीम जल्द या बाद में अपने स्वयं के वास्तुशिल्प दृष्टिकोण को पेश करने के बारे में सोचना शुरू कर देती है, और इसके बारे में बहुत सारी प्रतियां टूट गईं। अम्ब्रेला आईटी में हम हमेशा लचीले उपकरणों के साथ काम करना चाहते थे, ताकि वास्तुकला का निर्माण कुछ दर्दनाक न हो, और नेविगेशन, मॉक-फाइल्स, आइसोलेशन और परीक्षण की समस्याएं कुछ डरावनी हों, कुछ ऐसा जो जल्द या बाद में हो। एक अतिवृद्धि परियोजना पर लटका। सौभाग्य से, हम एक नए "अनन्य" वास्तुकला के बारे में बात नहीं कर रहे हैं जिसमें एक संक्षिप्त नाम है। मुझे यह स्वीकार करना चाहिए कि वर्तमान में लोकप्रिय आर्किटेक्चर (MVP, MVVM, VIPER, क्लीन-स्विफ्ट) अपने कार्यों से मुकाबला कर रहे हैं, और केवल गलत विकल्प और इस या उस दृष्टिकोण के गलत उपयोग से मुश्किलें पैदा हो सकती हैं। हालांकि, अपनाया वास्तुकला के ढांचे के भीतर, विभिन्न पैटर्नों का उपयोग किया जा सकता है, जो उन बहुत ही पौराणिक संकेतकों को प्राप्त करने की अनुमति देगा: लचीलापन, अलगाव, परीक्षणशीलता, पुन: उपयोग।

बेशक, आवेदन अलग हैं। यदि किसी प्रोजेक्ट में केवल कुछ स्क्रीन हैं जो श्रृंखला में जुड़े हुए हैं, तो मॉड्यूल के बीच जटिल इंटरैक्शन की कोई विशेष आवश्यकता नहीं है। यह सामान्य सेग-कनेक्शन के साथ करना संभव है, यह अच्छे पुराने एमवीसी / एमवीपी के साथ सभी सीजन करता है। और हालांकि वास्तुशिल्प स्नोबेरी जल्द या बाद में हर डेवलपर को हरा देता है, फिर भी कार्यान्वयन परियोजना के लक्ष्यों और जटिलता के अनुरूप होना चाहिए। और इसलिए, यदि परियोजना में एक जटिल स्क्रीन संरचना और विभिन्न राज्य (प्राधिकरण, अतिथि मोड, ऑफ़लाइन, उपयोगकर्ताओं के लिए भूमिका आदि) शामिल हैं, तो वास्तुकला के लिए एक सरलीकृत दृष्टिकोण निश्चित रूप से एक चाल चलेगा: बहुत सारी निर्भरता, एक अस्पष्ट और महंगा डेटा स्क्रीन और राज्य, नेविगेशन के साथ समस्याएं और सबसे महत्वपूर्ण बात - यह सब किसी भी लचीलेपन और पुन: प्रयोज्य नहीं होगा, समाधान परियोजना में कसकर पिघल जाएंगे और स्क्रीन ए हमेशा स्क्रीन खोलेगी। बी बदलाव करने के प्रयास दर्दनाक रिफ्लेक्टर का कारण बनेंगे। नगमा जिसके दौरान गलतियाँ करना और काम करने के लिए इस्तेमाल की गई चीजों को तोड़ना इतना आसान है। नीचे दिए गए उदाहरण में, हम एक एप्लिकेशन को व्यवस्थित करने के एक लचीले तरीके का वर्णन करेंगे जिसमें दो राज्य हैं: उपयोगकर्ता अधिकृत नहीं है और इसे प्राधिकरण स्क्रीन पर निर्देशित किया जाना चाहिए, उपयोगकर्ता अधिकृत है और एक निश्चित मुख्य स्क्रीन खोला जाना चाहिए।

1. मुख्य प्रोटोकॉल का कार्यान्वयन

पहले हमें आधार को लागू करने की आवश्यकता है। यह सब समन्वयक, प्रस्तुत करने योग्य, नियमित प्रोटोकॉल के साथ शुरू होता है:

protocol Coordinatable: class { func start() } protocol Presentable { var toPresent: UIViewController? { get } } extension UIViewController: Presentable { var toPresent: UIViewController? { return self } func showAlert(title: String, message: String? = nil) { UIAlertController.showAlert(title: title, message: message, inViewController: self, actionBlock: nil) } } 

इस उदाहरण में, showAlert एक अधिसूचना को कॉल करने के लिए सिर्फ एक सुविधाजनक तरीका है, जो कि UIViewController एक्सटेंशन में है।

 protocol Routable: Presentable { func present(_ module: Presentable?) func present(_ module: Presentable?, animated: Bool) func push(_ module: Presentable?) func push(_ module: Presentable?, animated: Bool) func push(_ module: Presentable?, animated: Bool, completion: CompletionBlock?) func popModule() func popModule(animated: Bool) func dismissModule() func dismissModule(animated: Bool, completion: CompletionBlock?) func setRootModule(_ module: Presentable?) func setRootModule(_ module: Presentable?, hideBar: Bool) func popToRootModule(animated: Bool) } 

2. एक समन्वयक बनाएँ

समय-समय पर, एप्लिकेशन स्क्रीन को बदलने की आवश्यकता होती है, जिसका अर्थ है कि डाउनडाउन के बिना परीक्षण परत को लागू करना आवश्यक होगा, साथ ही साथ SOLID सिद्धांतों का उल्लंघन किए बिना।

हम समन्वय परत के कार्यान्वयन के लिए आगे बढ़ते हैं:



आवेदन शुरू करने के बाद, AppCoordinator पद्धति को बुलाया जाना चाहिए, जो निर्धारित करता है कि किस प्रवाह को शुरू किया जाना चाहिए। उदाहरण के लिए, यदि उपयोगकर्ता पंजीकृत है, तो आपको प्रवाह एप्लिकेशन चलाना चाहिए, और यदि नहीं, तो प्राधिकरण प्रवाहित करें। इस मामले में, MainCoordinator और AuthorizationCoordinator की आवश्यकता होती है। हम प्राधिकरण के लिए समन्वयक का वर्णन करेंगे, अन्य सभी स्क्रीन एक समान तरीके से बनाई जा सकती हैं।

पहले आपको समन्वयक को आउटपुट जोड़ने की आवश्यकता है ताकि वह एक उच्च समन्वयक (AppCoordinator) के साथ एक कनेक्शन रख सके:

 protocol AuthorizationCoordinatorOutput: class { var finishFlow: CompletionBlock? { get set } } final class AuthorizationCoordinator: BaseCoordinator, AuthorizationCoordinatorOutput { var finishFlow: CompletionBlock? fileprivate let factory: AuthorizationFactoryProtocol fileprivate let router : Routable init(router: Routable, factory: AuthorizationFactoryProtocol) { self.router = router self.factory = factory } } // MARK:- Coordinatable extension AuthorizationCoordinator: Coordinatable { func start() { performFlow() } } // MARK:- Private methods private extension AuthorizationCoordinator { func performFlow() { //:- Will implement later } } 

जैसा कि ऊपर दिखाया गया है, हमारे पास एक राउटर और एक मॉड्यूल कारखाने के साथ एक प्राधिकरण समन्वयक है। लेकिन कौन और कब प्रारंभ () विधि कहता है?
यहां हमें AppCoordinator को लागू करने की आवश्यकता है।

 final class AppCoordinator: BaseCoordinator { fileprivate let factory: CoordinatorFactoryProtocol fileprivate let router : Routable fileprivate let gateway = Gateway() init(router: Routable, factory: CoordinatorFactory) { self.router = router self.factory = factory } } // MARK:- Coordinatable extension AppCoordinator: Coordinatable { func start() { self.gateway.getState { [unowned self] (state) in switch state { case .authorization: self.performAuthorizationFlow() case .main: self.performMainFlow() } } } } // MARK:- Private methods func performAuthorizationFlow() { let coordinator = factory.makeAuthorizationCoordinator(with: router) coordinator.finishFlow = { [weak self, weak coordinator] in guard let `self` = self, let `coordinator` = coordinator else { return } self.removeDependency(coordinator) self.start() } addDependency(coordinator) coordinator.start() } func performMainFlow() { // MARK:- main flow logic } 

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

 final class CoordinatorFactory { fileprivate let modulesFactory = ModulesFactory() } extension CoordinatorFactory: CoordinatorFactoryProtocol { func makeAuthorizationCoordinator(with router: Routable) -> Coordinatable & AuthorizationCoordinatorOutput { return AuthorizationCoordinator(router: router, factory: modulesFactory) } } 

3. कारखाने के समन्वयकों का कार्यान्वयन

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

 class BaseCoordinator { var childCoordinators: [Coordinatable] = [] // Add only unique object func addDependency(_ coordinator: Coordinatable) { for element in childCoordinators { if element === coordinator { return } } childCoordinators.append(coordinator) } func removeDependency(_ coordinator: Coordinatable?) { guard childCoordinators.isEmpty == false, let coordinator = coordinator else { return } for (index, element) in childCoordinators.enumerated() { if element === coordinator { childCoordinators.remove(at: index) break } } } } 

बेसकॉर्डिनेटर - एक वर्ग जिसमें बाल समन्वयक की एक सरणी होती है और दो विधियाँ होती हैं: समन्वयक निर्भरता को हटाएं और जोड़ें।

4. AppDelegate कॉन्फ़िगर करना

अब देखते हैं कि UIApplicationMain कैसा दिखता है:

 @UIApplicationMain class AppDelegate: UIResponder, UIApplicationDelegate { var window: UIWindow? var rootController: UINavigationController { window?.rootViewController = UINavigationController() window?.rootViewController?.view.backgroundColor = .white return window?.rootViewController as! UINavigationController } fileprivate lazy var coordinator: Coordinatable = self.makeCoordinator() func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool { coordinator.start() return true } } // MARK:- Private methods private extension AppDelegate { func makeCoordinator() -> Coordinatable { return AppCoordinator(router: Router(rootController: rootController), factory: CoordinatorFactory()) } } 

जैसे ही प्रतिनिधि विधि didFinishLaunchingWithOptions कहा जाता है, AppCoordinator की शुरुआत () विधि को कहा जाता है, जो आवेदन के आगे के तर्क को निर्धारित करेगा।

5. एक स्क्रीन मॉड्यूल बनाना

आगे क्या होता है, इसे प्रदर्शित करने के लिए, हम वापस प्राधिकरण प्राधिकरण में जाते हैं और PerformFlow () विधि को लागू करते हैं।

सबसे पहले, हमें ModulesFactory वर्ग में AuthorFFactoryProtocol इंटरफ़ेस लागू करने की आवश्यकता है:

 final class ModulesFactory {} // MARK:- AuthorizationFactoryProtocol extension ModulesFactory: AuthorizationFactoryProtocol { func makeEnterView() -> EnterViewProtocol { let view: EnterViewController = EnterViewController.controllerFromStoryboard(.authorization) EnterAssembly.assembly(with: view) return view 

एक मॉड्यूल कारखाने में किसी भी विधि को बुलाकर, एक नियम के रूप में, हमारा मतलब है कि स्टोरीबोर्ड से व्यूकंट्रोलर को इनिशियलाइज़ करना और फिर इस मॉड्यूल के सभी आवश्यक घटकों को एक विशिष्ट आर्किटेक्चर (MVP, MVVM, CleanSwift) के साथ जोड़ना।

आवश्यक तैयारी के बाद, हम ऑथराइजेशन कोऑर्डिनेटर के परफॉर्मो () विधि को लागू कर सकते हैं।
इस समन्वयक के भीतर प्रारंभ स्क्रीन EnterView है।
PerformFlow () विधि में, मॉड्यूल फैक्ट्री का उपयोग करके, दिए गए समन्वयक के लिए एक तैयार किए गए मॉड्यूल का निर्माण कहा जाता है, फिर एक बार या किसी अन्य पर हमारे व्यू कंट्रोलर को कॉल करने की प्रक्रिया के तर्क को लागू किया जाता है, फिर इस मॉड्यूल को राउटर द्वारा स्क्रीन के नेविगेशन स्टैक में रूट के रूप में सेट किया जाता है:

 private extension AuthorizationCoordinator { func performFlow() { let enterView = factory.makeEnterView() finishFlow = enterView.onCompleteAuthorization enterView.output?.onAlert = { [unowned self] (message: String) in self.router.toPresent?.showAlert(message: message) } router.setRootModule(enterView) } } 

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

जीथब से लिंक करें , जिसमें क्लीन आर्किटेक्चर पर आधारित डेमो और आवश्यक आर्किटेक्चरल लेयर बनाने के लिए सुविधाजनक Xcode टेम्प्लेट हो।