¿Cómo enviar un objeto JSON a través de Solicitud con Android?

Quiero enviar el siguiente texto JSON

{"Email":"aaa@tbbb.com","Password":"123456"}

a un servicio web y lea la respuesta. Sé cómo leer JSON. El problema es que el objeto JSON anterior debe enviarse en un nombre de variable jason.

¿Cómo puedo hacer esto desde Android? ¿Cuáles son los pasos, como crear un objeto de solicitud, configurar encabezados de contenido, etc.

Enviar un objeto json desde Android es fácil si usa Apache HTTP Client. Aquí hay un ejemplo de código sobre cómo hacerlo. Debe crear un nuevo subproceso para las actividades de la red para no bloquear el subproceso de la interfaz de usuario.

    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();      
    }

También podrías usar Google Gson para enviar y recuperar JSON.

Android no tiene un código especial para enviar y recibir HTTP, puede usar el código estándar de Java. Recomiendo usar el cliente Apache HTTP, que viene con Android. Aquí hay un fragmento de código que usé para enviar un HTTP POST.

No entiendo qué tiene que ver enviar el objeto en una variable llamada “jason”. Si no está seguro de qué quiere exactamente el servidor, considere escribir un programa de prueba para enviar varias cadenas al servidor hasta que sepa en qué formato debe estar.

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);

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) {
    }
}

HttpPost está en desuso por Android Api Nivel 22. Por lo tanto, use HttpUrlConnection para más

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;
}

Hay una biblioteca sorprendentemente agradable para Android HTTP disponible en el siguiente enlace:

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

Las solicitudes simples son muy fáciles:

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

Para enviar JSON (crédito a `voidberg’ en 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);

Todo es asincrónico, funciona bien con Android y es seguro llamar desde el subproceso de la interfaz de usuario. El controlador de respuesta se ejecutará en el mismo subproceso desde el que lo creó (normalmente, su subproceso de interfaz de usuario). Incluso tiene un resonseHandler incorporado para JSON, pero prefiero usar google gson.

Ahora desde el HttpClient está en desuso, el código de trabajo actual es usar el HttpUrlConnection para crear la conexión y escribir y leer de la conexión. Pero preferí usar el Voleo. Esta biblioteca es de Android AOSP. Me pareció muy fácil de usar para hacer JsonObjectRequest o JsonArrayRequest

Nada podría ser más simple que esto. Usar OkHttpLibrary

Crea tu json

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

y enviarlo así.

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();