Comment envoyer un objet JSON via une requête avec Android?

Question

Je veux envoyer le texte JSON suivant {"Email":"aaa@tbbb.com","Password":"123456"} à un service Web et lire la réponse. Je sais à comment lire JSON. Le problème est que l'objet JSON ci-dessus doit être envoyé sous un nom de variable jason.

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

Answer 1

Android ne possède pas de code spécial pour l'envoi et la réception HTTP, vous pouvez utiliser le code Java standard. Je recommande d'utiliser le client HTTP Apache, qui est livré avec Android. Voici un extrait de code que j'ai utilisé pour envoyer un POST HTTP.

Je ne comprends pas ce que l'envoi de l'objet dans une variable nommée "jason" a à voir avec n'importe quoi. Si vous n'êtes pas sûr exactement le serveur veut, envisager d'écrire un programme de test pour envoyer des différentes chaînes sur le serveur jusqu'à ce que vous savez quel format il doit être.

int TIMEOUT_MILLISEC = 10000; // = 10 seconds 
String postMessage="{}"; //HERE_YOUR_POST_STRING. 
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 2

Envoi d'un objet JSON d'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 verrouiller le thread d'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 JSON.

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

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

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

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 'au 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é depuis votre thread d'interface utilisateur. Le responseHandler s'exécutera sur le même thread que vous l'avez créé (généralement, votre thread UI). Il a même une réponse intégrée pour JSON, mais je préfère utiliser google gson.

Answer 5

HttpPost est obsolète par Android Api niveau 22. Donc, utilisez HttpUrlConnection pour plus loin.

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 6

maintenant depuis le HttpClient est dépréciée le code de travail actuel est d'utiliser le HttpUrlConnection pour créer la connexion et écrire le et lire à partir de la connexion. Mais j'ai préféré utiliser le Volley. Cette bibliothèque provient d'Android AOSP. J'ai trouvé très facile à utiliser pour faire JsonObjectRequest ou JsonArrayRequest

Answer 7

Rien de plus simple que cela. Utilisez OkHttpLibrary

Créer votre JSON

JSONObject requestObject = new JSONObject(); 
requestObject.put("Email", email); 
requestObject.put("Password", password); 

et l'envoyer comme ça.

OkHttpClient client = new OkHttpClient(); 

RequestBody body = RequestBody.create(JSON, json); 
Request request = new Request.Builder() 
      .addHeader("Content-Type","application/json") 
      .url(url) 
      .post(requestObject.toString()) 
      .build(); 

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

Answer 8

public class getUserProfile extends AsyncTask<Void, String, JSONArray> { 
    JSONArray array; 
    @Override 
    protected JSONArray doInBackground(Void... params) { 

     try { 
      commonurl cu = new commonurl(); 
      String u = cu.geturl("tempshowusermain.php"); 
      URL url =new URL(u); 
      // URL url = new URL("http://192.168.225.35/jabber/tempshowusermain.php"); 
      HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection(); 
      httpURLConnection.setRequestMethod("POST"); 
      httpURLConnection.setRequestProperty("Content-Type", "application/json"); 
      httpURLConnection.setRequestProperty("Accept", "application/json"); 
      httpURLConnection.setDoOutput(true); 
      httpURLConnection.setRequestProperty("Connection", "Keep-Alive"); 
      httpURLConnection.setDoInput(true); 
      httpURLConnection.connect(); 

      JSONObject jsonObject=new JSONObject(); 
      jsonObject.put("lid",lid); 


      DataOutputStream outputStream = new DataOutputStream(httpURLConnection.getOutputStream()); 
      outputStream.write(jsonObject.toString().getBytes("UTF-8")); 

      int code = httpURLConnection.getResponseCode(); 
      if (code == 200) { 
       BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(httpURLConnection.getInputStream())); 

       StringBuffer stringBuffer = new StringBuffer(); 
       String line; 

       while ((line = bufferedReader.readLine()) != null) { 
        stringBuffer.append(line); 
       } 
       object = new JSONObject(stringBuffer.toString()); 
      // array = new JSONArray(stringBuffer.toString()); 
       array = object.getJSONArray("response"); 

      } 

     } catch (Exception e) { 

      e.printStackTrace(); 
     } 
     return array; 


    } 

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



    } 

    @Override 
    protected void onPostExecute(JSONArray array) { 
     super.onPostExecute(array); 
     try { 
      for (int x = 0; x < array.length(); x++) { 

       object = array.getJSONObject(x); 
       ComonUserView commUserView=new ComonUserView();// commonclass.setId(Integer.parseInt(jsonObject2.getString("pid").toString())); 
       //pidArray.add(jsonObject2.getString("pid").toString()); 

       commUserView.setLid(object.get("lid").toString()); 
       commUserView.setUname(object.get("uname").toString()); 
       commUserView.setAboutme(object.get("aboutme").toString()); 
       commUserView.setHeight(object.get("height").toString()); 
       commUserView.setAge(object.get("age").toString()); 
       commUserView.setWeight(object.get("weight").toString()); 
       commUserView.setBodytype(object.get("bodytype").toString()); 
       commUserView.setRelationshipstatus(object.get("relationshipstatus").toString()); 
       commUserView.setImagepath(object.get("imagepath").toString()); 
       commUserView.setDistance(object.get("distance").toString()); 
       commUserView.setLookingfor(object.get("lookingfor").toString()); 
       commUserView.setStatus(object.get("status").toString()); 

       cm.add(commUserView); 
      } 
      custuserprof = new customadapterformainprofile(getActivity(),cm,Tab3.this); 
      gridusername.setAdapter(custuserprof); 
      // listusername.setAdapter(custuserprof); 
      } catch (Exception e) { 

       e.printStackTrace(); 
     } 
    }