Come chiamare un servizio web SOAP su Android [chiuso]


553

Ho molti problemi a trovare buone informazioni su come chiamare un servizio web SOAP / WSDL standard con Android. Tutto quello che sono riuscito a trovare sono documenti e riferimenti molto contorti a "kSoap2" e poi un po 'di analisi manuale con SAX . OK, va bene, ma è il 2008, quindi ho pensato che ci dovrebbe essere una buona libreria per chiamare i servizi web standard.

Il servizio web è sostanzialmente uno creato in NetBeans . Vorrei avere il supporto IDE per generare le classi idrauliche. Ho solo bisogno del modo più semplice / elegante per contattare un servizio Web basato su WSDL da un telefono basato su Android.


Ecco un ottimo collegamento sull'uso di SOAP in Android: Come chiamare il servizio Web in Android usando SOAP
Jainendra

Se qualcuno in precedenza aveva familiarità con MS VS, l'uso di Mono per Android risolverà molti problemi con i servizi dati e i servizi Web, tutto è semplice e veloce. Inoltre, chi non ha familiarità con C # (codice molto simile a Java), tutte le librerie hanno gli stessi metodi, alcune funzioni sono state sostituite dalle proprietà, quindi i nomi sono quasi gli stessi e chi ha scritto prima su Java per Android può facilmente usare la propria esperienza per scrivere c # codice.
Eugene Bosikov,

Dai un'occhiata al link qui sotto ha un Eaxample dettagliato sull'accesso a un servizio Web in Android Uso di Ksoap2 Accesso a un servizio
Fred Ondieki

Credo che questo sia possibile con Xamarin / C # usando .Net Core. vedi blogs.msdn.microsoft.com/webdev/2016/05/25/…
Vahid Amiri,

Questo strumento di Spring sembra promettente.
Louis,

Risposte:


245

Android non fornisce alcun tipo di libreria SOAP. Puoi scrivere il tuo o usare qualcosa come kSOAP 2 . Come hai notato, altri sono stati in grado di compilare e utilizzare kSOAP2 nei propri progetti, ma non ho dovuto.

Finora Google ha mostrato scarso interesse per l'aggiunta di una libreria SOAP ad Android. Il mio sospetto per questo è che preferirebbero supportare le attuali tendenze dei servizi Web verso i servizi basati su REST e usare JSON come formato di incapsulamento dei dati. Oppure, usando XMPP per la messaggistica. Ma questa è solo una congettura.

Al momento i servizi Web basati su XML sono un'attività leggermente non banale su Android. Non conoscendo NetBeans, non posso parlare con gli strumenti disponibili lì, ma sono d'accordo che dovrebbe essere disponibile una libreria migliore. È possibile che XmlPullParser ti salverà dall'uso di SAX, ma non ne so molto.


7
Sì, penso che dovrò costruire un proxy REST. Sembra abbastanza strano che Google non abbia interesse a fornire supporto SOAP. Ho provato il metodo kSoap, non è nemmeno un'alternativa seria. È, nella migliore delle ipotesi, una brutta esperienza che richiede molta analisi dei newsgroup.
BobbyShaftoe,

19
Il motivo è probabilmente che SOAP è molto dettagliato e non soddisfa bene i vincoli del mobile computing.
Neil,

92
Questa risposta sarebbe migliorata se qualcuno potesse suggerire la migliore alternativa alla chiamata di servizi Web con un'app Android. Una volta che le persone trovano questa domanda e la leggono, è quello che la maggior parte di loro cercherà.
MGOwen,

4
L'elaborazione SOAP è anche intensiva per memoria e processore rispetto a un formato più conciso come JSON.
Jeremy Edwards

3
@MGOwen La migliore alternativa che posso vedere è un proxy. Implementare un'interfaccia REST che esegua il proxy degli inviluppi SOAP tramite WSDL2Java.

99

org.apache.http.impl.client.DefaultHttpClientviene fornito con Android SDK per impostazione predefinita. Questo ti metterà in contatto con il WSDL.

HttpClient httpClient = new DefaultHttpClient();
HttpContext localContext = new BasicHttpContext();
HttpGet httpGet = new HttpGet("http://www.example.com/" + URL);
HttpResponse response = httpClient.execute(httpGet, localContext);

5
Sì, questo sarebbe il percorso in cui avrei dovuto analizzare manualmente tutto, non avrei avuto un approccio orientato agli oggetti.
BobbyShaftoe,

