Comment appeler un service Web RESTful à partir d'Android?
J'ai écrit un service Web REST dans Netbean IDE à l'aide de Jersey Framework et Java.
Pour chaque demande dont l'utilisateur doit fournir un nom d'utilisateur et un mot de passe, je sais que cette authentification n'est pas une pratique recommandée (à l'aide d'une commande curl telle que: curl -u username:password -X PUT http://localhsot:8080/user).
Je souhaite maintenant appeler un service Web REST à partir d'une classe Android.
Comment devrais-je le faire?
J'ai une classe Android qui utilise DefaultHttpClient et CredentialUsernameAndPassword, mais lorsque je l'exécute dans Eclipse, je reçois parfois une exception d'exécution ou une exception SDK.
Ceci est un exemple de classe restclient
public class RestClient
{
public enum RequestMethod
{
GET,
POST
}
public int responseCode=0;
public String message;
public String response;
public void Execute(RequestMethod method,String url,ArrayList<NameValuePair> headers,ArrayList<NameValuePair> params) throws Exception
{
switch (method)
{
case GET:
{
// add parameters
String combinedParams = "";
if (params!=null)
{
combinedParams += "?";
for (NameValuePair p : params)
{
String paramString = p.getName() + "=" + URLEncoder.encode(p.getValue(),"UTF-8");
if (combinedParams.length() > 1)
combinedParams += "&" + paramString;
else
combinedParams += paramString;
}
}
HttpGet request = new HttpGet(url + combinedParams);
// add headers
if (headers!=null)
{
headers=addCommonHeaderField(headers);
for (NameValuePair h : headers)
request.addHeader(h.getName(), h.getValue());
}
executeRequest(request, url);
break;
}
case POST:
{
HttpPost request = new HttpPost(url);
// add headers
if (headers!=null)
{
headers=addCommonHeaderField(headers);
for (NameValuePair h : headers)
request.addHeader(h.getName(), h.getValue());
}
if (params!=null)
request.setEntity(new UrlEncodedFormEntity(params, HTTP.UTF_8));
executeRequest(request, url);
break;
}
}
}
private ArrayList<NameValuePair> addCommonHeaderField(ArrayList<NameValuePair> _header)
{
_header.add(new BasicNameValuePair("Content-Type","application/x-www-form-urlencoded"));
return _header;
}
private void executeRequest(HttpUriRequest request, String url)
{
HttpClient client = new DefaultHttpClient();
HttpResponse httpResponse;
try
{
httpResponse = client.execute(request);
responseCode = httpResponse.getStatusLine().getStatusCode();
message = httpResponse.getStatusLine().getReasonPhrase();
HttpEntity entity = httpResponse.getEntity();
if (entity != null)
{
InputStream instream = entity.getContent();
response = convertStreamToString(instream);
instream.close();
}
}
catch (Exception e)
{ }
}
private static String convertStreamToString(InputStream is)
{
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder sb = new StringBuilder();
String line = null;
try
{
while ((line = reader.readLine()) != null)
{
sb.append(line + "\n");
}
is.close();
}
catch (IOException e)
{ }
return sb.toString();
}
}
Récemment découvert qu'une bibliothèque tierce - Square Retrofit peut très bien faire le travail.
Définition du noeud final REST
public interface GitHubService {
@GET("/users/{user}/repos")
List<Repo> listRepos(@Path("user") String user,Callback<List<User>> cb);
}
Obtenir le service concret
RestAdapter restAdapter = new RestAdapter.Builder()
.setEndpoint("https://api.github.com")
.build();
GitHubService service = restAdapter.create(GitHubService.class);
Appel du noeud final REST
List<Repo> repos = service.listRepos("octocat",new Callback<List<User>>() {
@Override
public void failure(final RetrofitError error) {
Android.util.Log.i("example", "Error, body: " + error.getBody().toString());
}
@Override
public void success(List<User> users, Response response) {
// Do something with the List of Users object returned
// you may populate your adapter here
}
});
La bibliothèque gère la sérialisation et la déserailization de json pour vous. Vous pouvez également personnaliser la sérialisation et la désérialisation.
Gson gson = new GsonBuilder()
.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
.registerTypeAdapter(Date.class, new DateTypeAdapter())
.create();
RestAdapter restAdapter = new RestAdapter.Builder()
.setEndpoint("https://api.github.com")
.setConverter(new GsonConverter(gson))
.build();
Arrêtez avec ce que vous faisiez! :)
Implémentez le client RESTful en tant que SERVICE et déléguez le processus réseau intensif à un composant indépendant de l'activité: un SERVICE.
Regardez cette vidéo perspicace http://www.youtube.com/watch?v=xHXn3Kg2IQE où Virgil Dobjanschi explique sa démarche face à ce défi ...
J'utilise ce REST Client pour mon Android. Cela a l'air vraiment cool. Beau travail de Luke.
http://lukencode.com/2010/04/27/calling-web-services-in-Android-using-httpclient/
J'ai utilisé OkHttpClient pour appeler un service Web reposant. C'est très simple.
OkHttpClient httpClient = new OkHttpClient();
Request request = new Request.Builder()
.url(url)
.build();
Response response = httpClient.newCall(request).execute();
String body = response.body().string()
Utilisation de Spring pour Android avec RestTemplate https://spring.io/guides/gs/consuming-rest-Android/
// The connection URL
String url = "https://ajax.googleapis.com/ajax/" +
"services/search/web?v=1.0&q={query}";
// Create a new RestTemplate instance
RestTemplate restTemplate = new RestTemplate();
// Add the String message converter
restTemplate.getMessageConverters().add(new StringHttpMessageConverter());
// Make the HTTP GET request, marshaling the response to a String
String result = restTemplate.getForObject(url, String.class, "Android");
Suivez les étapes ci-dessous pour consommer RestFul sur Android.
Étape 1
Créez un projet vierge Android.
Étape 2
Besoin d'une autorisation d'accès Internet. écrivez le code ci-dessous dans le fichier AndroidManifest.xml.
<uses-permission Android:name="Android.permission.INTERNET">
</uses-permission>
Étape 3
Besoin d'URL RestFul s'exécutant sur un autre serveur ou le même ordinateur.
Étape 4
Faites un client RestFul qui étend AsyncTask. Voir RestFulPost.Java.
Step5
Créez une classe DTO pour la requête et la réponse RestFull.
RestFulPost.Java
package javaant.com.consuming_restful.restclient;
import Android.app.ProgressDialog;
import Android.content.Context;
import Android.os.AsyncTask;
import Android.util.Log;
import com.google.gson.Gson;
import org.Apache.http.HttpResponse;
import org.Apache.http.client.methods.HttpPost;
import org.Apache.http.entity.StringEntity;
import org.Apache.http.impl.client.DefaultHttpClient;
import org.Apache.http.util.EntityUtils;
import Java.util.Map;
import javaant.com.consuming_restful.util.Util;
/**
* Created by Nirmal Dhara on 29-10-2015.
*/
public class RestFulPost extends AsyncTask<map, void,="" string=""> {
RestFulResult restFulResult = null;
ProgressDialog Asycdialog;
String msg;
String task;
public RestFulPost(RestFulResult restFulResult, Context context, String msg,String task) {
this.restFulResult = restFulResult;
this.task=task;
this.msg = msg;
Asycdialog = new ProgressDialog(context);
}
@Override
protected String doInBackground(Map... params) {
String responseStr = null;
Object dataMap = null;
HttpPost httpost = new HttpPost(params[0].get("url").toString());
try {
dataMap = (Object) params[0].get("data");
Gson gson = new Gson();
Log.d("data map", "data map------" + gson.toJson(dataMap));
httpost.setEntity(new StringEntity(gson.toJson(dataMap)));
httpost.setHeader("Accept", "application/json");
httpost.setHeader("Content-type", "application/json");
DefaultHttpClient httpclient= Util.getClient();
HttpResponse response = httpclient.execute(httpost);
int statusCode = response.getStatusLine().getStatusCode();
Log.d("resonse code", "----------------" + statusCode);
if (statusCode == 200)
responseStr = EntityUtils.toString(response.getEntity());
if (statusCode == 404) {
responseStr = "{\n" +
"\"status\":\"fail\",\n" +
" \"data\":{\n" +
"\"ValidUser\":\"Service not available\",\n" +
"\"code\":\"404\"\n" +
"}\n" +
"}";
}
} catch (Exception e) {
e.printStackTrace();
}
return responseStr;
}
@Override
protected void onPreExecute() {
Asycdialog.setMessage(msg);
//show dialog
Asycdialog.show();
super.onPreExecute();
}
@Override
protected void onPostExecute(String s) {
Asycdialog.dismiss();
restFulResult.onResfulResponse(s,task);
}
}
Pour plus de détails et le code complet, visitez le site http://javaant.com/consume-a-restful-webservice-in-Android/#.VwzbipN96Hs
Quel back-end? Si Java, vous pouvez utiliser REST avec Java (JAX-RS) à l'aide de Jersey.
Sur le côté Android, vous pouvez utiliser ce simple RestClient pour travailler avec ce service REST.
Pour le mappage d'objets JSON <-> des deux côtés (Android, back-end Java), vous pouvez utiliser GSON.
Peut-être suis-je en retard ou peut-être l'avez-vous déjà utilisé auparavant, mais il en existe un autre appelé ksoap et c'est assez incroyable .. Il inclut également des délais d'attente et permet d'analyser efficacement tout service Web basé sur SOAP. J'ai également apporté quelques modifications en fonction de mon analyse syntaxique.
Voici ma bibliothèque que j'ai créée pour un simple appel Webservice,
Vous pouvez utiliser ceci en ajoutant une dépendance de dégradé sur une ligne -
compile 'com.scantity.ScHttpLibrary:ScHttpLibrary:1.0.0'
Voici la démonstration de l'utilisation.
Il y a des tonnes de bibliothèques disponibles pour cela
Retrofit remplace la tâche Async traditionnelle et a sa propre tâche d'arrière-plan, vous n'avez donc pas à vous en soucier. La performance est également très bonne par rapport à AsyncTask.
Vérifiez-le ici,
http://square.github.io/retrofit/
Un exemple complet de rénovation peut être trouvé ici,
https://futurestud.io/blog/retrofit-getting-gart-started-and-Android-client/
Volley est également efficace et facile à utiliser. Vous pouvez jeter un oeil ici:
https://github.com/mcxiaoke/Android-volley
Il y a un tas de ressources sur le web sur la façon de l'utiliser:
http://www.androidhive.info/2014/05/Android-working-with-volley-library-1
AsyncTask
OU Vous devez utiliser une variable AsyncTask et ensuite substituer la méthode doInTheBackground() - où vous pouvez implémenter l'appel REST.
Ensuite, vous pouvez utiliser onPostExecute() pour permettre au thread d'interface utilisateur de traiter les résultats renvoyés à l'étape précédente.
Cette réponse fournit un bon exemple de la façon de mettre en œuvre AsyncTask. voir Exemple d'AsyncTask Android
Pour le commentaire ci-dessous, voici un exemple plus pertinent d'appel REST utilisant AsyncTask: http://alvinalexander.com/Android/android-asynctask-http-client-rest-example-tutorial