Enviando e analisando objetos JSON no Android [fechado]

Gostaria de enviar mensagens no formato de objetos JSON para um servidor e analisar a resposta JSON do servidor.

Exemplo de objeto JSON

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

Eu estou tentando analisar o JSON manualmente, indo atributo por atributo. Existe alguma biblioteca / utilitário que eu possa usar para facilitar esse processo?

Estou surpreso que isso não tenha sido mencionado: mas, em vez de usar um processo manual e simples com o pequeno pacote do json.org, GSon e Jackson são muito mais convenientes de usar. Assim:

• GSON
• Jackson

Portanto, você pode vincular-se aos seus próprios POJOs, não a alguns nós de árvore de meia-boca ou Listas e Mapas. (e pelo menos Jackson também permite a vinculação a essas coisas (talvez GSON também, não tenho certeza), JsonNode, Map, List, se você realmente deseja esses objetos em vez de objetos 'reais')

EDIT 19-MAR-2014:

Outro novo candidato é a biblioteca Jackson jr : ela usa o mesmo analisador / gerador de Streaming rápido que Jackson ( jackson-core), mas a parte de ligação de dados é minúscula (50kB). A funcionalidade é mais limitada (sem anotações, apenas Java Beans regulares), mas em termos de desempenho deve ser rápida e a sobrecarga de inicialização (primeira chamada) também muito baixa. Portanto, pode ser uma boa escolha, especialmente para aplicativos menores.

Você pode usar org.json.JSONObject e org.json.JSONTokener . você não precisa de bibliotecas externas, pois essas classes vêm com o Android SDK

O GSON é mais fácil de usar e o caminho a percorrer se os dados tiverem uma estrutura definida.

Faça o download do gson .

Adicione-o às 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 da classe Post

package com.tut.JSON;

public class Post {

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

Esta é a classe 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 não é mais suportado pelo sdk 23, portanto, é aconselhável usar o destino sdk 21 com esse código.

Não há realmente nada no JSON. Os colchetes são para "objetos" (matrizes associativas) e os colchetes são para matrizes sem chaves (indexados numericamente). Quanto a trabalhar com ele no Android, existem aulas prontas para as incluídas no sdk (não é necessário fazer o download).

Confira estas classes: http://developer.android.com/reference/org/json/package-summary.html

Outras respostas observaram Jackson e GSON - as populares bibliotecas JSON de expansão para Android e json.org, o pacote JSON básico incluído no Android.

Mas acho que também vale a pena notar que o Android agora tem sua própria API JSON com todos os recursos.

Isso foi adicionado ao Honeycomb: API level 11.

Isso inclui
- android.util.JsonReader: docs e source
- android.util.JsonWriter: docs e source

Também acrescentarei uma consideração adicional que me leva de volta a Jackson e GSON: achei útil usar bibliotecas de terceiros em vez de pacotes android. * Porque, então, o código que escrevo pode ser compartilhado entre cliente e servidor. Isso é particularmente relevante para algo como JSON, em que você pode querer serializar dados para JSON em uma extremidade para enviar para a outra extremidade. Para casos de uso como esse, se você usa Java nas duas extremidades, ajuda a evitar a introdução de dependências android. *.

Ou eu acho que alguém poderia pegar o código-fonte relevante do Android. * E adicioná-lo ao seu projeto de servidor, mas eu não tentei isso ...

Você pode fazer o download de uma biblioteca em http://json.org (Json-lib ou org.json) e usá-la para analisar / gerar o JSON

você só precisa importar isso

   import org.json.JSONObject;


  constructing the String that you want to send

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

estou usando dois objetos porque você pode ter um jsonObject dentro de outra

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

então eu coloquei o post json dentro de outro assim

  param.put("post",post);

este é o método que eu uso para fazer uma solicitação

 makeRequest(param.toString());

public JSONObject makeRequest(String param)
{
    try
    {

configurando a conexão

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

definindo o fluxo de saída

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

eu uso isso para ver no logcat o que estou 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;

aqui a corda é construída

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

eu uso esse log para ver o que está chegando na resposta

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

instanciando um json com a String que contém a resposta do 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;
}

Se você está procurando uma análise rápida do json no android, sugiro uma ferramenta disponível gratuitamente.

Ferramenta JSON Class Creator

É de uso gratuito e cria sua classe all json parsing dentro de um a dois segundos ..: D

Embora já existam respostas excelentes para os usuários, como incentivar o uso do GSON, etc. Gostaria de sugerir o uso do org.json . Inclui a maioria das funcionalidades do GSON. Ele também permite que você passe a string json como argumento para o JSONObject e cuidará do resto, por exemplo:

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

Essa funcionalidade o torna meu favorito pessoal.

Existem diferentes bibliotecas de código aberto, que você pode usar para analisar o json.

org.json: - Se você quiser ler ou escrever json, poderá usar esta biblioteca. Primeiro crie o JsonObject: -

JSONObject jsonObj = new JSONObject(<jsonStr>);

Agora, use este objeto para obter seus valores: -

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

Você pode ver um exemplo completo aqui

Jackson databind: - Se você deseja vincular e analisar seu json a uma determinada classe POJO, pode usar a biblioteca jackson-databind, isso vinculará seu json à classe POJO: -

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

Você pode ver um exemplo completo aqui