it-swarm.com.de

Wie rufen Sie einen RESTful-Webdienst von Android aus auf

Ich habe in Netbean REST einen IDE - Webdienst unter Verwendung von Jersey Framework und Java geschrieben. 

Ich weiß, dass diese Authentifizierung für jede Anforderung, die ein Benutzer eingeben muss, ein Benutzername und ein Kennwort ist (mit einem curl-Befehl wie curl -u username:password -X PUT http://localhsot:8080/user) keine bewährte Methode.

Jetzt möchte ich einen REST - Webdienst von einer Android-Klasse aus aufrufen. 

Wie soll ich das machen? 

Ich habe eine Android-Klasse, die DefaultHttpClient und CredentialUsernameAndPassword verwendet, aber wenn ich sie in Eclipse starte, erhalte ich manchmal eine Laufzeitausnahme oder eine SDK-Ausnahme.

47
sudo

Dies ist ein Beispiel für eine Restclient-Klasse

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();
    }
}
19
Varghese John

Kürzlich entdeckte ich, dass eine Bibliothek eines Drittanbieters - Square Retrofit die Arbeit sehr gut machen kann.


Definieren des Endpunkts REST

public interface GitHubService {
   @GET("/users/{user}/repos")
   List<Repo> listRepos(@Path("user") String user,Callback<List<User>> cb);
}

Den konkreten Service bekommen

RestAdapter restAdapter = new RestAdapter.Builder()
    .setEndpoint("https://api.github.com")
    .build();
GitHubService service = restAdapter.create(GitHubService.class);

Aufruf des Endpunkts 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
    }
});

Die Bibliothek übernimmt die Serialisierung und Deserailisierung von Json für Sie. Sie können auch die Serialisierung und Deserialisierung anpassen.

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();
14
Tianhai

Hör auf mit dem, was du gerade getan hast! :) 

Implementieren Sie den RESTful-Client als SERVICE und delegieren Sie das intensive Netzwerkmaterial an die aktivitätsunabhängige Komponente: einen SERVICE. 

Sehen Sie sich dieses aufschlussreiche Video an http://www.youtube.com/watch?v=xHXn3Kg2IQE wo Virgil Dobjanschi seine Herangehensweise an diese Herausforderung erklärt ...

6
luigi7up

Ich benutze diesen REST Client für mein Android. Das sieht wirklich cool aus. Schöne Arbeit von Luke.

http://lukencode.com/2010/04/27/calling-web-services-in-Android-using-httpclient/

6
Naveen Vijay

Ich habe OkHttpClient verwendet, um einen restful-Webdienst aufzurufen. Es ist sehr einfach.

OkHttpClient httpClient = new OkHttpClient();
Request request = new Request.Builder()
                .url(url)
                .build();

Response response = httpClient.newCall(request).execute();
String body = response.body().string()
1
taynguyen

Spring für Android mit RestTemplate verwenden 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");
1
Igor Vuković

Führen Sie die folgenden Schritte aus, um RestFul in Android zu konsumieren.

Schritt 1

Erstellen Sie ein leeres Android-Projekt.

Schritt 2

Benötigen Sie eine Internet-Zugangserlaubnis. Schreiben Sie den folgenden Code in die Datei AndroidManifest.xml.

 <uses-permission Android:name="Android.permission.INTERNET">
</uses-permission>

Schritt 3

Brauchen Sie RestFul-URL, die auf einem anderen Server oder auf demselben Computer ausgeführt wird.

Schritt 4

Erstellen Sie einen RestFul-Client, der AsyncTask erweitert. Siehe RestFulPost.Java.

Schritt5

Machen Sie eine DTO-Klasse für RestFull Request und Response.

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);
    }
}

Weitere Informationen und den vollständigen Code finden Sie unter http://javaant.com/consume-a-restful-webservice-in-Android/#.VwzbipN96Hs

0
Nirmal Dhara

Welches Backend? Wenn Java, dann können Sie REST mit Java (JAX-RS) mit Jersey verwenden.

Auf Android-Seite können Sie diesen einfachen RestClient verwenden, um mit diesem REST -Dienst zu arbeiten.

Für JSON <-> Object Mapping auf beiden Seiten (Android, Java Backend) können Sie GSON verwenden.

0
Komal Nikhare

Vielleicht bin ich zu spät oder Sie haben es bereits verwendet, aber es gibt noch einen anderen namens ksoap und es ist ziemlich erstaunlich. Es enthält auch Timeouts und kann jeden SOAP basierten Webservice effizient analysieren. Ich habe auch ein paar Änderungen vorgenommen, um meiner Analyse zu entsprechen .. Schauen Sie nach 

0
Olu Smith

Hier ist meine Bibliothek, die ich für einfaches Webservice Calling erstellt habe,

Sie können dies verwenden, indem Sie eine einzeilige Abhängigkeit hinzufügen. 

compile 'com.scantity.ScHttpLibrary:ScHttpLibrary:1.0.0'

Hier ist die Demonstration der Verwendung.

https://github.com/vishalchhodwani1992/httpLibrary

0

Dafür gibt es jede Menge Bibliotheken 

Retrofit ersetzt die traditionelle AsyncTask und hat eine eigene Hintergrundaufgabe, so dass Sie sich wirklich keine Gedanken darüber machen müssen. Die Leistung ist auch im Vergleich zu AsyncTask sehr gut.

Überprüfen Sie es hier,

http://square.github.io/retrofit/

Ein vollständiges Beispiel für Retrofit finden Sie hier.

https://futurestud.io/blog/retrofit-getting-started-and-Android-client/

Volley ist auch effizient und einfach zu bedienen. Hier können Sie einen Blick darauf werfen:

https://github.com/mcxiaoke/Android-volley

Es gibt eine Reihe von Ressourcen im Web, wie man es benutzt:

http://www.androidhive.info/2014/05/Android-working-with-volley-library-1

AsyncTask 

ODER Sie sollten eine AsyncTask implementieren und dann die Methode doInTheBackground() überschreiben. Dort können Sie den REST - Aufruf implementieren.

Dann können Sie onPostExecute() verwenden, um den UI-Thread die Ergebnisse verarbeiten zu lassen, die im vorherigen Schritt zurückgegeben wurden.

Diese Antwort liefert ein gutes Beispiel für die Implementierung von AsyncTask. siehe AsyncTask Android-Beispiel

Nachstehend finden Sie ein interessanteres Beispiel für den Aufruf von REST mit AsyncTask: http://alvinalexander.com/Android/android-asynctask-http-client-rest-example-tutorial

0
Umer