webentwicklung-frage-antwort-db.com.de

Machen Sie eine HTTP-Anfrage mit android

Ich habe überall gesucht, konnte aber meine Antwort nicht finden. Gibt es eine Möglichkeit, eine einfache HTTP-Anfrage zu stellen? Ich möchte eine PHP Seite/ein _ Skript auf einer meiner Websites anfordern, aber ich möchte die Webseite nicht anzeigen.

Wenn möglich möchte ich es sogar im Hintergrund machen (in einem BroadcastReceiver)

343
Mats Hofman

AKTUALISIEREN

Dies ist eine sehr alte Antwort. Ich werde den Apache-Client definitiv nicht mehr empfehlen. Verwenden Sie stattdessen entweder:

Ursprüngliche Antwort

Fordern Sie zunächst eine Berechtigung zum Zugriff auf das Netzwerk an und fügen Sie Folgendes zu Ihrem Manifest hinzu:

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

Dann ist der einfachste Weg, den mit Android gebündelten Apache http-Client zu verwenden:

    HttpClient httpclient = new DefaultHttpClient();
    HttpResponse response = httpclient.execute(new HttpGet(URL));
    StatusLine statusLine = response.getStatusLine();
    if(statusLine.getStatusCode() == HttpStatus.SC_OK){
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        response.getEntity().writeTo(out);
        String responseString = out.toString();
        out.close();
        //..more logic
    } else{
        //Closes the connection.
        response.getEntity().getContent().close();
        throw new IOException(statusLine.getReasonPhrase());
    }

Wenn es auf einem separaten Thread ausgeführt werden soll, empfehle ich die Erweiterung von AsyncTask:

class RequestTask extends AsyncTask<String, String, String>{

    @Override
    protected String doInBackground(String... uri) {
        HttpClient httpclient = new DefaultHttpClient();
        HttpResponse response;
        String responseString = null;
        try {
            response = httpclient.execute(new HttpGet(uri[0]));
            StatusLine statusLine = response.getStatusLine();
            if(statusLine.getStatusCode() == HttpStatus.SC_OK){
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                response.getEntity().writeTo(out);
                responseString = out.toString();
                out.close();
            } else{
                //Closes the connection.
                response.getEntity().getContent().close();
                throw new IOException(statusLine.getReasonPhrase());
            }
        } catch (ClientProtocolException e) {
            //TODO Handle problems..
        } catch (IOException e) {
            //TODO Handle problems..
        }
        return responseString;
    }

    @Override
    protected void onPostExecute(String result) {
        super.onPostExecute(result);
        //Do anything with response..
    }
}

Sie können dann eine Anfrage stellen, indem Sie:

   new RequestTask().execute("http://stackoverflow.com");
465

sofern Sie keinen ausdrücklichen Grund haben, sich für den Apache HttpClient zu entscheiden, sollten Sie Java.net.URLConnection bevorzugen. Sie finden zahlreiche Beispiele für die Verwendung im Web.

wir haben auch die Android Dokumentation seit Ihrem ursprünglichen Beitrag verbessert: http://developer.Android.com/reference/Java/net/HttpURLConnection.html

und wir haben über die Kompromisse auf dem offiziellen Blog gesprochen: http://Android-developers.blogspot.com/2011/09/androids-http-clients.html

65
Elliott Hughes

Hinweis: Der mit Android gebündelte Apache HTTP-Client wird jetzt zugunsten von HttpURLConnection nicht mehr empfohlen. Weitere Informationen finden Sie in den Android Entwicklern Blog .

Fügen Sie Ihrem Manifest <uses-permission Android:name="Android.permission.INTERNET" /> hinzu.

Sie würden dann eine Webseite wie folgt abrufen:

URL url = new URL("http://www.Android.com/");
HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
try {
     InputStream in = new BufferedInputStream(urlConnection.getInputStream());
     readStream(in);
}
finally {
     urlConnection.disconnect();
}

Ich schlage auch vor, es auf einem separaten Thread auszuführen:

