इस लेख में मेरा लक्ष्य यह समझाना है कि Model-View-ViewModel आर्किटेक्चरल पैटर्न GUI आर्किटेक्चर के प्रेजेंटेशन लॉजिक के संबंध में कुछ स्थितियों में चिंताओं का एक बहुत ही अजीब पृथक्करण प्रस्तुत करता है।
हम MVVM के दो वेरिएंट का पता लगाएंगे (इसे करने का सिर्फ एक तरीका नहीं है), और उन कारणों को जिनके आधार पर आप प्रोजेक्ट आवश्यकताओं के आधार पर एक वेरिएंट को दूसरे पर प्राथमिकता दे सकते हैं।
MVVM बनाम MVP/MVC?
यह काफी संभावना है कि मेरे लाइव संडे Q&A सत्र के दौरान मुझसे पूछा जाने वाला सबसे आम प्रश्न, कुछ इस तरह है:
MVVM बनाम MVP/MVC?
जब भी मुझसे यह प्रश्न पूछा जाता है, तो मैं इस विचार पर जोर देने के लिए तत्पर हूं कि कोई एकल GUI आर्किटेक्चर सभी स्थितियों में बढ़िया काम नहीं करता।
आप पूछ सकते हैं क्यों? किसी दिए गए एप्लिकेशन के लिए सर्वोत्तम आर्किटेक्चर (या कम से कम एक अच्छा विकल्प) हाथ में आवश्यकताओं पर दृढ़ता से निर्भर करता है।
आइए संक्षेप में सोचें कि यह शब्द आवश्यकताएं वास्तव में क्या अर्थ रखता है:
- आपका UI कितना जटिल है? एक साधारण UI को आमतौर पर इसे समन्वयित करने के लिए जटिल तर्क की आवश्यकता नहीं होती है, जबकि एक जटिल UI को सुचारू रूप से काम करने के लिए व्यापक तर्क और बारीक नियंत्रण की आवश्यकता हो सकती है।
- आप टेस्टिंग की कितनी परवाह करते हैं? आम तौर पर, जो क्लास फ्रेमवर्क और OS (विशेष रूप से यूजर इंटरफेस) से सख्ती से युग्मित हैं, उन्हें टेस्ट करने के लिए अतिरिक्त काम की आवश्यकता होती है।
- आप कितनी पुन: प्रयोज्यता और अमूर्तता को बढ़ावा देना चाहते हैं? क्या होगा यदि आप अपने एप्लिकेशन के बैक एंड, डोमेन, और यहां तक कि प्रेजेंटेशन लॉजिक को विभिन्न प्लेटफार्मों पर साझा करना चाहते हैं?
- क्या आप स्वभाव से व्यावहारिक, पूर्णतावादी, आलसी, या अलग-अलग समय पर, अलग-अलग स्थितियों में उपरोक्त सभी हैं?
मैं एक लेख लिखना पसंद करूंगा जहां मैं ऊपर सूचीबद्ध आवश्यकताओं और चिंताओं के संबंध में MVVM कैसे काम करता है, इस पर विस्तार से चर्चा करूं। दुर्भाग्य से, आप में से कुछ को यह सोचकर गुमराह किया गया होगा कि MVVM करने का केवल एक ही तरीका है।
इसके बजाय, मैं MVVM के सामान्य विचार के दो अलग-अलग दृष्टिकोणों पर चर्चा करूंगा जो बहुत अलग लाभ और नुकसान पेश करते हैं। लेकिन पहले, आइए सामान्य विचार से शुरू करें।
तुम अपने View क्लास का संदर्भ नहीं दोगे
मेरे उन दोस्तों के लिए जो पुरानी अंग्रेजी नहीं पढ़ सकते: “आप View क्लास का संदर्भ नहीं दे सकते."
ViewModel नाम का उपयोग करने के अलावा (जो अपने आप में भ्रमित करने वाला है अगर क्लास लॉजिक से भरी हुई है), MVVM आर्किटेक्चर का एक अटल नियम यह है कि आप कभी भी ViewModel से View का संदर्भ नहीं दे सकते।
अब, भ्रम का पहला क्षेत्र इस शब्द "संदर्भ" से उत्पन्न हो सकता है, जिसे मैं कई अलग-अलग स्तरों के शब्दजाल का उपयोग करके पुनः बताऊंगा:
- आपके ViewModels के पास किसी भी View के संदर्भ (मेंबर वेरिएबल, प्रॉपर्टी, म्यूटेबल/इम्यूटेबल फील्ड) नहीं हो सकते
- आपके ViewModels किसी भी View पर निर्भर नहीं हो सकते
- आपके ViewModels सीधे आपके Views से बात नहीं कर सकते
अब, Android प्लेटफॉर्म पर, इस नियम का कारण केवल यह नहीं है कि इसे तोड़ना बुरा है क्योंकि कोई जिसे सॉफ़्टवेयर आर्किटेक्चर के बारे में पता लगता है उसने आपको बताया कि यह बुरा है।
Architecture Components से ViewModel क्लास का उपयोग करते समय (जिसे अपने इंस्टेंस को Fragment/Activity जीवनचक्र से अधिक समय तक बनाए रखने के लिए डिज़ाइन किया गया है जब उपयुक्त हो), View का संदर्भ देना गंभीर मेमोरी लीक को आमंत्रित कर रहा है।
जहां तक सामान्य रूप से MVVM ऐसे संदर्भों की अनुमति नहीं देता है, लक्ष्य काल्पनिक रूप से View और ViewModel दोनों को टेस्ट करना और लिखना आसान बनाना है।
अन्य यह भी बता सकते हैं कि यह ViewModels की पुन: प्रयोज्यता को बढ़ावा देता है, लेकिन यह ठीक वही जगह है जहां इस पैटर्न के साथ चीजें टूट जाती हैं।
कोड देखने से पहले, कृपया ध्यान दें कि मैं व्यक्तिगत रूप से अपने प्रोडक्शन कोड में LiveData का उपयोग नहीं करता। मैं इन दिनों अपना खुद का Publisher-Subscriber Pattern लिखना पसंद करता हूं, लेकिन जो मैं नीचे कहता हूं वह किसी भी लाइब्रेरी पर लागू होता है जो ViewModel से View तक PubSub/Observer Pattern लिंक की अनुमति देता है।
यह लेख एक वीडियो ट्यूटोरियल के साथ है जो यहां कई समान विचारों को कवर करता है:
ViewLogic + ViewModel या View + ViewModelController?
जब मैंने पिछले अनुभाग में "टूटना" कहा, तो मेरा मतलब यह नहीं है कि पैटर्न शाब्दिक रूप से टूट जाता है। मेरा मतलब है कि यह (कम से कम) दो अलग-अलग दृष्टिकोणों में टूट जाता है जिनकी बहुत अलग दिखावट, लाभ और परिणाम हैं।
आइए इन दो दृष्टिकोणों पर विचार करें, और आप कब एक को दूसरे पर प्राथमिकता देना चाह सकते हैं।

