प्रस्तुतकर्ता के साथ काम करने का GWT- प्लेटफ़ॉर्म मूल बातें

सभी habrazhitel शुभ दिन!

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

हमारे एप्लिकेशन में एक नेविगेशन पैनल होगा, जिस पर वर्तमान दृश्य स्विच करने के लिए बटन स्थित हैं। साथ ही दो कॉलम जिसमें हम स्थिति के आधार पर वांछित सामग्री डालेंगे। मैंने स्पष्टता के लिए दो कॉलम बनाए। वास्तविक जीवन में, पाठ्यक्रम में से एक की आवश्यकता होगी।

यदि आप नावबार में बटन पर क्लिक करते हैं, तो या तो एप्लिकेशन का बाईं ओर खुल जाएगा, या अर्थहीन टेक्स्ट के साथ दाईं ओर।

डिफ़ॉल्ट रूप से, बाएं कॉलम खुलता है, जिस पर पहले और अंतिम नाम दर्ज करने के लिए एक डायलॉग बॉक्स खोलने के लिए एक बटन होता है। पुष्टिकरण बटन दबाने के बाद, यह डेटा सही कॉलम में स्थानांतरित किया जाता है और प्रदर्शित किया जाता है।






इसलिए, शुरुआत के लिए, हमें IDE में GWT प्रोजेक्ट बनाने की आवश्यकता है। GWTP के साथ काम करने के लिए, हमें लाइब्रेरी को प्रोजेक्ट में जोड़ने की आवश्यकता है: guice-2.0.jar, guice-3.0.jar, gwtp-all-1.0.jar, aopalliance.jar, guice-Assistedinjectject-3.0.jar। मैंने आवेदन में "सौंदर्य" को जोड़ने के लिए gwt-bootstrap-2.2.2.0-SNAPSHOT.jar को भी जोड़ा।



आप ग्रहण में gwt-platform plugin इंस्टॉल कर सकते हैं। यह जीवन को बहुत सुगम बनाता है। इसकी मदद से, आप नई परियोजनाओं और प्रस्तुति-प्रस्तुति दोनों बंडल बना सकते हैं। इस लिंक से डाउनलोड करें: plugin.gwt-platform.googlecode.com/hg/update

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

public class ClientModule extends AbstractPresenterModule { @Override protected void configure() { install(new DefaultModule(ClientPlaceManager.class)); bindPresenter(MainPagePresenter.class, MainPagePresenter.MyView.class, MainPageView.class, MainPagePresenter.MyProxy.class); bindConstant().annotatedWith(DefaultPlace.class).to(NameTokens.main); } } 

  @GinModules({ DispatchAsyncModule.class, ClientModule.class }) public interface ClientGinjector extends Ginjector { EventBus getEventBus(); PlaceManager getPlaceManager(); Provider<MainPagePresenter> getMainPagePresenter(); } 

अगला हमारा प्रवेश बिंदु है: यहां हम वर्तमान पृष्ठ (स्थान) पर जाने के लिए अपने प्लेसमेंट को बताते हैं। यही है, अगर हमने ब्राउज़र के एड्रेस बार में कुछ टोकन दर्ज किए हैं जो आवश्यक स्थान निर्धारित करता है, तो हम वहां पहुंच जाएंगे। बेशक, बशर्ते कि हमारी पहुंच हो। (उदाहरण के लिए, गेटकीपर इसके लिए जिम्मेदार हो सकता है)।

 public class HabraTest implements EntryPoint { private final ClientGinjector ginjector = GWT.create(ClientGinjector.class); @Override public void onModuleLoad() { DelayedBindRegistry.bind(ginjector); ginjector.getPlaceManager().revealCurrentPlace(); } } 

मैं जगह के साथ काम करने पर ध्यान केंद्रित नहीं करूंगा। पहले से ही GWT पर कई उल्लेखनीय लेख थे। उदाहरण के लिए।

मैं दिखाऊंगा कि कैसे आप जगह का उपयोग किए बिना छोटे जीडब्ल्यूटी एप्लिकेशन बना सकते हैं (एक स्थान पर अधिक सटीक,)।