class RequestTask extends AsyncTask<String, String, String>{

@Override
protected String doInBackground(String... uri) {
    String responseString = null;
    try {
        URL url = new URL(myurl);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        if(conn.getResponseCode() == HttpsURLConnection.HTTP_OK){
            // Do normal input or output stream reading
        }
        else {
            response = "FAILED"; // See documentation for more info on response handling
        }
    } catch (ClientProtocolException e) {
        //TODO Handle problems..
    } catch (IOException e) {
        //TODO Handle problems..
    }
    return responseString;
}

@Override
protected void onPostExecute(String result) {
    super.onPostExecute(result);
    //Do anything with response..
}
}

Weitere Informationen zur Behandlung von Antworten und zu POST -Anforderungen finden Sie in der Dokumentation .

43
Kevin Cronly

Der einfachste Weg ist die Verwendung der Android -Lib Volley

Volley bietet folgende Vorteile:

Automatische Planung von Netzwerkanforderungen. Mehrere gleichzeitige Netzwerkverbindungen . Transparentes Cache für Festplatten- und Speicherantworten mit standardmäßiger HTTP-Cache-Kohärenz. Unterstützung für die Priorisierung von Anfragen. Stornierungsanforderungs-API. Sie können eine einzelne Anfrage stornieren oder Blöcke oder Bereiche von Anfragen zum Stornieren festlegen. Einfache Anpassung, z. B. für Wiederholungs- und Zurückversetzungsversuche. Starke Reihenfolge, die es einfach macht, Ihre Benutzeroberfläche korrekt mit Daten zu füllen, die asynchron aus dem Netzwerk abgerufen werden. Debugging- und Tracing-Tools.

So einfach können Sie eine http/https-Anfrage senden:

        // Instantiate the RequestQueue.
        RequestQueue queue = Volley.newRequestQueue(this);
        String url ="http://www.yourapi.com";
        JsonObjectRequest request = new JsonObjectRequest(url, null,
            new Response.Listener<JSONObject>() {
                @Override
                public void onResponse(JSONObject response) {
                    if (null != response) {
                         try {
                             //handle your response
                         } catch (JSONException e) {
                             e.printStackTrace();
                         }
                    }
                }
            }, new Response.ErrorListener() {

            @Override
            public void onErrorResponse(VolleyError error) {

            }
        });
        queue.add(request);

In diesem Fall müssen Sie nicht in Betracht ziehen, im Hintergrund zu laufen oder den Cache selbst zu verwenden, da dies alles bereits von Volley durchgeführt wurde.

12
Shao Wenbin
private String getToServer(String service) throws IOException {
    HttpGet httpget = new HttpGet(service);
    ResponseHandler<String> responseHandler = new BasicResponseHandler();
    return new DefaultHttpClient().execute(httpget, responseHandler);

}

Grüße

6
Gabriel Gómez

Schau dir diese tolle neue Bibliothek an, die über gradle erhältlich ist :)

build.gradle: compile 'com.apptakk.http_request:http-request:0.1.2'

Verwendungszweck:

new HttpRequestTask(
    new HttpRequest("http://httpbin.org/post", HttpRequest.POST, "{ \"some\": \"data\" }"),
    new HttpRequest.Handler() {
      @Override
      public void response(HttpResponse response) {
        if (response.code == 200) {
          Log.d(this.getClass().toString(), "Request successful!");
        } else {
          Log.e(this.getClass().toString(), "Request unsuccessful: " + response);
        }
      }
    }).execute();

https://github.com/erf/http-request

5
Ben Marten

Mit einem Faden:

private class LoadingThread extends Thread {
    Handler handler;