पहला दृष्टिकोण: पुन: प्रयोज्य ViewModels को प्राथमिकता दें
जहां तक मैं बता सकता हूं, MVVM को लागू करने वाले अधिकांश लोग ViewModels की पुन: प्रयोज्यता को बढ़ावा देना एक लक्ष्य बनाते हैं, ताकि उन्हें n संख्या में विभिन्न Views (कई-से-एक अनुपात) के लिए पुन: उपयोग किया जा सके।
सरल शब्दों में, इस पुन: प्रयोज्यता को प्राप्त करने के दो तरीके हैं:
- किसी विशिष्ट View का संदर्भ न देकर। उम्मीद है कि इस बिंदु पर यह आपके लिए खबर नहीं है।
- UI के विवरण के बारे में जानकर जितना संभव हो उतना कम
दूसरा बिंदु अस्पष्ट या प्रतिकूल लग सकता है (यह किसी ऐसी चीज़ के बारे में कैसे जान सकता है जिसका यह संदर्भ नहीं देता?), इसलिए मुझे लगता है कि कुछ कोड देखने का समय आ गया है:
class NoteViewModel(val repo: NoteRepo): ViewModel(){ //नोट: आप Databinding, RxJava Observables, और अन्य दृष्टिकोण के माध्यम से View को डेटा भी प्रकाशित कर सकते हैं। हालांकि मुझे बैक एंड क्लास में LiveData का उपयोग करना पसंद नहीं है, यह AAC के साथ Android फ्रंट एंड के साथ बढ़िया काम करता है val noteState: MutableLiveData<Note>() //... fun handleEvent(event: NoteEvent) { when (event) { is NoteEvent.OnStart -> getNote(event.noteId) //... } } private fun getNote(noteId: String){ noteState.value = repo.getNote(noteId) } }यह एक बहुत सरल उदाहरण है, लेकिन बात यह है कि यह विशेष ViewModel केवल एक साधारण Note ऑब्जेक्ट को सार्वजनिक रूप से उजागर करता है (handleEvent फ़ंक्शन के अलावा):
data class Note(val creationDate:String, val contents:String, val imageUrl: String, val creator: User?)इस विशेष दृष्टिकोण के साथ, ViewModel न केवल एक विशेष View से, बल्कि किसी विशेष View के विवरण, और विस्तार से, प्रेजेंटेशन लॉजिक से भी अच्छी तरह और वास्तव में डिकॉपल है।
यदि मैं जो कह रहा हूं वह अभी भी अस्पष्ट लगता है, तो मैं वादा करता हूं कि यह स्पष्ट हो जाएगा जब मैं अन्य दृष्टिकोण का वर्णन करूंगा।
हालांकि मेरा पहले वाला शीर्षक, "ViewLogic + ViewModel…" गंभीरता से उपयोग या लिया जाने के लिए नहीं है, मेरा मतलब है कि बहुत डिकॉपल और पुन: प्रयोज्य ViewModels होने से, हम अब View पर ही यह काम करने के लिए निर्भर हैं कि इस Note ऑब्जेक्ट को स्क्रीन पर कैसे रेंडर/बाइंड किया जाए।
हम में से कुछ को View क्लास को लॉजिक से भरना पसंद नहीं है।
यहीं पर चीजें बहुत धुंधली और प्रोजेक्ट आवश्यकताओं पर निर्भर हो जाती हैं। मैं यह नहीं कह रहा हूं कि View क्लास को लॉजिक से भरना जैसे…:
private fun observeViewModel() { viewModel.notes.observe( viewLifecycleOwner, Observer { notes: List<Note> -> if (notes.isEmpty()) showEmptyState() else showNoteList(notes) } ) //.. }…हमेशा बुरी बात है, लेकिन जो क्लास प्लेटफॉर्म से सख्ती से युग्मित हैं (जैसे Fragments) टेस्ट करना मुश्किल है, और जिन क्लास में लॉजिक है वे टेस्ट करने के लिए सबसे महत्वपूर्ण क्लास हैं!
एक शब्द में, यह उस चीज को लागू करने में विफलता है जिसे मैं किसी भी अच्छे आर्किटेक्चर का स्वर्ण सिद्धांत मानता हूं: चिंताओं का पृथक्करण.
मेरी व्यक्तिगत राय है कि चिंताओं के पृथक्करण को बहुत उच्च स्तर पर लागू करना इसके लायक है। लेकिन इसमें कोई गलती न करें कि बहुत सारे कैश काउ एप्लिकेशन उन लोगों द्वारा लिखे गए हैं जिन्हें इस बात का धुंधला भी नहीं पता कि इसका क्या अर्थ है।
किसी भी मामले में, हम जिस दृष्टिकोण पर आगे चर्चा करेंगे, जबकि इसके अपने दुष्प्रभाव हैं, एक बार फिर View से प्रेजेंटेशन लॉजिक को हटा देता है।
खैर, ज्यादातर वैसे भी।
दूसरा दृष्टिकोण: विनम्र View, कंट्रोल-फ्रीक ViewModel
कभी-कभी अपने Views पर बारीक नियंत्रण न होना (जो ViewModels की पुन: प्रयोज्यता को प्राथमिकता देने का परिणाम है), वास्तव में बेकार होता है।
मुझे पिछले दृष्टिकोण को अंधाधुंध लागू करने के बारे में और भी कम उत्साही बनाने के लिए, मुझे लगता है कि मैं अक्सर नहीं ViewModel का पुन: उपयोग करने की आवश्यकता होती है।
विडंबना यह है कि MVP पर MVVM की एक आम आलोचना "बहुत अधिक अमूर्तता" है।
इसके साथ कहा गया है, कोई केवल ViewModel में संदर्भ को वापस जोड़कर View पर इस बारीक नियंत्रण को वापस नहीं पा सकता। यह मूल रूप से सिर्फ MVP + मेमोरी लीक होगा (यह मानते हुए कि आप अभी भी AAC से ViewModel का उपयोग कर रहे हैं)।
विकल्प तब, अपने ViewModels को इस तरह बनाना है कि उनमें किसी दिए गए View के लगभग सभी व्यवहार, स्थिति, और प्रेजेंटेशन लॉजिक हों। View को अभी भी ViewModel से बाइंड करना होगा, लेकिन View के बारे में पर्याप्त विवरण ViewModel में मौजूद हैं कि View के फ़ंक्शन वन-लाइनर (छोटे अपवादों के साथ) तक कम हो जाते हैं।
Martin Fowler के नामकरण सम्मेलनों में, इसे Passive View/Screen के रूप में जाना जाता है। इस दृष्टिकोण के लिए आम तौर पर लागू होने वाला नाम Humble Object Pattern है।
इसे प्राप्त करने के लिए, आपको अनिवार्य रूप से अपने ViewModel के पास View में मौजूद हर कंट्रोल या विजेट के लिए एक ऑब्जर्वेबल फील्ड (आप इसे कैसे प्राप्त करते हैं - डेटा बाइंडिंग, Rx, LiveData, जो भी हो) होना चाहिए:
class UserViewModel( val repo: IUserRepository, ){ //वास्तविक डेटा मॉडल को अवांछित छेड़छाड़ से बचाने के लिए निजी रखा गया है private val userState = MutableLiveData<User>() //कंट्रोल लॉजिक internal val authAttemptState = MutableLiveData<Unit>() internal val startAnimation = MutableLiveData<Unit>() //UI बाइंडिंग internal val signInStatusText = MutableLiveData<String>() internal val authButtonText = MutableLiveData<String>() internal val satelliteDrawable = MutableLiveData<String>() private fun showErrorState() { signInStatusText.value = LOGIN_ERROR authButtonText.value = SIGN_IN satelliteDrawable.value = ANTENNA_EMPTY } //... }बाद में, View को अभी भी खुद को ViewModel से जोड़ना होगा, लेकिन ऐसा करने के लिए आवश्यक फ़ंक्शन लिखना तुच्छ रूप से सरल हो जाता है:
class LoginView : Fragment() { private lateinit var viewModel: UserViewModel //... //ViewModel बनाएं और बाइंड करें override fun onStart() { super.onStart() viewModel = ViewModelProviders.of( //... ).get(UserViewModel::class.java) //बैकग्राउंड एनिम शुरू करें (root_fragment_login.background as AnimationDrawable).startWithFade() setUpClickListeners() observeViewModel() viewModel.handleEvent(LoginEvent.OnStart) } private fun setUpClickListeners() { //... } private fun observeViewModel() { viewModel.signInStatusText.observe( viewLifecycleOwner, Observer { //"it" MutableLiveData ऑब्जेक्ट का मान है, जिसे स्वचालित रूप से String माना जाता है lbl_login_status_display.text = it } ) viewModel.authButtonText.observe( viewLifecycleOwner, Observer { btn_auth_attempt.text = it } ) viewModel.startAnimation.observe( viewLifecycleOwner, Observer { imv_antenna_animation.setImageResource( resources.getIdentifier(ANTENNA_LOOP, "drawable", activity?.packageName) ) (imv_antenna_animation.drawable as AnimationDrawable).start() } ) viewModel.authAttemptState.observe( viewLifecycleOwner, Observer { startSignInFlow() } ) viewModel.satelliteDrawable.observe( viewLifecycleOwner, Observer { imv_antenna_animation.setImageResource( resources.getIdentifier(it, "drawable", activity?.packageName) ) } ) }आप इस उदाहरण के लिए पूरा कोड यहां पा सकते हैं।
जैसा कि आपने शायद देखा है, हम शायद इस ViewModel को कहीं और पुन: उपयोग नहीं करने जा रहे हैं। साथ ही, हमारा View पर्याप्त रूप से विनम्र हो गया है (आपके मानकों और कोड कवरेज के लिए प्राथमिकताओं के आधार पर), और लिखना बहुत आसान है।
कभी-कभी आप ऐसी स्थितियों में पड़ेंगे जहां आपको View और ViewModels के बीच प्रेजेंटेशन लॉजिक के वितरण का कोई आधा उपाय ढूंढना होगा, जो इनमें से किसी भी दृष्टिकोण का सख्ती से पालन नहीं करता है।
मैं एक दृष्टिकोण की दूसरे पर वकालत नहीं कर रहा हूं, बल्कि आपको हाथ में आवश्यकताओं के आधार पर अपने दृष्टिकोण में लचीला होने के लिए प्रोत्साहित कर रहा हूं।
प्राथमिकताओं और आवश्यकताओं के आधार पर अपनी आर्किटेक्चर चुनें
इस लेख का उद्देश्य दो अलग-अलग दृष्टिकोणों को देखना था जो एक डेवलपर Android प्लेटफॉर्म पर (कुछ अन्य प्लेटफार्मों पर कैरीओवर के साथ) MVVM स्टाइल GUI आर्किटेक्चर बनाने के संदर्भ में ले सकता है।
सच्चाई यह है कि हम इन दो दृष्टिकोणों के भीतर छोटे अंतरों के बारे में और अधिक विशिष्ट हो सकते हैं।
- क्या View को उसके पास मौजूद हर व्यक्तिगत विजेट/कंट्रोल के लिए एक फील्ड का निरीक्षण करना चाहिए, या उसे एक फील्ड का निरीक्षण करना चाहिए जो पूरे View को हर बार नए सिरे से रेंडर करने के लिए एक सिंगल मॉडल प्रकाशित करता है?
- शायद हम अपने ViewModels को एक-से-एक होने से बचा सकते हैं, जबकि अपने Views को Humble Objects के रूप में रखते हैं, बस प्रेजेंटर या कंट्रोलर जैसी कोई चीज मिक्स में जोड़कर?
बातें सस्ती हैं, और मैं आपको इन चीजों को कोड में आजमाने और सीखने की दृढ़ता से सलाह देता हूं ताकि आपको मेरे जैसे लोगों पर भरोसा न करना पड़े कि आपको क्या करना है।
अंततः, मुझे लगता है कि दो तत्व जो एक महान आर्किटेक्चर के लिए बनाते हैं, निम्नलिखित विचारों पर आते हैं:
सबसे पहले, कई दृष्टिकोणों के साथ तब तक खेलें जब तक आपको वह न मिल जाए जिसे आप पसंद करते हैं। यह वास्तव में प्रत्येक शैली में एक एप्लिकेशन (यह सरल हो सकता है) बनाकर और यह देखकर सबसे अच्छा किया जाता है कि क्या सही लगता है।
दूसरे, समझें कि प्राथमिकताओं के अलावा, विभिन्न शैलियों अलग-अलग लाभों पर जोर देंगी विभिन्न घाटे के बदले में। अंततः, आप अंध विश्वास के बजाय प्रोजेक्ट आवश्यकताओं की अपनी समझ के आधार पर अच्छे विकल्प चुनने में सक्षम होंगे।
सॉफ़्टवेयर आर्किटेक्चर के बारे में और जानें:
सोशल
https://www.instagram.com/rkay301/
https://www.facebook.com/wiseassblog/
https://twitter.com/wiseass301
https://wiseassblog.com/