web-dev-qa-db-fra.com

Android: AsyncTask pour faire une requête HTTP GET?

Je suis nouveau dans le développement Android. Ma question est, est-ce que j'utilise AsyncTask pour faire une demande HTTP GET (réponse JSON)? Est-ce correct? Est-ce que quelqu'un sait où je peux voir un exemple de ceci si cela est vraiment vrai? Si non, pourriez-vous me corriger? Merci!

androidandroid-asynctaskhttprequest
11
Mario A Guzman

Oui, vous avez raison, Asynctask est utilisé pour des tâches courtes telles que la connexion au réseau. En outre, il est utilisé pour les tâches en arrière-plan afin que vous ne bloquiez pas votre thread d'interface utilisateur ou obteniez une exception, car vous ne pouvez pas établir de connexion réseau dans votre thread d'interface utilisateur/principal.

Exemple: 

class JSONAsyncTask extends AsyncTask<String, Void, Boolean> {


@Override
protected void onPreExecute() {
    super.onPreExecute();

}

@Override
protected Boolean doInBackground(String... urls) {
    try {

        //------------------>>
        HttpGet httppost = new HttpGet("YOU URLS TO JSON");
        HttpClient httpclient = new DefaultHttpClient();
        HttpResponse response = httpclient.execute(httppost);

        // StatusLine stat = response.getStatusLine();
        int status = response.getStatusLine().getStatusCode();

        if (status == 200) {
            HttpEntity entity = response.getEntity();
            String data = EntityUtils.toString(entity);


            JSONObject jsono = new JSONObject(data);

            return true;
        }


    } catch (IOException e) {
        e.printStackTrace();
    } catch (JSONException e) {

        e.printStackTrace();
    }
    return false;
}

protected void onPostExecute(Boolean result) {

}
29
Rod_Algonquin

Découvrez ce lien LIEN et retirez-le de googlecelui-ci aussi

import Java.io.BufferedReader;
import Java.io.IOException;
import Java.io.InputStream;
import Java.io.InputStreamReader;
import Java.io.UnsupportedEncodingException;
import org.Apache.http.HttpEntity;
import org.Apache.http.HttpResponse;
import org.Apache.http.client.ClientProtocolException;
import org.Apache.http.client.methods.HttpPost;
import org.Apache.http.impl.client.DefaultHttpClient;
import org.json.JSONException;
import org.json.JSONObject;
import Android.util.Log;
public class JSONParser {
  static InputStream is = null;
  static JSONObject jObj = null;
  static String json = "";
  // constructor
  public JSONParser() {
  }
  public JSONObject getJSONFromUrl(String url) {
    // Making HTTP request
    try {
      // defaultHttpClient
      DefaultHttpClient httpClient = new DefaultHttpClient();
      HttpPost httpPost = new HttpPost(url);
      HttpResponse httpResponse = httpClient.execute(httpPost);
      HttpEntity httpEntity = httpResponse.getEntity();
      is = httpEntity.getContent();
    } catch (UnsupportedEncodingException e) {
      e.printStackTrace();
    } catch (ClientProtocolException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
    try {
      BufferedReader reader = new BufferedReader(new InputStreamReader(
          is, "iso-8859-1"), 8);
      StringBuilder sb = new StringBuilder();
      String line = null;
      while ((line = reader.readLine()) != null) {
        sb.append(line + "n");
      }
      is.close();
      json = sb.toString();
    } catch (Exception e) {
      Log.e("Buffer Error", "Error converting result " + e.toString());
    }
    // try parse the string to a JSON object
    try {
      jObj = new JSONObject(json);
    } catch (JSONException e) {
      Log.e("JSON Parser", "Error parsing data " + e.toString());
    }
    // return JSON String
    return jObj;
  }
}
3
Cho Hee

Oui vous avez 3 choix 

  1. Utiliser AsyncTask
  2. Vous pouvez utiliser Handler
  3. ou vous pouvez utiliser un seperate Thread.

Le meilleur choix est AsyncTask. Vous devez implémenter votre méthode network call dans doInBackground de AsyncTasket dans la méthode postExecute mettre à jour le main ui Thread ou quoi que vous fassiez avec le résultat.

vous pouvez suivre suivez ce tutoriel pour vos besoins

extrait de code

@Override
    protected String doInBackground(String... urls) {
      String response = "";
      for (String url : urls) {
        DefaultHttpClient client = new DefaultHttpClient();
        HttpGet httpGet = new HttpGet(url);
        try {
          HttpResponse execute = client.execute(httpGet);
          InputStream content = execute.getEntity().getContent();

          BufferedReader buffer = new BufferedReader(new InputStreamReader(content));
          String s = "";
          while ((s = buffer.readLine()) != null) {
            response += s;
          }

        } catch (Exception e) {
          e.printStackTrace();
        }
      }
      return response;
    }
3
Kaushik
protected String doInBackground(String... strings) {

    String response = "";

    response = ServiceHandler.findJSONFromUrl("url");
    data = response;
    return response;
}

public class ServiceHandler {

