Faire une demande HTTP avec android
j'ai cherché partout mais je n'ai pas trouvé ma réponse, y a-t-il un moyen de faire une simple requête HTTP? Je veux demander une page / script PHP sur un de mes sites Web mais je ne veux pas montrer la page web.
si possible, je veux même le faire en arrière-plan (dans un diffuseur)
11 réponses
UPDATE
C'est une réponse très ancienne. Je ne recommanderai plus le client D'Apache. À la place, utilisez l'une ou l'autre des mentions suivantes:
Réponse Originale À Cette Question
tout D'abord, demander la permission d'accéder au réseau, ajouter ce qui suit à votre manifeste:
<uses-permission android:name="android.permission.INTERNET" />
la manière la plus simple est alors D'utiliser le client http Apache livré avec Android:
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());
}
si vous voulez qu'il fonctionne sur un thread séparé, je vous recommande d'étendre 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..
}
}
vous pouvez alors faire une demande par:
new RequestTask().execute("http://stackoverflow.com");
sauf si vous avez une raison explicite de choisir Apache HttpClient, vous devriez préférer java.net.URLConnection. vous pouvez trouver beaucoup d'exemples de la façon de l'utiliser sur le web.
nous avons également amélioré la documentation Android depuis votre post original: http://developer.android.com/reference/java/net/HttpURLConnection.html
et nous avons parlé des compromis sur le blog officiel: http://android-developers.blogspot.com/2011/09/androids-http-clients.html
Note: le Client HTTP Apache livré avec Android est maintenant déprécié en faveur de HttpURLConnection . S'il vous plaît voir les développeurs Android Blog pour plus de détails.
ajouter <uses-permission android:name="android.permission.INTERNET" />
à votre manifeste.
vous obtiendriez alors une page web comme ceci:
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();
}
je suggère aussi de l'exécuter sur un fil séparé:
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..
}
}
voir la documentation pour plus d'informations sur la réponse de la manipulation et des requêtes POST.
le moyen le plus simple est d'utiliser L'Android lib appelé Volley
Volley offre les avantages suivants:"
de la planification Automatique de requêtes réseau. Multiples et simultanées réseau les connexions . La mise en cache de la réponse du disque Transparent et de la mémoire avec cohérence du cache HTTP standard. Soutien pour la priorisation des demandes. Demande D'annulation API. Vous pouvez annuler un simple demande, ou vous pouvez définir des blocs ou des portées de requêtes à annuler. Facilité de personnalisation, pour par exemple, pour le réembauchage et le retrait. Commande forte qui rend facile à remplissez correctement votre interface utilisateur avec les données récupérées de manière asynchrone à partir de la réseau. Débogage et des outils de suivi.
vous pouvez envoyer une requête http/https aussi simple que ceci:
// 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);
dans ce cas, vous n'avez pas besoin de considérer "running in the background" ou "using cache"" tout cela a déjà été fait par Volley.
private String getToServer(String service) throws IOException {
HttpGet httpget = new HttpGet(service);
ResponseHandler<String> responseHandler = new BasicResponseHandler();
return new DefaultHttpClient().execute(httpget, responseHandler);
}
concerne
avec un fil:
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);
}
}
Regardez cette incroyable nouvelle bibliothèque qui est disponible via gradle :)
"151920920 de construire".Grad le:compile 'com.apptakk.http_request:http-request:0.1.2'
Utilisation:
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();
j'ai fait ceci pour un service web à requerst sur URL, en utilisant une lib de Gson:
Client:
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;
}
C'est le nouveau code pour la requête HTTP Get/POST sur android. HTTPClient
est déprécié et peut ne pas être disponible comme il était dans mon cas.
ajoutez D'abord les deux dépendances dans build.gradle:
compile 'org.apache.httpcomponents:httpcore:4.4.1'
compile 'org.apache.httpcomponents:httpclient:4.5'
alors écrivez ce code dans ASyncTask
dans doBackground
méthode.
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
}
pour moi, la façon la plus simple est d'utiliser la bibliothèque appelée Retrofit2
nous avons juste besoin de créer une Interface qui contient notre méthode de requête, les paramètres, et aussi nous pouvons faire l'en-tête personnalisé pour chaque requête:
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);
}
Et le meilleur est, on peut le faire de manière asynchrone facilement mettre en file d'attente à l'aide de la méthode
comme aucune des réponses ne décrivait une façon d'effectuer des requêtes avec OkHttp , qui est un client http très populaire de nos jours pour Android et Java en général, je vais vous donner un exemple simple:
//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();
L'avantage évident de cette bibliothèque est qu'elle résumés de certaines détails de bas niveau, fournissant plus convivial et sécurisé façons d'interagir avec eux. La syntaxe est également simplifiée et permet d'écrire du bon code.