रिमोट प्रक्रिया कॉल (RPC) Android पर कमांड पैटर्न

प्रस्तावना

हाल ही में, मैंने एंड्रॉइड प्लेटफॉर्म के साथ अपने परिचित को शुरू किया। एक निश्चित चरण में, यह जांचना आवश्यक था कि चीजें दूरस्थ प्रक्रिया कॉल के साथ कैसे चल रही हैं या, अधिक सरल रूप से, क्लाइंट-सर्वर इंटरैक्शन।

सबसे पहले, यह आशा की गई थी कि मंच EJB प्रौद्योगिकी के उपयोग की अनुमति देगा। इंटरनेट पर कुछ खोज के बाद, मुझे विश्वास हो गया कि यह इतना सरल नहीं है। अधिकांश स्रोतों ने विकल्प के रूप में वेब सेवाओं का उपयोग करने की सिफारिश की EJB Android के लिए बहुत भारी है। वेब सेवाओं के लिए, ksoap2-android ढांचे की सिफारिश की गई थी।

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

क्या करना है, यह वास्तव में है कि इतने सालों तक एंड्रॉइड प्लेटफॉर्म पर आरपीसी को व्यवस्थित करने के लिए और अधिक सुविधाजनक तरीका नहीं है? तलाश जारी रही। कई स्रोतों ने JSON का उपयोग करने की सिफारिश की है। लेकिन मैं वास्तव में JSON के लिए क्रमांकन लिखना नहीं चाहता था। थोड़ी देर बाद, हालांकि, मैं गन्स लाइब्रेरी का उल्लेख करने लगा , और ऐसा लगता है कि यह इतना बुरा नहीं है।

आखिरी उम्मीद जीडब्ल्यूटी-आरपीसी तकनीक थी। यह माना जाता था कि चूंकि GWT और Android एक निगम की संतान हैं, इसलिए संभवतः Android क्लाइंट से GWT-RPC विधियों को कॉल करने का एक आसान तरीका होना चाहिए। दुर्भाग्य से, यह विधि मुझे नहीं मिली। हालाँकि एक gwt-phonegap लाइब्रेरी है, लेकिन मैं अभी आरपीसी की जानकारी नहीं पा सका हूँ।

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

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

मैंने परियोजना के स्रोत कोड का अध्ययन करना शुरू किया। सर्वर साइड को सरल बनाना, और GWT के साथ सभी संचार को तोड़ना आवश्यक था। अब सभी एक्शन ऑब्जेक्ट को GWT IsSerializable के बजाय नियमित Serializable इंटरफ़ेस को लागू करना था। कई दिनों के काम के बाद, परिणाम एक परिणाम था जिसे मैं समुदाय के साथ साझा करना चाहता था। इसलिए मैंने इसे http-dispatch नामक एक लाइब्रेरी में डाल दिया। इसके मूल में, यह वास्तव में थोड़ा नया डिज़ाइन किया गया gwt-dispatch ढाँचा है। लेकिन सबसे अच्छा, पुस्तकालय परीक्षण के लिए तैयार है और, उम्मीद है, एंड्रॉइड प्लेटफॉर्म पर उपयोग करें। कम से कम एमुलेटर और मेरे टैबलेट पर पहले परीक्षण सफल रहे। मुझे उम्मीद है कि समुदाय की मदद से परिणाम को दिमाग में लाना संभव होगा।

प्रस्तावना यहीं समाप्त होती है। मेरा मतलब है कि कई पाठक अभी भी व्यावहारिक भाग के लिए यहां आए थे।

व्यावहारिक हिस्सा

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

मैं आपको दिखाऊंगा कि http-डिस्पैच ढांचे का उपयोग करके एक साधारण पिंग कमांड कैसे लिखा जाता है। कमांड सर्वर को एक मनमानी वस्तु भेजेगा और उसी वस्तु को वापस प्राप्त करेगा।

सामान्य क्लाइंट-सर्वर भाग

सबसे पहले, हम क्लाइंट और सर्वर दोनों के संचालन के लिए आवश्यक वस्तुओं का वर्णन करते हैं।

सबसे पहले, आदेश का परिणाम। प्रत्येक परिणाम को net.customware.http.dispatch.sared.Result इंटरफ़ेस को लागू करना चाहिए। हमारा परिणाम AbstractSimpleResult सार वर्ग का विस्तार करेगा, जो उन परिस्थितियों के लिए उपयुक्त है जब एक ऑब्जेक्ट सर्वर से वापस आ जाता है।