    LoadingThread(Handler h) {
        handler = h;
    }
    @Override
    public void run() {
        Message m = handler.obtainMessage();
        try {
            BufferedReader in = 
                new BufferedReader(new InputStreamReader(url.openStream()));
            String page = "";
            String inLine;

            while ((inLine = in.readLine()) != null) {
                page += inLine;
            }

            in.close();
            Bundle b = new Bundle();
            b.putString("result", page);
            m.setData(b);
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        handler.sendMessage(m);
    }
}
4
fredley

Ich habe dies für einen Webservice gemacht, um unter Verwendung einer Gson-Bibliothek eine URL anzufordern:

Klient:

public EstabelecimentoList getListaEstabelecimentoPorPromocao(){

        EstabelecimentoList estabelecimentoList  = new EstabelecimentoList();
        try{
            URL url = new URL("http://" +  Conexao.getSERVIDOR()+ "/cardapio.online/rest/recursos/busca_estabelecimento_promocao_Android");
            HttpURLConnection con = (HttpURLConnection) url.openConnection();

            if (con.getResponseCode() != 200) {
                    throw new RuntimeException("HTTP error code : "+ con.getResponseCode());
            }

            BufferedReader br = new BufferedReader(new InputStreamReader((con.getInputStream())));
            estabelecimentoList = new Gson().fromJson(br, EstabelecimentoList.class);
            con.disconnect();

        } catch (IOException e) {
            e.printStackTrace();
        }
        return estabelecimentoList;
}
3

Dies ist der neue Code für HTTP Get/POST-Anforderungen in Android. HTTPClient ist benachteiligt und möglicherweise nicht verfügbar, wie es in meinem Fall war.

Fügen Sie zunächst die beiden Abhängigkeiten in build.gradle hinzu:

compile 'org.Apache.httpcomponents:httpcore:4.4.1'
compile 'org.Apache.httpcomponents:httpclient:4.5'

Dann schreiben Sie diesen Code in ASyncTask in doBackground Methode.

 URL url = new URL("http://localhost:8080/web/get?key=value");
 HttpURLConnection urlConnection = (HttpURLConnection)url.openConnection();
 urlConnection.setRequestMethod("GET");
 int statusCode = urlConnection.getResponseCode();
 if (statusCode ==  200) {
      InputStream it = new BufferedInputStream(urlConnection.getInputStream());
      InputStreamReader read = new InputStreamReader(it);
      BufferedReader buff = new BufferedReader(read);
      StringBuilder dta = new StringBuilder();
      String chunks ;
      while((chunks = buff.readLine()) != null)
      {
         dta.append(chunks);
      }
 }
 else
 {
     //Handle else
 }
2
Rahul Raina

Für mich ist die Verwendung der Bibliothek Retrofit2 der einfachste Weg

Wir müssen nur eine Schnittstelle erstellen, die unsere Anforderungsmethode und Parameter enthält. Außerdem können wir für jede Anforderung einen benutzerdefinierten Header erstellen:

    public interface MyService {

      @GET("users/{user}/repos")
      Call<List<Repo>> listRepos(@Path("user") String user);

      @GET("user")
      Call<UserDetails> getUserDetails(@Header("Authorization") String   credentials);

      @POST("users/new")
      Call<User> createUser(@Body User user);

      @FormUrlEncoded
      @POST("user/edit")
      Call<User> updateUser(@Field("first_name") String first, 
                            @Field("last_name") String last);

      @Multipart
      @PUT("user/photo")
      Call<User> updateUser(@Part("photo") RequestBody photo, 
                            @Part("description") RequestBody description);

      @Headers({
        "Accept: application/vnd.github.v3.full+json",
        "User-Agent: Retrofit-Sample-App"
      })
      @GET("users/{username}")
      Call<User> getUser(@Path("username") String username);    

    }

Und das Beste ist, wir können es einfach asynchron mit der Enqueue-Methode machen

1
faruk

Da in keiner der Antworten eine Möglichkeit beschrieben wurde, Anfragen mit OkHttp auszuführen, was heutzutage für Android und Java im Allgemeinen sehr beliebt ist, gehe ich um ein einfaches Beispiel zu geben:

//get an instance of the client
OkHttpClient client = new OkHttpClient();

//add parameters
HttpUrl.Builder urlBuilder = HttpUrl.parse("https://www.example.com").newBuilder();
urlBuilder.addQueryParameter("query", "stack-overflow");


String url = urlBuilder.build().toString();

//build the request
Request request = new Request.Builder().url(url).build();

//execute
Response response = client.newCall(request).execute();

Der klare Vorteil dieser Bibliothek ist, dass sie uns von einigen Details auf niedriger Ebene abstrahiert und freundlichere und sicherere Möglichkeiten für die Interaktion mit ihnen bietet. Die Syntax ist ebenfalls vereinfacht und ermöglicht das Schreiben von Nice-Code.

1
NiVeR