Comment envoyer un objet JSON par requête avec Android ?

Question

Je veux envoyer ce qui suit JSON texte {"Email":"aaa@tbbb.com","Password":"123456"} à un service web et lire la réponse. Je sais comment lire JSON . Le problème est que les JSON doit être envoyé dans un nom de variable jason .

Comment puis-je faire cela à partir d'Android ? Quelles sont les étapes telles que la création d'un objet de requête, la définition des en-têtes de contenu, etc.

Answer 1

L'envoi d'un objet json depuis Android est facile si vous utilisez le client HTTP Apache. Voici un exemple de code sur la façon de le faire. Vous devez créer un nouveau thread pour les activités réseau afin de ne pas bloquer le thread de l'interface utilisateur.

    protected void sendJson(final String email, final String pwd) {
        Thread t = new Thread() {

            public void run() {
                Looper.prepare(); //For Preparing Message Pool for the child Thread
                HttpClient client = new DefaultHttpClient();
                HttpConnectionParams.setConnectionTimeout(client.getParams(), 10000); //Timeout Limit
                HttpResponse response;
                JSONObject json = new JSONObject();

                try {
                    HttpPost post = new HttpPost(URL);
                    json.put("email", email);
                    json.put("password", pwd);
                    StringEntity se = new StringEntity( json.toString());  
                    se.setContentType(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
                    post.setEntity(se);
                    response = client.execute(post);

                    /*Checking response */
                    if(response!=null){
                        InputStream in = response.getEntity().getContent(); //Get the data in the entity
                    }

                } catch(Exception e) {
                    e.printStackTrace();
                    createDialog("Error", "Cannot Estabilish Connection");
                }

                Looper.loop(); //Loop in the message queue
            }
        };

        t.start();      
    }

Vous pouvez également utiliser Google Gson pour envoyer et récupérer du JSON.

Answer 2

Android n'a pas de code spécial pour envoyer et recevoir HTTP, vous pouvez utiliser le code Java standard. Je vous recommande d'utiliser le client HTTP Apache, qui est fourni avec Android. Voici un extrait de code que j'ai utilisé pour envoyer un HTTP POST.

Je ne comprends pas ce que l'envoi de l'objet dans une variable nommée "jason" a à voir avec quoi que ce soit. Si vous n'êtes pas sûr de ce que veut exactement le serveur, envisagez d'écrire un programme de test pour envoyer différentes chaînes de caractères au serveur jusqu'à ce que vous sachiez dans quel format elles doivent être envoyées.

int TIMEOUT_MILLISEC = 10000;  // = 10 seconds
HttpParams httpParams = new BasicHttpParams();
HttpConnectionParams.setConnectionTimeout(httpParams, TIMEOUT_MILLISEC);
HttpConnectionParams.setSoTimeout(httpParams, TIMEOUT_MILLISEC);
HttpClient client = new DefaultHttpClient(httpParams);

HttpPost request = new HttpPost(serverUrl);
request.setEntity(new ByteArrayEntity(
    postMessage.toString().getBytes("UTF8")));
HttpResponse response = client.execute(request);

Answer 3

public void postData(String url,JSONObject obj) {
    // Create a new HttpClient and Post Header

    HttpParams myParams = new BasicHttpParams();
    HttpConnectionParams.setConnectionTimeout(myParams, 10000);
    HttpConnectionParams.setSoTimeout(myParams, 10000);
    HttpClient httpclient = new DefaultHttpClient(myParams );
    String json=obj.toString();

    try {

        HttpPost httppost = new HttpPost(url.toString());
        httppost.setHeader("Content-type", "application/json");

        StringEntity se = new StringEntity(obj.toString()); 
        se.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
        httppost.setEntity(se); 

        HttpResponse response = httpclient.execute(httppost);
        String temp = EntityUtils.toString(response.getEntity());
        Log.i("tag", temp);

    } catch (ClientProtocolException e) {

    } catch (IOException e) {
    }
}

Answer 4

HttpPost est obsolète au niveau 22 de l'Api d'Android. Utilisez donc HttpUrlConnection pour plus d'informations.

public static String makeRequest(String uri, String json) {
    HttpURLConnection urlConnection;
    String url;
    String data = json;
    String result = null;
    try {
        //Connect 
        urlConnection = (HttpURLConnection) ((new URL(uri).openConnection()));
        urlConnection.setDoOutput(true);
        urlConnection.setRequestProperty("Content-Type", "application/json");
        urlConnection.setRequestProperty("Accept", "application/json");
        urlConnection.setRequestMethod("POST");
        urlConnection.connect();

        //Write
        OutputStream outputStream = urlConnection.getOutputStream();
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(outputStream, "UTF-8"));
        writer.write(data);
        writer.close();
        outputStream.close();

        //Read
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(urlConnection.getInputStream(), "UTF-8"));

        String line = null;
        StringBuilder sb = new StringBuilder();

        while ((line = bufferedReader.readLine()) != null) {
            sb.append(line);
        }

        bufferedReader.close();
        result = sb.toString();

    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return result;
}

Answer 5

Il existe une bibliothèque étonnamment agréable pour Android HTTP, disponible sur le lien ci-dessous :

http://loopj.com/Android-async-http/

Les demandes simples sont très faciles :

AsyncHttpClient client = new AsyncHttpClient();
client.get("http://www.google.com", new AsyncHttpResponseHandler() {
    @Override
    public void onSuccess(String response) {
        System.out.println(response);
    }
});

Pour envoyer JSON (crédit à `voidberg' à https://github.com/loopj/Android-async-http/issues/125 ) :

// params is a JSONObject
StringEntity se = null;
try {
    se = new StringEntity(params.toString());
} catch (UnsupportedEncodingException e) {
    // handle exceptions properly!
}
se.setContentType(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));

client.post(null, "www.example.com/objects", se, "application/json", responseHandler);

Tout est asynchrone, fonctionne bien avec Android et peut être appelé en toute sécurité depuis le fil d'exécution de l'interface utilisateur. Le responseHandler sera exécuté sur le même thread que celui à partir duquel vous l'avez créé (typiquement, votre thread UI). Il y a même un resonseHandler intégré pour JSON, mais je préfère utiliser google gson.