93
Vuoi dire che non riceveresti un pranzo gratuito. L'analisi manuale non ha nulla a che fare con OO. Potrei analizzare tutto sulla carta con il mio strumento più avanzato che è una matita HB1 e sarebbe ancora OO.
Neil,

8
Credo che per OO l'autore intendesse l'associazione Java-XML. Quale sarebbe il tuo prossimo passo in questo approccio per analizzare la risposta? E se ha centinaia di elementi, organizzati in una struttura ad albero?
Rustyx,

12
A proposito, mi aspetterei almeno un POST HTTP non un GET se vuoi avere fortuna con SOAP. Inoltre, dove sono le intestazioni Accept e SOAPAction? Se vuoi davvero andare in commando ci vorrà molto più di queste 4 linee per consumare un servizio SOAP.
Rustyx,

6
@NeilD: E se fossi stato costretto dalle circostanze a usare SOAP, ad es. Il webserver usa SOAP e non hai il controllo su questo?
Bjarke Freund-Hansen,

59

È vero che a causa del sovraccarico SOAP non è la scelta migliore per lo scambio di dati con dispositivi mobili. Tuttavia, potresti trovarti in una situazione in cui non controlli il formato dell'output del server.

Quindi, se devi rimanere con SOAP, c'è una libreria kSOAP2 patchata per Android qui:
http://code.google.com/p/ksoap2-android/


31

Per chiamare un servizio Web da un dispositivo mobile (specialmente su un telefono Android), ho usato un modo molto semplice per farlo. Non ho utilizzato alcuna API client del servizio Web nel tentativo di chiamare il servizio Web. Il mio approccio è il seguente per effettuare una chiamata.

  1. Creare una semplice connessione HTTP utilizzando l'API standard Java HttpURLConnection.
  2. Formare una richiesta SOAP. (Puoi aiutare SOAPUI a fare una richiesta SOAP.)
  3. Imposta il flag doOutPut su true.
  4. Imposta valori di intestazione HTTP come lunghezza del contenuto, tipo di contenuto e User-agent. Non dimenticare di impostare il valore della lunghezza del contenuto in quanto è obbligatorio.
  5. Scrivi l'intera richiesta SOAP nel flusso di output.
  6. Chiama il metodo per stabilire una connessione e ricevere la risposta (nel mio caso ho usato getResonseCode).
  7. Se il tuo codice di risposta ricevuto come
    1. Significa che sei riuscito a chiamare il servizio web.
  8. Ora prendi un flusso di input sulla stessa connessione HTTP e ricevi l'oggetto stringa. Questo oggetto stringa è una risposta SOAP.
  9. Se il codice di risposta è diverso da 200, prendere uno ErrorInputstream sullo stesso oggetto HTTP e ricevere l'eventuale errore.
  10. Analizzare la risposta ricevuta utilizzando SAXParser (nel mio caso) o DOMParaser o qualsiasi altro meccanismo di analisi.

Ho implementato questa procedura per il telefono Android e funziona correttamente. Sono in grado di analizzare la risposta anche se supera i 700 KB.


30

SOAP è una tecnologia inadatta per l'uso su Android (o dispositivi mobili in generale) a causa del sovraccarico di elaborazione / analisi richiesto. Un servizio REST è una soluzione più leggera ed è quello che suggerirei. Android viene fornito con un parser SAX ed è abbastanza banale da usare. Se sei assolutamente tenuto a gestire / analizzare SOAP su un dispositivo mobile, mi dispiace per te, il miglior consiglio che posso offrire è semplicemente di non usare SOAP.


2
C'è un posto speciale all'inferno per coloro che costringono gli sviluppatori a usare i servizi SOAP invece dell'API REST.
Hitesh Sahu,

24

Circa un anno fa stavo leggendo questo thread cercando di capire come effettuare chiamate SOAP su Android: i suggerimenti per creare le mie utilizzando HttpClient mi hanno portato a costruire la mia libreria SOAP per Android:

IceSoap

Fondamentalmente ti consente di creare buste da inviare tramite una semplice API Java, quindi analizzarle automaticamente in oggetti definiti tramite XPath ... ad esempio:

<Dictionary>
    <Id></Id>
    <Name></Name>
</Dictionary>

diventa:

@XMLObject("//Dictionary")
public class Dictionary {
    @XMLField("Id")
    private String id;

