Envío y análisis de objetos JSON en Android [cerrado]

Me gustaría enviar mensajes en forma de objetos JSON a un servidor y analizar la respuesta JSON del servidor.

Ejemplo de objeto JSON

{
  "post": {
    "username": "John Doe",
    "message": "test message",
    "image": "image url",
    "time":  "current time"
  }
}

Estoy tratando de analizar el JSON manualmente yendo atributo por atributo. ¿Hay alguna biblioteca / utilidad que pueda usar para facilitar este proceso?

Me sorprende que no se hayan mencionado: pero en lugar de utilizar el proceso básico en lugar del manual con el pequeño paquete de json.org, GSon y Jackson son mucho más cómodos de usar. Entonces:

• GSON
• Jackson

Por lo tanto, puede vincularse a sus propios POJO, no a algunos nodos de árbol a medias o Listas y mapas. (y al menos Jackson permite la vinculación a tales cosas también (quizás GSON también, no estoy seguro), JsonNode, Map, List, si realmente quiere estos en lugar de objetos 'reales')

EDITAR 19-MAR-2014:

Otro nuevo contendiente es la biblioteca Jackson jr : utiliza el mismo analizador / generador de Streaming rápido que Jackson ( jackson-core), pero la parte de enlace de datos es pequeña (50kB). La funcionalidad es más limitada (sin anotaciones, solo Java Beans normales), pero el rendimiento en cuanto a rendimiento debería ser rápido, y la sobrecarga de inicialización (primera llamada) también muy baja. Por lo tanto, podría ser una buena opción, especialmente para aplicaciones más pequeñas.

Puede usar org.json.JSONObject y org.json.JSONTokener . no necesita ninguna biblioteca externa ya que estas clases vienen con Android SDK

GSON es más fácil de usar y el camino a seguir si los datos tienen una estructura definida.

Descargar gson .

Agréguelo a las bibliotecas referenciadas.

package com.tut.JSON;

import org.json.JSONException;
import org.json.JSONObject;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class SimpleJson extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        String jString = "{\"username\": \"tom\", \"message\": \"roger that\"}  ";


        GsonBuilder gsonb = new GsonBuilder();
        Gson gson = gsonb.create();
        Post pst;

        try {
            pst = gson.fromJson(jString,  Post.class);

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

Código para la clase Post

package com.tut.JSON;

public class Post {

    String message;
    String time;
    String username;
    Bitmap icon;
}

Esta es la clase JsonParser

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;

    }

Nota: DefaultHttpClient ya no es compatible con sdk 23, por lo que es aconsejable usar target sdk 21 con este código.

Realmente no hay nada para JSON. Los corchetes son para "objetos" (matrices asociativas) y los corchetes son para matrices sin claves (indexadas numéricamente). En cuanto a trabajar con él en Android, hay clases preparadas para eso incluidas en el SDK (no se requiere descarga).

Echa un vistazo a estas clases: http://developer.android.com/reference/org/json/package-summary.html

Otras respuestas han señalado a Jackson y GSON, las populares bibliotecas JSON adicionales para Android, y json.org, el paquete JSON básico que se incluye en Android.

Pero creo que también vale la pena señalar que Android ahora tiene su propia API JSON con todas las funciones.

Esto se agregó en Honeycomb: API nivel 11.

Esto comprende
- android.util.JsonReader: docs , y source
- android.util.JsonWriter: docs , y source

También agregaré una consideración adicional que me empuja hacia Jackson y GSON: he encontrado útil utilizar bibliotecas de terceros en lugar de paquetes de Android. * Porque el código que escribo puede compartirse entre el cliente y el servidor. Esto es particularmente relevante para algo como JSON, donde es posible que desee serializar datos a JSON en un extremo para enviarlos al otro extremo. Para casos de uso como ese, si usa Java en ambos extremos, ayuda a evitar la introducción de dependencias de Android. *.

O supongo que uno podría tomar el código fuente de Android. * Relevante y agregarlo a su proyecto de servidor, pero no lo he intentado ...

Puede descargar una biblioteca desde http://json.org (Json-lib u org.json) y usarla para analizar / generar el JSON

solo necesitas importar esto

   import org.json.JSONObject;


  constructing the String that you want to send

 JSONObject param=new JSONObject();
 JSONObject post=new JSONObject();

estoy usando dos objetos porque puedes tener un jsonObject dentro de otro

post.put("username(here i write the key)","someusername"(here i put the value);
post.put("message","this is a sweet message");
post.put("image","http://localhost/someimage.jpg");
post.put("time":  "present time");

luego puse la publicación json dentro de otra como esta

  param.put("post",post);

este es el método que uso para hacer una solicitud

 makeRequest(param.toString());

public JSONObject makeRequest(String param)
{
    try
    {

establecer la conexión

        urlConnection = new URL("your url");
        connection = (HttpURLConnection) urlConnection.openConnection();
        connection.setDoOutput(true);
        connection.setRequestMethod("POST");
        connection.setRequestProperty("Content-type", "application/json;charset=UTF-8");
        connection.setReadTimeout(60000);
        connection.setConnectTimeout(60000);
        connection.connect();

establecer el flujo de salida

        dataOutputStream = new DataOutputStream(connection.getOutputStream());

Lo uso para ver en el logcat lo que estoy enviando

        Log.d("OUTPUT STREAM  " ,param);
        dataOutputStream.writeBytes(param);
        dataOutputStream.flush();
        dataOutputStream.close();

        InputStream in = new BufferedInputStream(connection.getInputStream());
        BufferedReader reader = new BufferedReader(new InputStreamReader(in));
        result = new StringBuilder();
        String line;

aquí se construye la cuerda

        while ((line = reader.readLine()) != null)
        {
            result.append(line);
        }

uso este registro para ver qué viene en la respuesta

         Log.d("INPUTSTREAM: ",result.toString());

Instanciar un JSON con la cadena que contiene la respuesta del servidor

        jResponse=new JSONObject(result.toString());

    }
    catch (IOException e) {
        e.printStackTrace();
        return jResponse=null;
    } catch (JSONException e)
    {
        e.printStackTrace();
        return jResponse=null;
    }
    connection.disconnect();
    return jResponse;
}

si está buscando un análisis rápido de json en Android, le sugiero una herramienta que está disponible gratuitamente.

Herramienta JSON Class Creator

Es de uso gratuito y crea su clase de análisis de todos los json en uno o dos segundos ...: D

Aunque los usuarios ya proporcionan respuestas excelentes, como fomentar el uso de GSON, etc., me gustaría sugerir el uso de org.json . Incluye la mayoría de las funcionalidades de GSON. También le permite pasar una cadena json como argumento a su JSONObject y se encargará del resto, por ejemplo:

JSONObject json = new JSONObject("some random json string");

Esta funcionalidad lo convierte en mi favorito personal.

Existen diferentes bibliotecas de código abierto, que puede usar para analizar json.

org.json: - Si desea leer o escribir json, puede usar esta biblioteca. Primero cree JsonObject: -

JSONObject jsonObj = new JSONObject(<jsonStr>);

Ahora, use este objeto para obtener sus valores: -

String id = jsonObj.getString("id");

Puedes ver el ejemplo completo aquí

Jackson databind: - Si desea vincular y analizar su json a una clase POJO particular, puede usar la biblioteca jackson-databind, esto vinculará su json a la clase POJO: -

ObjectMapper mapper = new ObjectMapper();
post= mapper.readValue(json, Post.class);

Puedes ver el ejemplo completo aquí