स्विज़ फ़्रेमवर्क (सरलतम अनुप्रयोग)

मेरी पिछली पोस्ट: स्विज़ फ्रेमवर्क (अवलोकन)

इस पोस्ट में मैं यह समझाने की कोशिश करूंगा कि स्विज़ फ्रेमवर्क में लिखा गया सबसे सरल एप्लिकेशन क्या काम करता है और यह कैसे काम करता है। यदि आपका कोई प्रश्न या टिप्पणी है, तो टिप्पणी लिखें, मैं सभी को जवाब देने की कोशिश करूंगा। इस उदाहरण में वर्णित स्रोतों को यहां पाया जा सकता है।


तो स्विज़ का उपयोग करके एक फ्लेक्स एप्लिकेशन का सबसे सरल आरेख इस प्रकार है:

व्यू (या प्रस्तुति मॉडल) एक घटना को भेजता है जो मेटा टैग [Mediate(event="someEvent")] का उपयोग करके नियंत्रक द्वारा पकड़ा जाता है, फिर नियंत्रक सेवा को कॉल करता है और मॉडल को बदलता है। दृश्य केवल मॉडल में परिवर्तन को दर्शाता है।

Inzhekting

यह समझने के लिए कि आपको किस चीज़ में इंजेक्शन लगाया गया है, आप चित्र को देख सकते हैं:

मॉडल को दृश्य और नियंत्रक में इंजेक्ट किया जाता है। तदनुसार, मॉडल दृश्य दिखाता है, नियंत्रक इसे अपडेट करता है। सेवाओं को भी प्रतिनिधि में इंजेक्ट किया जाता है, और प्रतिनिधि, नियंत्रक में इंजेक्ट किया जाता है।

के घटक

मुख्य SwizQuickstart.mxml एप्लिकेशन में एक स्विज़ घटक शामिल है जो बीनप्रोवाइडर्स और कॉन्फिगरेशन को निर्दिष्ट करता है, साथ ही साथ यूजरफार्म व्यू भी

 <fx: घोषणाएँ>
	 <स्विज़: स्विज़>	
		 <swiz: beanProviders>
			 <config: बीन्स />
		 </ swiz: beanProviders>
			
		 <swiz: config>
			 <स्विज़: स्विज़कोनफिग 
				 EventPackages = "org.swizframework.quickswiz.event। *।" 
				 viewPackages = "org.swizframework.quickswiz.view। *" />
		 </ swiz: config>
	 </ swiz: swiz>
 </ fx: घोषणाएँ>

 <दृश्य: UserForm id = "userForm" />

आइए सभी घटकों का क्रम में विश्लेषण करें

SwizConfig

पूरे ढांचे को इस वर्ग के साथ कॉन्फ़िगर किया गया है। यह इस तरह दिखता है:

 <स्विज़: स्विज़कोनफिग
	 setUpEventType = "{Event.ADDED_TO_STAGE}" 
	 setUpEventPhase = "{EventPhase.CAPTURING_PHASE}" 
	 setUpEventPyerity = "50"
	 teardownEventType = "{Event.REMOVED_FROM_STAGE}" 
	 teardownEventPhase = "{EventPhase.CAPTURING_PHASE}" 
	 आंसूमनोपयोगिता = "50"
	 EventPackages = "com.foo.events, org.bar.events"
	 validateEventTypes = "सही"
	 viewPackages = "com.foo.views, org.bar.events"
	 DefaultFaultHandler = "हैंडहेल्डफ़्लैड्स हैंडल"
	 defaultDispatcher = "वैश्विक" />

फलियां