    @XMLField("Name")
    private String name;
}

Lo stavo usando per il mio progetto ma ho pensato che potesse aiutare alcune altre persone, quindi ho trascorso un po 'di tempo a separarlo e documentarlo. Mi piacerebbe davvero che alcune delle tue povere anime che si imbattessero in questa discussione mentre cercavano su Google "SOAP Android" un tentativo e ottenere qualche beneficio.


hai lavorato con la sessione di autenticazione su IceSoap?
Adnen Chouibi,

24

NON DIMENTICARE DI AGGIUNGERE ksoap2.jar nel progetto e aggiungere anche l'autorizzazione INTERNET nel file AndroidManifest

import org.ksoap2.SoapEnvelope;
import org.ksoap2.serialization.PropertyInfo;
import org.ksoap2.serialization.SoapObject;
import org.ksoap2.serialization.SoapPrimitive;
import org.ksoap2.serialization.SoapSerializationEnvelope;
import org.ksoap2.transport.HttpTransportSE;
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;

public class WebserviceActivity extends Activity {

    private static final String NAMESPACE = "https://api.authorize.net/soap/v1/";
    private static final String URL ="https://apitest.authorize.net/soap/v1/Service.asmx?wsdl"; 
    private static final String SOAP_ACTION = "https://api.authorize.net/soap/v1/AuthenticateTest";
    private static final String METHOD_NAME = "AuthenticateTest";
    private TextView lblResult;


    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        lblResult = (TextView) findViewById(R.id.tv);

        SoapObject request = new SoapObject(NAMESPACE, METHOD_NAME); 
        request.addProperty("name","44vmMAYrhjfhj66fhJN");
        request.addProperty("transactionKey","9MDQ7fghjghjh53H48k7e7n");
        SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11); 
        envelope.setOutputSoapObject(request);
        HttpTransportSE androidHttpTransport = new HttpTransportSE(URL);
        try {
            androidHttpTransport.call(SOAP_ACTION, envelope);

            //SoapPrimitive  resultsRequestSOAP = (SoapPrimitive) envelope.getResponse();
            // SoapPrimitive  resultsRequestSOAP = (SoapPrimitive) envelope.getResponse();
            SoapObject resultsRequestSOAP = (SoapObject) envelope.bodyIn;


            lblResult.setText(resultsRequestSOAP.toString());
            System.out.println("Response::"+resultsRequestSOAP.toString());


        } catch (Exception e) {
            System.out.println("Error"+e);
        }

    }
}

HttpTransportSE dove posso ottenere questa classe ??
Noman,