    // Create Http connection And find Json

    public static String findJSONFromUrl(String url) {
        String result = "";
        try {
            URL urls = new URL(url);
            HttpURLConnection conn = (HttpURLConnection) urls.openConnection();
            conn.setReadTimeout(150000); //milliseconds
            conn.setConnectTimeout(15000); // milliseconds
            conn.setRequestMethod("GET");

            conn.connect();

            if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {

                BufferedReader reader = new BufferedReader(new InputStreamReader(
                        conn.getInputStream(), "iso-8859-1"), 8);
                StringBuilder sb = new StringBuilder();
                String line = null;
                while ((line = reader.readLine()) != null) {
                    sb.append(line + "\n");

                }
                result = sb.toString();
            } else {

                return "error";
            }


        } catch (Exception e) {
            // System.out.println("exception in jsonparser class ........");
            e.printStackTrace();
            return "error";
        }

        return result;
    } // method ends
}
2
Rishabh Dixit

Voici une simple HttpsURLConnection dans la classe ASyncTask pour l'appel API Web Https POST/GET avec un en-tête de paquet et JSONObject dans le corps. 

import Android.os.AsyncTask;

import org.json.JSONObject;

import Java.io.BufferedInputStream;
import Java.io.BufferedReader;
import Java.io.IOException;
import Java.io.InputStream;
import Java.io.InputStreamReader;
import Java.io.OutputStreamWriter;
import Java.net.MalformedURLException;
import Java.net.ProtocolException;
import Java.net.URL;

import javax.net.ssl.HttpsURLConnection;

/**
 * Class to handle BasicAuth post web-api call.
 */
public class Information extends AsyncTask<String, String, String> {

    @Override
    protected String doInBackground(String... params) {

        try {
            // Creating & connection Connection with url and required Header.
            URL url = new URL("https://example.com/wp-json/jwt-auth/v1/token");
            HttpsURLConnection urlConnection = (HttpsURLConnection) url.openConnection();
            urlConnection.setRequestProperty("Content-Type", "application/json");
            urlConnection.setRequestProperty("header-param_3", "value-3");
            urlConnection.setRequestProperty("header-param_4", "value-4");
            urlConnection.setRequestProperty("Authorization", "Basic Y2tfNDIyODg0NWI1YmZiZT1234ZjZWNlOTA3ZDYyZjI4MDMxY2MyNmZkZjpjc181YjdjYTY5ZGM0OTUwODE3NzYwMWJhMmQ2OGQ0YTY3Njk1ZGYwYzcw");
            urlConnection.setRequestMethod("POST");   //POST or GET
            urlConnection.connect();

            // Create JSONObject Request
            JSONObject jsonRequest = new JSONObject();
            jsonRequest.put("username", "user.name");
            jsonRequest.put("password", "pass@123");

            // Write Request to output stream to server.
            OutputStreamWriter out = new OutputStreamWriter(urlConnection.getOutputStream());
            out.write(jsonRequest.toString());
            out.close();

            // Check the connection status.
            int statusCode = urlConnection.getResponseCode();
            String statusMsg = urlConnection.getResponseMessage();

            // Connection success. Proceed to fetch the response.
            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);
                }
                String returndata = dta.toString();
                return returndata;
            } else {
                //Handle else case
            }
        } catch (ProtocolException e) {
            e.printStackTrace();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

}

Ici, la valeur de Authentication (paramètre d'en-tête) est la valeur codée par Base64 de [API-key]:[API-Secret] en ajoutant la chaîne "Basic " au début. 

Dans Android Studio, utilisez l'entrée Gradle en tant que: 

compile 'org.Apache.httpcomponents:httpcore:4.4.1'
compile 'org.Apache.httpcomponents:httpclient:4.5'
0
Rahul Raina

AsyncTask gère son pool de threads, mais il n'est pas optimisé pour l'activité du réseau. En fait, si vous avez plusieurs requêtes HTTP sur le même serveur, il est préférable, en termes de consommation de mémoire et de performances globales, de les conserver sur le même thread et de réutiliser une connexion persistante, chaque fois que possible. AsyncTask ne considère pas ces problèmes.

Au lieu de créer votre propre client HTTP asynchrone, envisagez d'utiliser l'une des rares bibliothèques disponibles. Certaines personnes intelligentes ont beaucoup investi pour les rendre robustes, flexibles et rapides.

0
Alex Cohn