Effectuer une requête HTTP avec android
J'ai cherché partout mais je n'ai pas trouvé de réponse. Existe-t-il un moyen de faire une simple requête HTTP? Je souhaite demander une page/script PHP sur l'un de mes sites Web, mais je ne souhaite pas afficher la page Web.
Si possible, je veux même le faire en arrière-plan (dans un BroadcastReceiver)
MISE À JOUR
C'est une très vieille réponse. Je ne recommanderai certainement plus le client d'Apache. Utilisez plutôt soit:
Réponse originale
Tout d'abord, demandez une autorisation pour accéder au réseau, ajoutez ce qui suit à votre manifeste:
<uses-permission Android:name="Android.permission.INTERNET" />
Ensuite, le moyen le plus simple consiste à utiliser le client HTTP Apache fourni 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 s'exécute 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");
à moins que vous n'ayez une raison explicite de choisir Apache HttpClient, vous devez préférer Java.net.URLConnection. vous pouvez trouver de nombreux exemples d'utilisation de ce logiciel sur le Web.
nous avons également amélioré la documentation Android depuis votre publication d'origine: 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
Remarque: le client HTTP Apache fourni avec Android est désormais obsolète en faveur de HttpURLConnection . Veuillez consulter le Android Developers Blog pour plus de détails.
Ajoutez <uses-permission Android:name="Android.permission.INTERNET" /> à votre manifeste.
Vous devriez alors récupérer 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 également de l'exécuter sur un thread 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 le documentation pour plus d'informations sur le traitement des réponses et les demandes POST.
Le moyen le plus simple consiste à utiliser la Android lib appelée Volley
Volley offre les avantages suivants:
Planification automatique des requêtes réseau. Plusieurs connexions réseau simultanées . Mise en cache transparente des réponses sur le disque et la mémoire avec cohérence de cache HTTP standard. Prise en charge de la priorisation des demandes. API de demande d'annulation. Vous pouvez annuler une demande unique ou définir des blocs ou des portées de demandes à annuler. Facilité de personnalisation, par exemple, pour réessayer et annuler. Un ordre solide qui facilite le remplissage correct de votre interface utilisateur avec des données extraites de manière asynchrone à partir du réseau. Outils de débogage et de traçage.
Vous pouvez envoyer une demande http/https aussi simple que cela:
// 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 penser à "exécuter en arrière-plan" ou à "utiliser le cache", car 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);
}
Cordialement
Regardez cette nouvelle bibliothèque géniale qui est disponible via gradle :)
build.gradle: compile 'com.apptakk.http_request:http-request:0.1.2'
Usage:
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();
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);
}
}
J'ai créé ceci pour qu'un service web demande une URL, en utilisant une lib 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 sous Android. HTTPClient est privé de licence et risque de ne pas être disponible tel qu'il était dans mon cas.
Premièrement, ajoutez les deux dépendances dans build.gradle:
compile 'org.Apache.httpcomponents:httpcore:4.4.1'
compile 'org.Apache.httpcomponents:httpclient:4.5'
Puis écrivez ce code dans ASyncTask dans la méthode doBackground.
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, le moyen le plus simple consiste à utiliser une bibliothèque appelée Retrofit2
Nous avons juste besoin de créer une interface contenant notre méthode de requête, nos paramètres, et nous pouvons aussi créer un 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 mieux est que nous pouvons le faire facilement de manière asynchrone en utilisant la méthode de mise en file d'attente
Comme aucune réponse ne décrivait un moyen 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 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 nous extrait de certains détails de bas niveau, offrant ainsi des moyens plus conviviaux et sécurisés d'interagir avec eux. La syntaxe est également simplifiée et permet d’écrire du code Nice.