बीनप्रोवाइडर्स में, नियंत्रक, मॉडल, सेवाएं, शामिल किए जाने वाले प्रतिनिधियों को इंगित किया जाता है। इन वर्गों के प्रसंस्करण की प्रक्रिया में, वे सभी मेटा टैग होते हैं और सभी आंतरिक प्रक्रियाएं होती हैं। <config:Beans /> वर्ग इस प्रकार है:

 <swiz: बीनप्रॉइडर 
	 xmlns: fx = "http://ns.adobe.com/mxml/2009"
	 xmlns: swiz = "http://swiz.swizframework.org"
	 xmlns: सेवा = "org.swizframework.quickswiz.service। * 
	 xmlns: नियंत्रक = "org.swizframework.quickswiz.controller। *">
	
	 <सेवा: उपयोगकर्ता सेवा आईडी = "उपयोगकर्ता सेवा" />
	 <नियंत्रक: UserController id = "userController" />
	
	 <! - हम सर्वर-साइड कॉल का अनुकरण करने में मदद करने के लिए स्विज़ सर्विस हेल्पर का उपयोग करेंगे।  ->
	 <swiz: ServiceHelper id = "serviceHelper" />

 </ swiz: बीनप्रॉइडर>

तदनुसार, बीन्स स्विज़ प्रसंस्करण के बाद पहले से ही जानता है कि हमारे पास सेवाएं और नियंत्रक हैं।

UserForm

यह एक साधारण mxml है, सबसे दिलचस्प बात यह है कि इंजेक्शन लगाना:

 [Bindable]
 [Inject (स्रोत = "userController.currentUser", bind = "true")]
 सार्वजनिक संस्करण उपयोगकर्ता: उपयोगकर्ता;

आगे किसी भी स्थान पर आप हमारे उपयोगकर्ता मॉडल का उपयोग कर सकते हैं, उदाहरण के लिए, प्रदर्शित करने के लिए:

  <s: TextInput id = "firstName" टेक्स्ट = "{user.firstName}" /> 

यह सब कैसे काम करता है:

दृश्य यह प्रदर्शित करता है कि इसे मॉडल से क्या मिला।
<s:TextInput id="firstName" text="{user.firstName}" />

इसके बाद, उपयोगकर्ता किसी भी डेटा को संपादित करता है, और सेव बटन पर क्लिक करता है।
<s:Button label="Save" click="saveUser()" />

भेजी हुई घटना
user.firstName = firstName.text;
user.lastName = lastName.text;
user.email = email.text;
var event : UserEvent = new UserEvent( UserEvent.SAVE_USER_REQUESTED );
event.user = user;
dispatchEvent( event );

ईवेंट नियंत्रक में पकड़ा जाता है, और सेवा को कॉल करता है। UserService.saveUser (उपयोगकर्ता) कमांड एक AsyncToken देता है। यह, क्रमशः, कोई भी प्रतिनिधि और कोई भी कॉल हो सकता है जो AsyncToken देता है।

 [मध्यस्थता (घटना = "UserEvent.SAVE_USER_REQUESTED", गुण = "उपयोगकर्ता")]
 सार्वजनिक समारोह saveUser (उपयोगकर्ता: उपयोगकर्ता): शून्य
 {
	 serviceHelper.executeServiceCall (userService.saveUser (उपयोगकर्ता), handleSaveUserResort);
 }

AsyncToken परिणाम घटना को भेजने के बाद, handleSaveUserResult फ़ंक्शन निष्पादित होता है

 निजी फ़ंक्शन हैंडलसेवयूसरसाइकल (घटना: परिणाम): शून्य
 {
	 Alert.show ('उपयोगकर्ता सफलतापूर्वक सहेजा गया है!');
 }

इस स्थान में, हम तदनुसार या किसी भी घटना को मॉडल को बदल सकते हैं जिसे किसी भी नियंत्रक या प्रस्तुति मॉडल में [मेडिएट] टैग का उपयोग करके सफलतापूर्वक पकड़ा जा सकता है।

निम्नलिखित पदों में मैं विश्लेषण करूँगा कि एक अधिक व्यापक स्विज़-आधारित एप्लिकेशन कैसे काम करता है, और मैं स्विज़ कक्षाओं के गुणों का भी विस्तार से वर्णन करूंगा।