सबसे पहले, हमारे आवेदन के मुख्य प्रस्तुतकर्ता बनाएँ:

 public class MainPagePresenter extends Presenter<MainPagePresenter.MyView, MainPagePresenter.MyProxy> implements MainPageUiHandlers, FirstPageEvent.Handler{ public interface MyView extends View, HasUiHandlers<MainPageUiHandlers> { } //       public final static Object SLOT_FIRST_PAGE = new Object(); public final static Object SLOT_SECOND_PAGE = new Object(); //  private FirstPagePresenter firstPagePresenter; private SecondPagePresenter secondPagePresenter; @ProxyStandard @NameToken(NameTokens.main) public interface MyProxy extends ProxyPlace<MainPagePresenter> { } private EventBus eventBus; private final PlaceManager placeManager; //    @Inject public MainPagePresenter(final EventBus eventBus, final MyView view, FirstPagePresenter firstPagePresenter, SecondPagePresenter secondPagePresenter, final MyProxy proxy, final PlaceManager placeManager) { super(eventBus, view, proxy); this.placeManager = placeManager; this.firstPagePresenter = firstPagePresenter; this.secondPagePresenter = secondPagePresenter; this.eventBus = eventBus; //      getView().setUiHandlers(this); eventBus.addHandler(FirstPageEvent.getType(), this); } //       @Override protected void revealInParent() { RevealRootContentEvent.fire(this, this); } @Override protected void onBind() { super.onBind(); //       getView().setInSlot(SLOT_FIRST_PAGE, firstPagePresenter); } //       MainPageView @Override public void onRightBtnClicked() { showRightContent(); MainPageEvent mainPageEvent = new MainPageEvent( MainPageEvent.Action.SHOW_LOREM_IPSUM); eventBus.fireEvent(mainPageEvent); } //     @Override public void onLeftBtnClicked() { showLeftContent(); } public void showLeftContent() { removeFromSlot(SLOT_SECOND_PAGE, secondPagePresenter); getView().setInSlot(SLOT_FIRST_PAGE, firstPagePresenter); } public void showRightContent() { removeFromSlot(SLOT_FIRST_PAGE, firstPagePresenter); getView().setInSlot(SLOT_SECOND_PAGE, secondPagePresenter); } @Override public void onFirstPageEvent(FirstPageEvent event) { //      ,         showRightContent(); MainPageEvent mainPageEvent = new MainPageEvent( MainPageEvent.Action.SHOW_FORM_RESULT, event.getFirstName(), event.getLastName()); eventBus.fireEvent(mainPageEvent); } } 

ध्यान दें कि हमने FirstPagePresenter FirstPagePresenter, SecondPagePresenter secondPagePresenter के निर्माता में इंजेक्ट किया।
ये प्रस्तुतकर्ता होंगे - एप्लिकेशन के बाएं और दाएं भागों का प्रतिनिधित्व करने वाले विजेट (जो कि, सिद्धांत रूप में, अलग-अलग पृष्ठ हैं);

GWTP प्रस्तुतकर्ताओं के तीन मुख्य प्रकार हैं:

• ट्रांसपोंडर भी जगह है
• ट्रांसपोंडर विजेट्स (प्रेजेंटरविजेट)
• प्रस्तुतकर्ता विजेट एक पॉपअप विंडो का प्रतिनिधित्व करता है

प्रस्तुतकर्ता-स्थान का उपयोग एप्लिकेशन के अलग-अलग पृष्ठ बनाने के लिए किया जाता है, नेविगेट करने के लिए जिसके माध्यम से आप ब्राउज़र के एड्रेस बार में जोड़े गए तथाकथित टोकन का उपयोग कर सकते हैं।
प्रत्येक ऐसे प्रस्तुतकर्ता में एक एनोटेशन होना चाहिए जो इंगित करता है कि कौन सा टोकन प्रस्तोता से जुड़ा हुआ है।
हमारे मामले में, हम केवल एक ऐसे प्रस्तुतकर्ता का उपयोग करते हैं।

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

MainPagePresenter वर्ग दिखाता है कि स्लॉट सिर्फ एक वस्तु है:

  public final static Object SLOT_FIRST_PAGE = new Object(); public final static Object SLOT_SECOND_PAGE = new Object(); 

संबंधित दृश्य में, हम प्रस्तुतकर्ताओं को स्लॉट में डालने के नियमों को परिभाषित करते हैं:

 public class MainPageView extends ViewWithUiHandlers<MainPageUiHandlers> implements MainPagePresenter.MyView { //    @UiField HTMLPanel main; //   @UiField ResponsiveNavbar navbar; //   @UiField Button firstPageBtn, secondPageBtn; private static MainPageViewUiBinder uiBinder = GWT .create(MainPageViewUiBinder.class); interface MainPageViewUiBinder extends UiBinder<Widget, MainPageView> { } //     @UiField Column leftColumn, rightColumn; @Inject public MainPageView() { uiBinder.createAndBindUi(this); navbar.setInverse(true); //   firstPageBtn.addClickHandler(new ClickHandler() { @Override public void onClick(ClickEvent event) { getUiHandlers().onLeftBtnClicked(); } }); secondPageBtn.addClickHandler(new ClickHandler() { @Override public void onClick(ClickEvent event) { getUiHandlers().onRightBtnClicked(); } }); } @Override public Widget asWidget() { return main; } //       @Override public void setInSlot(Object slot, IsWidget content) { if(slot == MainPagePresenter.SLOT_FIRST_PAGE ) { leftColumn.add(content); } else if(slot == MainPagePresenter.SLOT_SECOND_PAGE ){ rightColumn.add(content); } else { super.setInSlot(slot, content); } } //       @Override public void removeFromSlot(Object slot, IsWidget content) { if(slot == MainPagePresenter.SLOT_FIRST_PAGE ) { leftColumn.remove(content); } else if(slot == MainPagePresenter.SLOT_SECOND_PAGE ){ rightColumn.remove(content); } else { super.removeFromSlot(slot, content); } } } 

सब कुछ काफी सरल है: setInSlot () प्रस्तुतकर्ता और इसके संबंधित स्लॉट को स्वीकार करता है।
हम केवल इस प्रस्तोता को रखने के लिए किस विजेट में इंगित करते हैं। इस स्थिति में, ये दो बूटस्ट्रैप कॉलम हैं बाएँ और दाएँ दाएँ स्तंभ।
यद्यपि मैं इस मामले में दोहराता हूं, पृष्ठों के माध्यम से मार्ग का अनुकरण करने के लिए सब कुछ एक कॉलम में रखना अधिक उपयुक्त होगा।

इसके अलावा, हमारे प्रस्तुतकर्ता विगेट्स और उनके विचार:

 public class FirstPagePresenter extends PresenterWidget<FirstPagePresenter.MyView> implements FirstPageUiHandlers, PopupEvent.Handler{ public interface MyView extends View, HasUiHandlers<FirstPageUiHandlers> { } //    FirstPagePopupPresenter firstPagePopupPresenter; EventBus eventBus; @Inject public FirstPagePresenter(final EventBus eventBus, final MyView view, FirstPagePopupPresenter firstPagePopupPresenter ) { super(eventBus, view); this.firstPagePopupPresenter = firstPagePopupPresenter; this.eventBus = eventBus; getView().setUiHandlers(this); //    PopupEvent eventBus.addHandler(PopupEvent.getType(), this); } @Override public void onShowFormBtnClicked() { //      showForm(true); } private void showForm(boolean show) { if(show){ addToPopupSlot(firstPagePopupPresenter, true); firstPagePopupPresenter.getView().show(); } else { removeFromPopupSlot(firstPagePopupPresenter); } } @Override public void onPopupEvent(PopupEvent event) { showForm(false); eventBus.fireEvent(new FirstPageEvent(event.getFirstName(), event.getLastName())); } } 

कृपया ध्यान दें कि मैंने कुछ FirstPagePopupPresenter FirstPagePopupPresenter को इंजेक्ट किया है। (कोड नीचे होगा)। यह हमारा फॉर्म पॉपअप है। इसी तरह, आप किसी भी प्रस्तोता विगेट्स को किसी भी मात्रा में और किसी भी घोंसले के शिकार के साथ इंजेक्ट कर सकते हैं। मुख्य बात पदानुक्रम को तोड़ना नहीं है।

 public class FirstPageView extends ViewWithUiHandlers<FirstPageUiHandlers> implements FirstPagePresenter.MyView { private final Widget widget; @UiField Button showFormBtn; public interface Binder extends UiBinder<Widget, FirstPageView> { } @Inject public FirstPageView(final Binder binder) { widget = binder.createAndBindUi(this); showFormBtn.addClickHandler(new ClickHandler() { @Override public void onClick(ClickEvent event) { getUiHandlers().onShowFormBtnClicked(); } }); } @Override public Widget asWidget() { return widget; } } 

दृश्य कुछ खास नहीं है, सिवाय इसके कि इसमें टाइप किए गए व्यूविथयूहैंडलर वर्ग को विरासत में मिला है।
चूंकि हम एमवीपी के सिद्धांतों का उल्लंघन नहीं करना चाहते हैं, इसलिए हम प्रस्तोता को सीधे दृश्य (हम इसके विपरीत, कर सकते हैं) तक नहीं पहुंच सकते हैं। इसके लिए हम इंटरफेस का इस्तेमाल करते हैं। हम getUiHandlers () का उपयोग कर बटन क्लिक के बारे में सूचित करते हैं।

 public interface FirstPageUiHandlers extends UiHandlers{ void onShowFormBtnClicked(); } 

getUiHandlers () FirstPageUiHandlers इंटरफ़ेस लौटाता है जिसमें हम उन तरीकों को निर्दिष्ट करते हैं जिन्हें संबंधित प्रस्तुतकर्ता में लागू किया जाना चाहिए। स्वाभाविक रूप से, प्रस्तुतकर्ता को इस इंटरफ़ेस को लागू करना चाहिए, और इसमें स्थित MyView इंटरफ़ेस को HasUiHandlers टाइपिंग इंटरफ़ेस को इनहेरिट करना चाहिए। और मुख्य बात यह है कि प्रस्तुतकर्ता में अपने आप को देखने की घटनाओं के लिए एक हैंडलर के रूप में असाइन करने के लिए नहीं है - getView (); SetUiHandlers (यह);

अगला, प्रस्तुतकर्ता और दूसरे पृष्ठ का संगत दृश्य:

 public class SecondPagePresenter extends PresenterWidget<SecondPagePresenter.MyView> implements MainPageEvent.Handler { public interface MyView extends View { void showLoremIpsum(); void showFormInfo(String firstName, String lastName); } EventBus eventBus; @Inject public SecondPagePresenter(final EventBus eventBus, final MyView view) { super(eventBus, view); this.eventBus = eventBus; eventBus.addHandler(MainPageEvent.getType(), this); } @Override public void onMainPageEvent(MainPageEvent event) { switch(event.getAction()) { case SHOW_FORM_RESULT: showFormInfoWidget(event.getFirstName(), event.getLastName()); break; case SHOW_LOREM_IPSUM: showLoremIpsumWidget(); break; default: break; } } private void showLoremIpsumWidget() { getView().showLoremIpsum(); } private void showFormInfoWidget(String firstName, String lastName) { getView().showFormInfo( firstName, lastName); } 

 public class SecondPageView extends ViewImpl implements SecondPagePresenter.MyView { private final Widget widget; @UiField FlowPanel contentPanel; public interface Binder extends UiBinder<Widget, SecondPageView> { } @Inject public SecondPageView(final Binder binder) { widget = binder.createAndBindUi(this); } @Override public Widget asWidget() { return widget; } @Override public void showLoremIpsum() { contentPanel.clear(); contentPanel.add(new LoremIpsumWidget()); } @Override public void showFormInfo(String firstName, String lastName) { contentPanel.clear(); contentPanel.add(new FormInfoWidget(firstName, lastName)); } } 

जीडब्ल्यूटी पर डेवलपर के लिए विशेष रूप से दिलचस्प और नया कुछ भी नहीं है। प्रस्तुतकर्ताओं के बीच संचार मानक घटनाओं (GwtEvent) के माध्यम से होता है।

और अंत में फॉर्म के साथ पॉपअप करें:

 public class FirstPagePopupPresenter extends PresenterWidget<FirstPagePopupPresenter.MyView> implements PopupUiHandlers { public interface MyView extends PopupView , HasUiHandlers<PopupUiHandlers>{ } EventBus eventBus; @Inject public FirstPagePopupPresenter(final EventBus eventBus, final MyView view) { super(eventBus, view); this.eventBus = eventBus; getView().setUiHandlers(this); } @Override public void onSubmitBtnClicked(String firstName, String lastName) { eventBus.fireEvent(new PopupEvent(firstName, lastName)); } } 

 public class FirstPagePopupView extends PopupViewWithUiHandlers<PopupUiHandlers> implements FirstPagePopupPresenter.MyView { @UiField PopupPanel main; @UiField Button submitBtn; @UiField TextBox firstName, lastName; public interface Binder extends UiBinder<Widget, FirstPagePopupView> { } @Inject public FirstPagePopupView(final EventBus eventBus, final Binder binder) { super(eventBus); binder.createAndBindUi(this); main.setAnimationEnabled(true); main.setModal(true); main.setGlassEnabled(true); submitBtn.addClickHandler(new ClickHandler() { @Override public void onClick(ClickEvent event) { getUiHandlers().onSubmitBtnClicked(firstName.getValue(), lastName.getValue()); } }); } @Override public Widget asWidget() { return main; } } 

जैसा कि आप देख सकते हैं, पॉपअप भी एक प्रस्तोता विजेट है, लेकिन इसके दृश्य इंटरफ़ेस को पॉपअप व्यू विरासत में मिलना चाहिए। और मुख्य दृश्य पैनल पॉपअपपनेल, अच्छी तरह से या इस वर्ग के वारिस होना चाहिए। पारंपरिक प्रस्तुतकर्ता विगेट्स से एक और अंतर यह है कि आपको किसी पृष्ठ पर पॉप-अप दिखाने के लिए स्लॉट और इंसर्ट पैनल की आवश्यकता नहीं है। यह addToPopupSlot () विधि का उपयोग करने के लिए पर्याप्त है;

साथ ही, सभी बंडलों में, प्रस्तुति प्रस्तुति यूबिंदर का उपयोग करती थी। मैं संबंधित * ui.xml फ़ाइलों को अपलोड नहीं करता हूं। वहां, सिद्धांत रूप में, GWT डेवलपर्स के लिए कुछ भी दिलचस्प नहीं है।

इस पते पर परियोजना कुछ समय के लिए उपलब्ध होगी ।

और इसलिए, अब हम यह बताने के लिए परियोजना पर जाएंगे कि क्या हो रहा है और प्रस्तुतकर्ता कैसे संबंधित हैं:

ओवरराइंड ऑनबाइंड () विधि में मेनपेज पेसेंटर को लोड करते समय, हम तुरंत पहले पेज को स्लॉट पर प्रस्तुत करते हैं:

  @Override protected void onBind() { super.onBind(); getView().setInSlot(SLOT_FIRST_PAGE, firstPagePresenter); } 

(प्रस्तुतकर्ताओं के जीवन चक्र और तरीकों के बारे में onBind (), onUnbind, onReveal (), onReset (), onHide () मैं अगले लेख में बताना चाहूंगा।)

तदनुसार, FirstPagePresenter'a दृश्य स्क्रीन के बाईं ओर दिखाई देता है। जब हम बटन पर क्लिक करते हैं, तो हम FirstPageUresHandlers इंटरफ़ेस में वर्णित FirstPagePresenter में onShowFormBtnClicked () विधि के कार्यान्वयन को लागू करते हैं

कॉल करें:

  showFormBtn.addClickHandler(new ClickHandler() { @Override public void onClick(ClickEvent event) { getUiHandlers().onShowFormBtnClicked(); } }); 

FirstPagePresenter 'में निम्नलिखित होता है:

  addToPopupSlot(firstPagePopupPresenter, true); 

हम स्लॉट में पॉपअप प्रस्तुतकर्ता सेट करते हैं। जैसा कि मैंने पहले ही उल्लेख किया है, पॉपअप के लिए, स्लॉट को परिभाषित करने की आवश्यकता नहीं है। एकमात्र शर्त यह है कि प्रस्तुतकर्ता जिससे पॉपअप कहा जाता है वह स्वयं माता-पिता के स्लॉट में होना चाहिए और इसी तरह श्रृंखला में। AddToPopupSlot () विधि में दूसरा पैरामीटर इंगित करता है कि क्या एप्लिकेशन विंडो में पॉपअप को केंद्रित करना है (विधि में कई अधिभार हैं और यह पैरामीटर आमतौर पर वैकल्पिक है)।

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

  @Override public void onPopupEvent(PopupEvent event) { showForm(false); eventBus.fireEvent(new FirstPageEvent(event.getFirstName(), event.getLastName())); } 

सबसे पहले, शोफॉर्म () विधि में, हम पॉपअप को स्लॉट से निकालते हैं:

 removeFromPopupSlot(firstPagePopupPresenter); 

फिर हम एक नई घटना (अब यह FirstPageEvent है) को आगे फेंकते हैं। हमारा MainPagePresenter इसे सब्सक्राइब किया गया है:

  @Override public void onFirstPageEvent(FirstPageEvent event) { //       ,         showRightContent(); MainPageEvent mainPageEvent = new MainPageEvent( MainPageEvent.Action.SHOW_FORM_RESULT, event.getFirstName(), event.getLastName()); eventBus.fireEvent(mainPageEvent); } 

इसे प्राप्त करने के बाद, MainPagePresenter स्लॉट से पहला पृष्ठ हटाता है और दूसरा सम्मिलित करता है:

  public void showRightContent() { removeFromSlot(SLOT_FIRST_PAGE, firstPagePresenter); getView().setInSlot(SLOT_SECOND_PAGE, secondPagePresenter); } 

इसके अलावा वह पहले से ही MainPageEvent आगे मक्खियों। न केवल नाम और उपनाम, बल्कि एक्शन भी, इसके बारे में शिकायत कर रहे हैं।

हमारा दूसरा पेजप्रेशर, ऑनमैनेजेज () विधि में एक घटना प्राप्त करने के बाद, पृष्ठ पर क्या दिखाना है, यह तय करता है। इस मामले में, ये प्रस्तुतकर्ता के बिना साधारण विजेट हैं।

  @Override public void onMainPageEvent(MainPageEvent event) { switch(event.getAction()) { case SHOW_FORM_RESULT: showFormInfoWidget(event.getFirstName(), event.getLastName()); break; case SHOW_LOREM_IPSUM: showLoremIpsumWidget(); break; default: break; } } 

बस इतना ही। यह कुछ को लग सकता है कि ऐसे सरल कार्यों के लिए बहुत अधिक कोड है, लेकिन:

• हम एमवीपी के सिद्धांतों का उल्लंघन नहीं करते हैं - दृश्य को इसके प्रस्तुतकर्ता के बारे में कुछ भी नहीं जानना चाहिए
• एप्लिकेशन को मॉड्यूल में विभाजित करके, कोड पुन: प्रयोज्य और अधिक लचीला हो जाता है।

इसके अलावा, कुछ शायद नाराज हो जाएंगे - घटनाओं के प्रसारण की इतनी लंबी श्रृंखला क्यों? हालाँकि, आप देख सकते हैं कि ईवेंट प्राप्त करने के बाद, प्रस्तुतकर्ता, अगले एक को भेजने से पहले, किसी प्रकार का ऑपरेशन करता है। उदाहरण के लिए, यह अनावश्यक प्रेजेंटर्स को हटा देता है या किसी तरह प्राप्त डेटा को प्रोसेस करता है।

सामान्य तौर पर, मुझे आशा है कि यह लेख किसी के लिए उपयोगी होगा और वह जीडब्ल्यूटी-प्लेटफ़ॉर्म की ओर अपनी आँखें घुमाएगा।

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