Ciao, sto usando il tuo codice ma sto ottenendo il seguente errore, Response :: AuthenticateTestResponse {AuthenticateTestResult = anyType {resultCode = Error; messaggi = {anyType MessagesTypeMessage = anyType {codice = E00014; text = È richiesta l'autenticazione del commerciante .; }; }; }; } Mi potete aiutare per favore?
Hasmukh,

ciao Amit im amit ..... Puoi dirmi come confrontare la risposta quando abbiamo ottenuto la risposta ha esito positivo oppure no come e quali condizioni verificare la risposta ......
Amitsharma

come aggiungere un array in xml della proprietà request?
droidster.me,

21

Ho provato con KSOAP; Ho scelto un approccio piuttosto semplice.

Dato un file WSDL, creare modelli di richiesta SOAP per ciascuna richiesta (ad esempio: utilizzando l'interfaccia utente SOAP) e quindi sostituire i valori da passare nel codice. POST questi dati all'endpoint del servizio utilizzando l'istanza DefaultHttpClient e ottenere il flusso di risposta. Analizzare il flusso di risposta utilizzando un parser XML Pull.


18

Puoi dare un'occhiata a WSClient ++


4
Finalmente una prima risposta utile dopo aver ripetuto kSoap o SAX
rustyx

Ho provato la versione demo. Non ha funzionato per me per un servizio semplice. Non vale la pena spendere così tanti $$$$$.
Tushar,

16

Ho creato un nuovo client SOAP per la piattaforma Android. Sta utilizzando un'interfaccia generata da JAX-WS, ma finora è solo una prova di concetto.

Se sei interessato, prova l'esempio e / o guarda la fonte su AndroidSOAP .


1
Ho avuto il piacere di assistere alla tua presentazione al JUM XVII. Budapest su questa roba Android. Continua così!
pcjuzer,

15

Se puoi, scegli JSON. Android viene fornito con il pacchetto org.json completo


14

Chiama ksoap2 metodi . Funziona molto bene.

Imposta i dettagli, ad esempio

private static String mNAMESPACE=null;
private static String mURL=null;
public static Context context=null;
SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);
envelope.dotNet = true;
envelope.setOutputSoapObject(Request);

envelope.addMapping(mNAMESPACE, "UserCredentials",new UserCredendtials().getClass());
AndroidHttpTransport androidHttpTransport = new AndroidHttpTransport(mURL);

e poi per ottenere il risultato fare

androidHttpTransport.call(SOAP_ACTION, envelope);
result = (SoapPrimitive)envelope.getResponse();


11

Pochi mesi fa stavo lavorando con il servizio web jax-ws nell'applicazione j2ee, lì stavamo usando CXF wsdl2java per generare lo stub client WS dal file WSDL e con quegli stub client abbiamo consumato i servizi web. Poche settimane fa, quando stavo cercando di consumare il servizio web allo stesso modo nella piattaforma Android, non potevo, perché il vaso Android non ha tutte le classi di supporto "jax-ws" al suo interno. Quella volta non ho trovato nessuno di questi strumenti (se non fossi riuscito a utilizzare Google in modo efficiente) per soddisfare le mie esigenze -

  • Ottieni lo stub client dal WSDL.
  • E chiama il servizio con qualche argomento (oggetto richiesta business java).
  • Ottieni l'oggetto business Response.

Quindi, ho sviluppato il mio strumento di generazione client SOAP Android . Dove devi seguire questi passaggi:

  • Da WSDL Ottieni stub client WS, inseriscilo nel tuo progetto.
  • Dire per alcuni servizi "ComplexOperationService", creare un'istanza del servizio, ottenere la porta dell'endpoint e chiamare il metodo di servizio e ottenere la risposta dal servizio Web:

per esempio:

ComplexOperationService service = new ComplexOperationService( );
ComplexOperation port= service.getComplexOperationPort();    
SomeComplexRequest request = --Get some complex request----;    
SomeComplexResp resp = port.operate( request  );
  • Non è necessario preoccuparsi della classe di servizio / req / classi di risposta o di qualsiasi altra classe e del metodo, poiché si sa che tutto è generato da WSDL.
  • E ovviamente non è necessario essere consapevoli dell'azione soap / envelope / namespace ecc. Basta chiamare il metodo come noi, gli sviluppatori facciamo sempre.

Sai come gestire la data? Apache CXF lo traduce in XMLGregorianCalendar che non sono in grado di creare in Android.
Martin Nuc,



6

Seguire questi passaggi con il metodo SOAP

Dal file WSDL,

  • creare modelli di richieste SOAP per ogni richiesta.

  • Quindi sostituire i valori da passare nel codice.

  • POST questi dati all'end point del servizio utilizzando l'istanza DefaultHttpClient.

  • Ottieni il flusso di risposta e infine

  • Analizzare il flusso di risposta utilizzando un parser XML Pull.



6

Per me il modo più semplice è usare un buon strumento per generare tutte le classi richieste. Personalmente utilizzo questo sito:

http://easywsdl.com/

Supporta servizi web abbastanza complessi e usa ksoap2.


5

Suggerirei di provare uno strumento molto utile che mi ha aiutato molto. Anche i ragazzi che si occupano di quel progetto sono stati di grande aiuto. www.wsdl2code.com/


5

In caso di problemi con la chiamata al servizio Web in Android, è possibile utilizzare il codice seguente per chiamare il servizio Web e ottenere risposta. Assicurati che il tuo servizio web restituisca la risposta in formato tabella dati. Questo codice ti aiuterà se utilizzi i dati dal database di SQL Server . Se usi MYSQL devi cambiare una cosa semplicemente sostituendo la parola NewDataSet dalla frase obj2=(SoapObject) obj1.getProperty("NewDataSet");di DocumentElement

void callWebService(){ 

private static final String NAMESPACE = "http://tempuri.org/"; // for wsdl it may be package name i.e http://package_name
private static final String URL = "http://localhost/sample/services/MyService?wsdl";
// you can use IP address instead of localhost
private static final String METHOD_NAME = "Function_Name";
private static final String SOAP_ACTION = "urn:" + METHOD_NAME;

    SoapObject request = new SoapObject(NAMESPACE, METHOD_NAME);
    request.addProperty("parm_name", prm_value);// Parameter for Method
    SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);
    envelope.dotNet = true;// **If your Webservice in .net otherwise remove it**
    envelope.setOutputSoapObject(request);
    HttpTransportSE androidHttpTransport = new HttpTransportSE(URL);

    try {
        androidHttpTransport.call(SOAP_ACTION, envelope);// call the eb service
                                                                                                         // Method
    } catch (Exception e) {
        e.printStackTrace();
    }

    // Next task is to get Response and format that response
    SoapObject obj, obj1, obj2, obj3;
    obj = (SoapObject) envelope.getResponse();
    obj1 = (SoapObject) obj.getProperty("diffgram");
    obj2 = (SoapObject) obj1.getProperty("NewDataSet");

    for (int i = 0; i < obj2.getPropertyCount(); i++) { 
// the method getPropertyCount() and  return the number of rows
            obj3 = (SoapObject) obj2.getProperty(i);
            obj3.getProperty(0).toString();// value of column 1
            obj3.getProperty(1).toString();// value of column 2
            // like that you will get value from each column
        }
    }

Se hai qualche problema a riguardo puoi scrivermi ..


4

Scaricare e aggiungere il file della libreria SOAP con il nome del file del progetto: ksoap2-android-assembly-3.4.0-jar-with-dependencies

Pulisci l'applicazione e quindi avvia il programma

Ecco il codice per la chiamata al servizio SOAP

    String SOAP_ACTION = "YOUR_ACTION_NAME";
    String METHOD_NAME = "YOUR_METHOD_NAME";
    String NAMESPACE = "YOUR_NAME_SPACE";
    String URL = "YOUR_URL";
    SoapPrimitive resultString = null;

    try {
        SoapObject Request = new SoapObject(NAMESPACE, METHOD_NAME);
        addPropertyForSOAP(Request);

        SoapSerializationEnvelope soapEnvelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);
        soapEnvelope.dotNet = true;
        soapEnvelope.setOutputSoapObject(Request);

        HttpTransportSE transport = new HttpTransportSE(URL);

        transport.call(SOAP_ACTION, soapEnvelope);
        resultString = (SoapPrimitive) soapEnvelope.getResponse();

        Log.i("SOAP Result", "Result Celsius: " + resultString);
    } catch (Exception ex) {
        Log.e("SOAP Result", "Error: " + ex.getMessage());
    }
    if(resultString != null) {
        return resultString.toString();
    }
    else{
        return "error";
    }

I risultati possono essere JSONObject o JSONArray o String

Per una migliore consultazione, https://trinitytuts.com/load-data-from-soap-web-service-in-android-application/

Grazie.


3

Questo è un esempio funzionante di consumo di servizi web SOAP in Android.

** Nota :: *** NON DIMENTICARE DI AGGIUNGERE ksoap2.jar nel progetto e aggiungere anche l'autorizzazione INTERNET nel file AndroidManifest *

public final String WSDL_TARGET_NAMESPACE = "http://tempuri.org/";
public final String METHOD_NAME = "FahrenheitToCelsius";
public final String PROPERTY_NAME = "Fahrenheit";
public final String SOAP_ACTION = "http://tempuri.org/FahrenheitToCelsius";
public final String SOAP_ADDRESS = "http://www.w3schools.com/webservices/tempconvert.asmx";


private class TestAsynk extends AsyncTask<String, Void, String> {

    @Override
    protected void onPostExecute(String result) {

        super.onPostExecute(result);
        Toast.makeText(getApplicationContext(),
                String.format("%.2f", Float.parseFloat(result)),
                Toast.LENGTH_SHORT).show();
    }

    @Override
    protected String doInBackground(String... params) {
        SoapObject request = new SoapObject(WSDL_TARGET_NAMESPACE,
                METHOD_NAME);
        request.addProperty(PROPERTY_NAME, params[0]);

        SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(
                SoapEnvelope.VER11);
        envelope.dotNet = true;

        envelope.setOutputSoapObject(request);

        HttpTransportSE androidHttpTransport = new HttpTransportSE(
                SOAP_ADDRESS);
        Object response = null;
        try {

            androidHttpTransport.call(SOAP_ACTION, envelope);
            response = envelope.getResponse();
            Log.e("Object response", response.toString());

        } catch (Exception e) {
            e.printStackTrace();
        }
        return response.toString();
    }
}


3

È possibile eseguire chiamate soap come post su http con determinate intestazioni. Ho risolto questa domanda senza librerie aggiuntive come ksoap2 Ecco il codice live che ottiene gli ordini dal servizio soap

private static HashMap<String,String> mHeaders = new HashMap<>();

static {
    mHeaders.put("Accept-Encoding","gzip,deflate");
    mHeaders.put("Content-Type", "application/soap+xml");
    mHeaders.put("Host", "35.15.85.55:8080");
    mHeaders.put("Connection", "Keep-Alive");
    mHeaders.put("User-Agent","AndroidApp");
    mHeaders.put("Authorization","Basic Q2xpZW50NTkzMzppMjR3s2U="); // optional
}public final static InputStream receiveCurrentShipments(String stringUrlShipments)
{
    int status=0;
    String xmlstring= "<soap:Envelope xmlns:soap=\"http://www.w3.org/2003/05/soap-envelope\" xmlns:ser=\"http://35.15.85.55:8080/ServiceTransfer\">\n" +
            "   <soap:Header/>\n" +
            "   <soap:Body>\n" +
            "      <ser:GetAllOrdersOfShipment>\n" +
            "         <ser:CodeOfBranch></ser:CodeOfBranch>\n" +
            "      </ser:GetAllOrdersOfShipment>\n" +
            "   </soap:Body>\n" +
            "</soap:Envelope>";
    StringBuffer chaine = new StringBuffer("");

    HttpURLConnection connection = null;
    try {
        URL url = new URL(stringUrlShipments);
        connection = (HttpURLConnection) url.openConnection();
        connection.setRequestProperty("Content-Length", xmlstring.getBytes().length + "");
        connection.setRequestProperty("SOAPAction", "http://35.15.85.55:8080/ServiceTransfer/GetAllOrdersOfShipment");

        for(Map.Entry<String, String> entry : mHeaders.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            connection.setRequestProperty(key,value);

        }

        connection.setRequestMethod("POST");
        connection.setDoInput(true);

        OutputStream outputStream = connection.getOutputStream();
        outputStream.write(xmlstring.getBytes("UTF-8"));
        outputStream.close();

        connection.connect();
        status = connection.getResponseCode();
    } catch (ProtocolException e) {
        e.printStackTrace();
    } catch (MalformedURLException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {

        Log.i("HTTP Client", "HTTP status code : " + status);
    }

    InputStream inputStream = null;
    try {
        inputStream = connection.getInputStream();
    } catch (IOException e) {
        e.printStackTrace();
    }

    return inputStream;
}


due domande su questo: 1. Come viene chiamato dall'attività principale? 2. Quale dovrebbe essere il valore di StringUrlShipment passato come parametro?
Tori,

nel commento sopra, ignora la domanda n. 1.
Tori,

Dall'attività principale è necessario utilizzare AsyncTask per chiamare questo codice. All'interno di questa classe AsyncTask implementare doInBackground per lanciare questo codice
Lapenkov Vladimir

2

Per chiamare un servizio Web SOAP da Android, prova a utilizzare questo client

NON DIMENTICARE DI AGGIUNGERE ksoap2-android.jar nel tuo percorso di build java

public class WsClient {
    private static final String SOAP_ACTION = "somme";
    private static final String OPERATION_NAME = "somme";
    private static final String WSDL_TARGET_NAMESPACE = "http://example.ws";
    private static final String SOAP_ADDRESS = "http://192.168.1.2:8080/axis2/services/Calculatrice?wsdl";

    public String caclculerSomme() {

        String res = null;
        SoapObject request = new SoapObject(WSDL_TARGET_NAMESPACE,
                OPERATION_NAME);
        request.addProperty("a", "5");
        request.addProperty("b", "2");

        SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(
                SoapEnvelope.VER11);
        envelope.dotNet = true;
        envelope.setOutputSoapObject(request);
        HttpTransportSE httpTransport = new HttpTransportSE(SOAP_ADDRESS);

        try {
            httpTransport.call(SOAP_ACTION, envelope);
            String result = envelope.getResponse().toString();
            res = result;
            System.out.println("############# resull is :" + result);
        } catch (Exception exception) {
            System.out.println("########### ERRER" + exception.getMessage());
        }

        return res;
    }
}

@ Wajdi hh come confrontare la risposta di risposta dal risultato della risposta del donatore: - successo ..... "responce = 1 ~ Successfull .... .... quindi come confrontiamo quel risultato da una condizione che è dal lato del server ...... ..
Amitsharma,

1

Aggiungi Soap Libaray (ksoap2-android-assembly-3.2.0-jar-with-dependencies.jar ):

public static String Fn_Confirm_CollectMoney_Approval (

        HashMap < String, String > str1,
        HashMap < String, String > str2,
        HashMap < String, String > str3) {

    Object response = null;
    String METHOD_NAME = "CollectMoney";
    String NAMESPACE = "http://xxx/yyy/xxx";
    String URL = "http://www.w3schools.com/webservices/tempconvert.asmx";
    String SOAP_ACTION = "";

    try {

        SoapObject RequestParent = new SoapObject(NAMESPACE, METHOD_NAME);

        SoapObject Request1 = new SoapObject(NAMESPACE, "req");

        PropertyInfo pi = new PropertyInfo();

        Set mapSet1 = (Set) str1.entrySet();

        Iterator mapIterator1 = mapSet1.iterator();

        while (mapIterator1.hasNext()) {

            Map.Entry mapEntry = (Map.Entry) mapIterator1.next();

            String keyValue = (String) mapEntry.getKey();

            String value = (String) mapEntry.getValue();

            pi = new PropertyInfo();

            pi.setNamespace("java:com.xxx");

            pi.setName(keyValue);

            pi.setValue(value);

            Request1.addProperty(pi);
        }

        mapSet1 = (Set) str3.entrySet();

        mapIterator1 = mapSet1.iterator();

        while (mapIterator1.hasNext()) {

            Map.Entry mapEntry = (Map.Entry) mapIterator1.next();

            // getKey Method of HashMap access a key of map
            String keyValue = (String) mapEntry.getKey();

            // getValue method returns corresponding key's value
            String value = (String) mapEntry.getValue();

            pi = new PropertyInfo();

            pi.setNamespace("java:com.xxx");

            pi.setName(keyValue);

            pi.setValue(value);

            Request1.addProperty(pi);
        }

        SoapObject HeaderRequest = new SoapObject(NAMESPACE, "XXX");

        Set mapSet = (Set) str2.entrySet();

        Iterator mapIterator = mapSet.iterator();

        while (mapIterator.hasNext()) {

            Map.Entry mapEntry = (Map.Entry) mapIterator.next();

            // getKey Method of HashMap access a key of map
            String keyValue = (String) mapEntry.getKey();

            // getValue method returns corresponding key's value
            String value = (String) mapEntry.getValue();

            pi = new PropertyInfo();

            pi.setNamespace("java:com.xxx");

            pi.setName(keyValue);

            pi.setValue(value);

            HeaderRequest.addProperty(pi);
        }

        Request1.addSoapObject(HeaderRequest);

        RequestParent.addSoapObject(Request1);

        SoapSerializationEnvelope soapEnvelope = new SoapSerializationEnvelope(
                SoapEnvelope.VER10);

        soapEnvelope.dotNet = false;

        soapEnvelope.setOutputSoapObject(RequestParent);

        HttpTransportSE transport = new HttpTransportSE(URL, 120000);

        transport.debug = true;

        transport.call(SOAP_ACTION, soapEnvelope);

        response = (Object) soapEnvelope.getResponse();

        int cols = ((SoapObject) response).getPropertyCount();

        Object objectResponse = (Object) ((SoapObject) response)
                .getProperty("Resp");

        SoapObject subObject_Resp = (SoapObject) objectResponse;


        modelObject = new ResposeXmlModel();

        String MsgId = subObject_Resp.getProperty("MsgId").toString();


        modelObject.setMsgId(MsgId);

        String OrgId = subObject_Resp.getProperty("OrgId").toString();


        modelObject.setOrgId(OrgId);

        String ResCode = subObject_Resp.getProperty("ResCode").toString();


        modelObject.setResCode(ResCode);

        String ResDesc = subObject_Resp.getProperty("ResDesc").toString();


        modelObject.setResDesc(ResDesc);

        String TimeStamp = subObject_Resp.getProperty("TimeStamp")
                .toString();


        modelObject.setTimestamp(ResDesc);

        return response.toString();

    } catch (Exception ex) {

        ex.printStackTrace();

        return null;
    }

}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.