PingActionResult.java

import net.customware.http.dispatch.shared.AbstractSimpleResult; public class PingActionResult extends AbstractSimpleResult<Object> { private static final long serialVersionUID = 1L; public PingActionResult(Object object) { super(object); } } 

अब हम सीधे कमांड लिखते हैं जो सर्वर को भेजा जाएगा। उत्तरार्द्ध, बदले में, पिछले चरण में वर्णित परिणाम लौटाएगा। प्रत्येक टीम को जेनेरिक इंटरफ़ेस net.customware.http.dispatch.sared.Action को लागू करना होगा। कार्यान्वयन पैरामीटर को परिणाम के प्रकार को निर्दिष्ट करना होगा। यह पिछले चरण से PingActionResult होगा। हमारी टीम में एक ऑब्जेक्ट होगा जो सर्वर पर deserialized है और क्लाइंट को वापस भेजा जाता है, परिणामस्वरूप, PingActionResult में लिपटे। चूंकि हम प्रशिक्षण सामग्री में सर्वर पर राज्य के कई मामले दिखाना चाहते हैं, इसलिए हम अपनी टीम में अशक्त परिणाम लौटाने और अपवाद को फेंकने के विकल्प भी जोड़ेंगे।

PingAction.java

 public class PingAction implements Action<PingActionResult> { private static final long serialVersionUID = 1L; private Object object; //      private boolean generateException; //   null    private boolean nullResult; public PingAction(Object object) { this.object = object; } public PingAction(boolean nullResult, boolean generateException) { this.generateException = generateException; this.nullResult = nullResult; } public Object getObject() { return object; } public void setObject(Object object) { this.object = object; } public boolean isGenerateException() { return generateException; } public void setGenerateException(boolean generateException) { this.generateException = generateException; } public boolean isNullResult() { return nullResult; } public void setNullResult(boolean nullResult) { this.nullResult = nullResult; } } 

इस स्तर पर, हमने उस भाग का पता लगाया जो क्लाइंट और सर्वर दोनों पर मौजूद होना चाहिए।

सर्वर साइड

सबसे पहले, हम अपनी पिंगएक्शन टीम के लिए एक नियंत्रण वर्ग लिखेंगे। प्रत्येक ऐसे नियंत्रण वर्ग को net.customware.http.dispatch.server.ActionHandler इंटरफ़ेस को लागू करना चाहिए। एक उच्च-स्तरीय अमूर्त वर्ग SimpleActionHandler है जो नए हैंडलर लिखने की सुविधा के लिए पहले से ही ActionHandler इंटरफ़ेस विधियों में से कुछ को लागू करता है

PingActionHandler.java

 import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpSession; import net.customware.http.dispatch.server.ExecutionContext; import net.customware.http.dispatch.server.SimpleActionHandler; import net.customware.http.dispatch.shared.ActionException; import net.customware.http.dispatch.shared.DispatchException; import net.customware.http.dispatch.test.shared.PingAction; import net.customware.http.dispatch.test.shared.PingActionResult; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.google.inject.Inject; import com.google.inject.Provider; public class PingActionHandler extends SimpleActionHandler<PingAction, PingActionResult> { protected final Logger log = LoggerFactory.getLogger(getClass()); @Override public PingActionResult execute(PingAction action, ExecutionContext context) throws DispatchException { try { //      if (action.isGenerateException()) { throw new Exception("Generated exception"); //    null  } else if (action.isNullResult()) { return null; //       } else { Object object = action.getObject(); log.debug("Received object " + object); return new PingActionResult(object); } } catch (Exception cause) { log.error("Unable to perform ping action", cause); //     ,  //       .  //    ActionException,   //   http-dispatch throw new ActionException(cause); } } // rollback         ,  //  BatchAction. ,      //   . @Override public void rollback(PingAction action, PingActionResult result, ExecutionContext context) throws DispatchException { log.debug("PingAction rollback called"); } } 

अब हमें हैंडलर को कंट्रोल सर्वलेट में पंजीकृत करना होगा। पहली बार, मैं आपको दिखाऊंगा कि एक असुरक्षित सर्वलेट के उदाहरण का उपयोग करके बिना जूँ का उपयोग कैसे करें।

प्रत्येक नियंत्रण सर्वलेट को net.ustomware.http.dispatch.server.standard.AbstractStandardDispatchServlet या AbstractSecureDispatchServlet वर्ग का विस्तार करना चाहिए। हमारा मानक नियंत्रण सर्वलेट इस तरह दिखेगा

StandardDispatcherTestService.java

 import net.customware.http.dispatch.server.BatchActionHandler; import net.customware.http.dispatch.server.DefaultActionHandlerRegistry; import net.customware.http.dispatch.server.Dispatch; import net.customware.http.dispatch.server.InstanceActionHandlerRegistry; import net.customware.http.dispatch.server.SimpleDispatch; import net.customware.http.dispatch.server.standard.AbstractStandardDispatchServlet; import net.customware.http.dispatch.test.server.handler.PingActionHandler; /** */ public class StandardDispatcherTestService extends AbstractStandardDispatchServlet { private static final long serialVersionUID = 1L; private Dispatch dispatch; public StandardDispatcherTestService() { // Setup for test case InstanceActionHandlerRegistry registry = new DefaultActionHandlerRegistry(); registry.addHandler( new BatchActionHandler() ); registry.addHandler(new PingActionHandler()); dispatch = new SimpleDispatch( registry ); } @Override protected Dispatch getDispatch() { return dispatch; } } 

यहाँ, हमारे PingActionHandler के अलावा , हम मानक BatchActionHandler को भी पंजीकृत करते हैं। यह बैच बैच कमांड पैकेज को प्रोसेस करने का काम करता है।

अब web.xml में हमारे सर्वलेट का विवरण जोड़ें
web.xml

 <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5"> <servlet> <servlet-name>DispatchServlet</servlet-name> <servlet-class>net.customware.http.dispatch.test.server.standard.StandardDispatcherTestService</servlet-class> <load-on-startup>0</load-on-startup> </servlet> <servlet-mapping> <servlet-name>DispatchServlet</servlet-name> <url-pattern>/standard_dispatch</url-pattern> </servlet-mapping> </web-app> 

यह सर्वर भाग के साथ है।

ग्राहक

चलो ग्राहक पक्ष पर चलते हैं। तुरंत एक आरक्षण करें कि http-dispatch फ्रेमवर्क मानता है कि सर्वर के साथ सभी ऑपरेशन अतुल्यकालिक हैं। हालांकि एक तुल्यकालिक कॉल की संभावना है, लेकिन मैं इसका उपयोग करने की सिफारिश नहीं करूंगा।

हम एंड्रॉइड प्लेटफॉर्म के लिए एक सरल क्लाइंट लिखेंगे जो मानक अतुल्यकालिक इंटरफ़ेस का उपयोग करेगा। सर्वर से बातचीत करने के लिए, आपको स्थिति के आधार पर इंटरफ़ेस net.customware.http.dispatch.client.standard.StandardDispatchServiceAsync या SecureDispatchServiceAsync लागू करना होगा। एंड्रॉइड प्लेटफ़ॉर्म के साथ काम करने के मेरे छोटे अनुभव के बावजूद, मैंने इसके लिए इंटरफ़ेस का एक सरल कार्यान्वयन लिखने की स्वतंत्रता ली। इस बार हम net.customware.http.dispatch.client.android.AndroidStandardDispatchServiceAsync का उपयोग करेंगे । इस कार्यान्वयन की एक विशेषता यह है कि सभी आदेशों को एक अलग थ्रेड में निष्पादित किया जाता है। सर्वर से परिणाम वापस करने पर, EDT स्ट्रीम में प्रोसेसिंग होती है। यह इस तरह दिखता है:

 public <R extends Result> void execute( final Action<R> action, final AsyncCallback<R> callback) { //  -"edt"    "edt"  final Handler uiThreadCallback = new Handler(); new Thread() { @Override public void run() { final Object result = getResult(action); //  і  "edt" ,   //   final Runnable runInUIThread = new Runnable() { @Override public void run() { HttpUtils.processResult(result, callback); } }; uiThreadCallback.post(runInUIThread); } }.start(); } 

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

क्लाइंट कोड में, DispatchAsync वर्ग का ऑब्जेक्ट बनाएँ। आप इस प्रकार कर सकते हैं:

 DispatchAsync dispatch = new StandardDispatchAsync( new DefaultExceptionHandler(), new AndroidStandardDispatchServiceAsync(DISPATCH_URL_STANDARD)); 

सर्वर तक पहुँचते समय, आपको हमारे परिणाम के लिए AsyncCallback का एक प्रकार बनाना होगा।

 AsyncCallback<PingRequestResult> callback = new AsyncCallback<PingRequestResult>() 

और तरीकों को लागू करें

 public void onSuccess(PingRequestResult result) 

और

 public void onFailure(Throwable caught) 

जब आदेश को सफलतापूर्वक निष्पादित किया जाता है और जब एक असाधारण स्थिति होती है, तो तदनुसार कहा जाएगा।

फिर हम निष्पादित करने के लिए कमांड देते हैं:

 dispatcher.execute(pingRequest, callback); 

हम RPCUtils वर्ग का वर्णन करते हैं, जो हमारे सर्वर पर विभिन्न मापदंडों के साथ कई परीक्षण कॉल करेगा। याद रखें, आपको अपने स्थानीय सर्वर के पते के साथ DISPATCH_URL को बदलना होगा। यद्यपि आप मौजूदा का उपयोग कर सकते हैं - यह JBoss Openshift प्लेटफ़ॉर्म पर एक तैनात परीक्षण अनुप्रयोग है।

RPCUtils.java

 import java.util.ArrayList; import java.util.List; import net.customware.http.dispatch.client.AsyncCallback; import net.customware.http.dispatch.client.DefaultExceptionHandler; import net.customware.http.dispatch.client.DispatchAsync; import net.customware.http.dispatch.client.android.AndroidSecureDispatchServiceAsync; import net.customware.http.dispatch.client.android.AndroidStandardDispatchServiceAsync; import net.customware.http.dispatch.client.guice.SecureDispatchModule; import net.customware.http.dispatch.client.secure.CookieSecureSessionAccessor; import net.customware.http.dispatch.client.standard.StandardDispatchAsync; import net.customware.http.dispatch.test.shared.PingRequest; import net.customware.http.dispatch.test.shared.PingRequestResult; public class RPCUtils { protected static final String DISPATCH_URL_STANDARD = "http://httpdispatch-ep.rhcloud.com/standard_dispatch"; static DispatchAsync dispatch = new StandardDispatchAsync( new DefaultExceptionHandler(), new AndroidStandardDispatchServiceAsync(DISPATCH_URL_STANDARD)); public static DispatchAsync getDispatchAsync() { return dispatch; } //     public static void runBasicStringTest(LogWrapper log) { String testObject = "Test String Object"; PingRequest pingRequest = new PingRequest(testObject); testCommon(pingRequest, log); } //      ArrayList<String> public static void runBasicListTest(LogWrapper log) { List<String> testList = new ArrayList<String>(); testList.add("one"); testList.add("two"); PingRequest pingRequest = new PingRequest(testList); testCommon(pingRequest, log); } //     null public static void runNullSubObjectTest(LogWrapper log) { PingRequest pingRequest = new PingRequest(null); testCommon(pingRequest, log); } //  null  public static void runNullObjectTest(LogWrapper log) { PingRequest pingRequest = new PingRequest(true, false); testCommon(pingRequest, log); } //       public static void runExceptionTest(LogWrapper log) { PingRequest pingRequest = new PingRequest(false, true); testCommon(pingRequest, log); } private static void testCommon(PingRequest pingRequest, final LogWrapper log) { final long start = System.currentTimeMillis(); log.log("Sending object: " + pingRequest.getObject()); DispatchAsync dispatcher = getDispatchAsync(); AsyncCallback<PingRequestResult> callback = new AsyncCallback<PingRequestResult>() { @Override public void onSuccess(PingRequestResult result) { if (result == null) { log.log("Received null at " + (System.currentTimeMillis() - start) + "ms"); } else { log.log("Received result: " + result.get() + " at " + (System.currentTimeMillis() - start) + "ms"); } } @Override public void onFailure(Throwable caught) { log.log("Received exception: " + caught.getMessage() + " at " + (System.currentTimeMillis() - start) + "ms"); } }; dispatcher.execute(pingRequest, callback); } } 

LogWrapper.java

 public interface LogWrapper { void log(String text); } 

अब हमारी गतिविधि के लिए एक लेआउट बनाएँ

activity_main.xml

 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" > <Spinner android:id="@+id/actionTypeSP" android:layout_width="match_parent" android:layout_height="wrap_content" android:layout_alignParentLeft="true" /> <Button android:id="@+id/runBtn" android:layout_width="match_parent" android:layout_height="wrap_content" android:layout_alignParentLeft="true" android:layout_below="@+id/actionTypeSP" android:text="Run" /> <ScrollView android:id="@+id/scroller" android:layout_width="match_parent" android:layout_height="match_parent" android:layout_below="@+id/runBtn" android:background="#FFFFFF" > <TextView android:id="@+id/logView" android:layout_width="match_parent" android:layout_height="wrap_content" android:layout_margin="3dp" android:scrollHorizontally="false" android:scrollbars="vertical" android:textSize="15sp" /> </ScrollView> </RelativeLayout> 

ठीक है, गतिविधि का कोड

MainActivity.java

 import android.app.Activity; import android.os.Bundle; import android.view.Menu; import android.view.View; import android.view.View.OnClickListener; import android.widget.ArrayAdapter; import android.widget.Button; import android.widget.ScrollView; import android.widget.Spinner; import android.widget.TextView; public class MainActivity extends Activity { enum ActionType { BASIC_STRING_OBJECT("Basic Object Send/Receive"), BASIC_ARRAYLIST_OBJECT("Basic ArrayList Send/Receive"), NULL_SUB_OBJECT("Null argument Send/Receive"), NULL_OBJECT("Null Receive"), EXCEPTION("Remote Exception") ; String description; ActionType(String description) { this.description = description; } @Override public String toString() { return description; } } Spinner actionTypeSP; TextView logView; ScrollView scroller; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); init(); } void init() { initActionList(); logView = (TextView) findViewById(R.id.logView); scroller = (ScrollView) findViewById(R.id.scroller); initRunButton(); } void initActionList() { actionTypeSP = (Spinner) findViewById(R.id.actionTypeSP); ArrayAdapter<ActionType> dataAdapter = new ArrayAdapter<ActionType>( this, android.R.layout.simple_spinner_item, ActionType.values()); dataAdapter .setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); actionTypeSP.setAdapter(dataAdapter); } void initRunButton() { Button runBtn = (Button) findViewById(R.id.runBtn); final LogWrapper log = new LogWrapper() { @Override public void log(String text) { MainActivity.this.log(text); } }; runBtn.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { ActionType actionType = (ActionType) actionTypeSP .getSelectedItem(); if (actionType != null) { switch (actionType) { case BASIC_STRING_OBJECT: RPCUtils.runBasicStringTest(log); break; case BASIC_ARRAYLIST_OBJECT: RPCUtils.runBasicListTest(log); break; case EXCEPTION: RPCUtils.runExceptionTest(log); break; case NULL_OBJECT: RPCUtils.runNullObjectTest(log); break; case NULL_SUB_OBJECT: RPCUtils.runNullSubObjectTest(log); break; default: break; } } } }); } void log(String str) { String text = logView.getText().toString(); text += str + "\n"; logView.setText(text); scroller.smoothScrollTo(0, logView.getBottom()); } @Override public boolean onCreateOptionsMenu(Menu menu) { getMenuInflater().inflate(R.menu.activity_main, menu); return true; } } 

इसके अलावा हमारे आवेदन के लिए इंटरनेट का उपयोग करने की अनुमति जोड़ना न भूलें

AndroidManifest.xml

 <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="net.customware.http.dispatch.test.client.android" android:versionCode="1" android:versionName="1.0" > <uses-sdk android:minSdkVersion="8" android:targetSdkVersion="15" /> <uses-permission android:name="android.permission.INTERNET"/> <application android:icon="@drawable/ic_launcher" android:label="@string/app_name" android:theme="@style/AppTheme" > <activity android:name=".MainActivity" android:label="@string/title_activity_main" > <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> </application> </manifest> 

परिणाम इस तरह दिखेगा:



आपको ऊपरी क्षेत्र में कार्रवाई के प्रकार का चयन करने की आवश्यकता है और फिर रन बटन पर क्लिक करें। एप्लिकेशन सर्वर को एक कमांड भेजेगा और परिणाम लॉग में प्रदर्शित होगा। उपलब्ध क्रियाएं: एक परीक्षण स्ट्रिंग भेजें, एक प्रकार का ऑब्जेक्ट भेजें ArrayList <स्ट्रिंग> , अशक्त भेजें, एक अशक्त परिणाम प्राप्त करें और सर्वर पर एक अपवाद फेंक दें।

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

संदर्भ

प्रोजेक्ट पृष्ठ: code.google.com/p/http-dispatch
Android परीक्षण आवेदन: http-dispatch.googlecode.com/files/HTTP_Dispatch_Test_Android.apk
तैयार वार: http-dispatch.googlecode.com/files/HTTP_Dispatch_Test_Server.war
ग्रहण के लिए Android ऐप प्रोजेक्ट:
http-dispatch.googlecode.com/files/HTTP_Dispatch_Test_Android.zip

Gwt -dispatch फ्रेमवर्क: code.google.com/p/gwt-dispatch

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