Comment appeler un service Web SOAP sur Android
J'ai beaucoup de mal à trouver de bonnes informations sur la procédure à suivre pour appeler un service Web SOAP/WSDL standard avec Android. Tout ce que j'ai pu trouver, ce sont des documents très compliqués et des références à "kSoap2", puis quelques informations sur l'analyse syntaxique manuelle avec SAX . D'accord, c'est bien, mais nous sommes en 2008, j'ai donc pensé qu'il devrait exister une bonne bibliothèque pour appeler des services Web standard.
Le service Web est simplement créé dans NetBeans . J'aimerais avoir le support IDE pour générer les classes de plomberie. J'ai juste besoin du moyen le plus simple et le plus élégant de contacter un service Web WSDL à partir d'un téléphone Android.
Android ne fournit aucune sorte de bibliothèque SOAP. Vous pouvez écrire le vôtre ou utiliser quelque chose comme kSOAP 2 . Comme vous le constatez, d’autres ont été capables de compiler et d’utiliser kSOAP2 dans leurs propres projets, mais je n’ai pas eu à le faire.
À ce jour, Google a montré peu d’intérêt pour l’ajout d’une bibliothèque SOAP à Android. Je soupçonne qu'ils préfèrent prendre en charge les tendances actuelles des services Web en faveur de services basés sur REST et utiliser JSON comme format d'encapsulation de données. Ou, en utilisant XMPP pour la messagerie. Mais ce n'est que conjecture.
Les services Web basés sur XML sont une tâche légèrement non triviale sur Android pour le moment. Ne connaissant pas NetBeans, je ne peux parler des outils disponibles sur ce site, mais je conviens qu'une meilleure bibliothèque devrait être disponible. Il est possible que XmlPullParser vous évite d'utiliser SAX, mais je ne connais pas grand chose à ce sujet.
org.Apache.http.impl.client.DefaultHttpClient est inclus dans le Android SDK par défaut. Cela vous permettra de vous connecter au WSDL.
HttpClient httpClient = new DefaultHttpClient();
HttpContext localContext = new BasicHttpContext();
HttpGet httpGet = new HttpGet("http://www.example.com/" + URL);
HttpResponse response = httpClient.execute(httpGet, localContext);
Il est vrai qu'en raison de sa surcharge, SOAP n'est pas le meilleur choix pour l'échange de données avec des appareils mobiles. Cependant, vous pourriez vous retrouver dans une situation dans laquelle vous ne contrôlez pas le format de la sortie du serveur.
Donc, si vous devez vous en tenir à SOAP, il existe une bibliothèque kSOAP2 corrigée pour Android ici:
http://code.google.com/p/ksoap2-Android/
Pour appeler un service Web à partir d'un appareil mobile (en particulier sur un téléphone Android), j'ai utilisé un moyen très simple de le faire. Je n'ai pas utilisé d'API client de service Web pour tenter d'appeler le service Web. Mon approche est la suivante pour passer un appel.
- Créez une connexion HTTP simple à l'aide de l'API standard Java _
HttpURLConnection. - Former une demande SOAP. (Vous pouvez faire appel à SOAPUI pour faire une demande SOAP.)
- Définissez l'indicateur doOutPut sur true.
- Définissez les valeurs d'en-tête HTTP telles que longueur-contenu, type de contenu et agent-utilisateur. N'oubliez pas de définir la valeur Content-length car il s'agit d'un élément obligatoire.
- Écrivez toute la demande SOAP dans le flux de sortie.
- Appelez la méthode pour établir une connexion et recevoir la réponse (dans mon cas, j'ai utilisé
getResonseCode). - Si votre code de réponse reçu est
- Cela signifie que vous avez réussi à appeler le service Web.
- Maintenant, prenez un flux d'entrée sur la même connexion HTTP et recevez l'objet string. Cet objet chaîne est une réponse SOAP.
- Si le code de réponse est différent de 200, prenez un flux
ErrorInputsur le même objet HTTP et recevez le cas échéant l'erreur. - Analyser la réponse reçue à l'aide de SAXParser (dans mon cas) ou de DOMParaser ou de tout autre mécanisme d'analyse.
J'ai mis en œuvre cette procédure pour le téléphone Android et il fonctionne correctement. Je suis capable d'analyser la réponse même si elle dépasse 700 Ko.
SOAP est une technologie inadaptée pour une utilisation sur Android (ou les appareils mobiles en général) en raison de la charge de traitement/d'analyse requise. Un REST services est une solution plus légère et c'est ce que je suggérerais. Android est fourni avec un analyseur SAX, et son utilisation est relativement simple. Si vous devez absolument manipuler/analyser SOAP sur un appareil mobile, je suis désolé pour vous, le meilleur conseil que je puisse vous donner est simplement de ne pas utiliser SOAP.
Il y a environ un an, je lisais ce fil pour essayer de comprendre comment faire SOAP appels sur Android - les suggestions de création du mien à l'aide de HttpClient m'ont amené à construire mon propre SOAP bibliothèque pour Android:
En gros, il vous permet de créer des enveloppes à envoyer via une simple API Java, puis de les analyser automatiquement dans des objets que vous définissez via XPath ... par exemple:
<Dictionary>
<Id></Id>
<Name></Name>
</Dictionary>
Devient:
@XMLObject("//Dictionary")
public class Dictionary {
@XMLField("Id")
private String id;
@XMLField("Name")
private String name;
}
Je l'utilisais pour mon propre projet, mais j'ai pensé que cela pourrait aider d'autres personnes. J'ai donc passé un certain temps à le séparer et à le documenter. J'aimerais vraiment que certains de vos pauvres âmes qui trébuchent sur ce fil en recherchant "SOAP Android" sur Google puissent l'essayer et en retirer un bénéfice.
N'OUBLIEZ PAS D'AJOUTER ksoap2.jar dans votre projet et d'ajouter également l'autorisation INTERNET dans le fichier 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);
}
}
}
J'ai eu mon rendez-vous avec KSOAP; J'ai choisi une approche plutôt simple.
Avec un fichier WSDL, créez SOAP modèles de demande pour chaque demande (par exemple: en utilisant SOAP UI), puis remplacez les valeurs à transmettre dans le code. POST ces données au point de terminaison du service à l'aide de l'instance DefaultHttpClient et obtenir le flux de réponse. Analyser le flux de réponses à l'aide d'un analyseur XML Pull.
Vous pouvez jeter un oeil à NSClient ++
J'ai créé un nouveau client SOAP pour la plate-forme Android. Il utilise une interface générée par JAX-WS, mais ce n’est pour l’instant qu’une preuve de concept.
Si cela vous intéresse, veuillez essayer l’exemple et/ou regarder la source sur AndroidSOAP .
Si vous le pouvez, optez pour JSON. Android est fourni avec le package complet org.json
Appelez ksoap2 méthodes. Cela fonctionne très bien.
Configurez les détails, comme
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);
et ensuite pour obtenir le résultat faire
androidHttpTransport.call(SOAP_ACTION, envelope);
result = (SoapPrimitive)envelope.getResponse();
J'espère Appeler un service Web depuis Android aide.
Il y a quelques mois, je travaillais avec le service Web jax-ws dans l'application j2ee. Nous utilisions là CXF wsdl2Java pour générer un stub client WS à partir du fichier WSDL et des stubs clients utilisés par les services Web. Il y a quelques semaines, lorsque j'essayais de consommer le service Web de la même manière sur la plate-forme Android, je ne pouvais pas le faire, car le fichier jar Android ne comporte pas tous les "jax-ws". classes de soutien en elle. Cette fois, je n'ai trouvé aucun outil de ce type (si je ne manquais pas de google efficacement) pour répondre à mes besoins -
- Obtenez le stub client à partir du WSDL.
- Et appelez le service avec un argument (objet de requête métier Java).
- Obtenez l'objet de gestion Response.
J'ai donc développé mon propre Android SOAP Outil de génération de client . Où vous devez suivre ces étapes:
- À partir de WSDL Get WS Client Stub, insérez-le dans votre projet.
- Dites pour certains services "ComplexOperationService", instanciez le service, obtenez le port du point de terminaison et appelez la méthode de service, puis obtenez la réponse du service Web:
par exemple:
ComplexOperationService service = new ComplexOperationService( );
ComplexOperation port= service.getComplexOperationPort();
SomeComplexRequest request = --Get some complex request----;
SomeComplexResp resp = port.operate( request );
- Vous n'avez pas besoin de vous soucier des classes de service/req/response ou de toute autre classe et de la méthode, car vous savez que tout est généré à partir de WSDL.
- Et bien sûr, vous n'avez pas besoin de connaître l'action/l'enveloppe/l'espace de noms de soap, etc. Appelez simplement la méthode comme nous, les développeurs, le faisons tout le temps.
Je suis sûr que vous pourriez créer un petit client SOAP avec Axis . Instructions d'installation Axis .
Je pense que Appelez SOAP Web Service à partir de Android application vous aidera lot.
Pour moi, le moyen le plus simple est d'utiliser un bon outil pour générer toutes les classes requises. Personnellement j'utilise ce site:
Il supporte des services Web assez complexes et utilise ksoap2.
Suivez ces étapes par la méthode SOAP
A partir du fichier WSDL,
créer SOAP modèles de demande pour chaque demande.
Remplacez ensuite les valeurs à transmettre dans le code.
POST ces données au noeud final du service à l'aide de l'instance DefaultHttpClient.
Obtenez le flux de réponse et enfin
Analyser le flux de réponses à l'aide d'un analyseur XML Pull.
Je suggérerais de vérifier un outil très utile qui m'a beaucoup aidé. Les gars qui s'occupent de ce projet ont également été très utiles. www.wsdl2code.com/
Si vous rencontrez des problèmes pour appeler le service Web dans Android, vous pouvez utiliser le code ci-dessous pour appeler le service Web et obtenir une réponse. Assurez-vous que votre service Web renvoie la réponse dans le format Format du tableau de données .. Ce code vous aidera si vous utilisez des données provenant de la base de données SQL Server. Si vous utilisez MYSQL vous devez changer quelque chose, remplacez simplement Word NewDataSet de la phrase obj2=(SoapObject) obj1.getProperty("NewDataSet"); par 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
}
}
Si vous avez un problème à ce sujet, vous pouvez m'écrire ..
Veuillez télécharger et ajouter le fichier de bibliothèque SOAP avec votre projet. Nom du fichier: ksoap2-Android-Assembly-3.4.0-jar-with-dependencies
Nettoyer l'application et ensuite démarrer le programme
Voici le code de l'appel de service 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";
}
Les résultats peuvent être JSONObject ou JSONArray ou String.
Pour votre meilleure référence, https://trinitytuts.com/load-data-from-soap-web-service-in-Android-application/
Merci.
Ceci est un exemple de travail de la consommation de SOAP services Web sous Android.
** Remarque :: *** N'OUBLIEZ PAS D'AJOUTER ksoap2.jar dans votre projet et d'ajouter également l'autorisation INTERNET dans le fichier 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();
}
}
Vous pouvez effectuer un appel de savon comme post sur http avec certains en-têtes. J'ai résolu cette question sans bibliothèques supplémentaires comme ksoap2. Voici du code en direct qui reçoit les commandes du service 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;
}
Pour appeler un service Web SOAP à partir de Android, essayez d'utiliser ce client.
N'OUBLIEZ PAS D'AJOUTER ksoap2-Android.jar dans votre chemin de construction 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;
}
}
Ajouter une bibliothèque de savon (ksoap2-Android-Assembly-3.2.0-jar-with-dependencies.jar):
public statique String Fn_Confirm_Collect Money 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;
}
}