L'envoi et l'Analyse des Objets JSON dans Android

Vous pouvez utiliser org.json.JSONObject et org.json.JSONTokener. vous n'avez pas besoin de toutes les bibliothèques externes depuis ces classes viennent avec le kit SDK d'Android

C'est le JsonParser classe

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

Remarque: DefaultHttpClient n'est plus supporté par sdk 23, il est donc conseillé d'utiliser l'objectif sdk 21 du présent code.

D'autres réponses ont noté Jackson et GSON - le populaire add-on JSON bibliothèques pour Android, et json.org le bare-bones JSON package est inclus dans Android.

Mais je pense qu'il est également intéressant de noter que Android a maintenant son propre complet API JSON.

Ceci a été ajouté en Nid d'abeille: API de niveau 11.

Cela comprend

- android.util.JsonReader: docs, et source

- android.util.JsonWriter: docs, et source

Je vais aussi ajouter une autre considération qui me pousse à revenir vers Jackson et GSON: je trouve qu'il est utile d'utiliser la 3ème partie des bibliothèques plutôt que d'android.* les paquets parce que le code que j'ai écris peut être partagé entre le client et le serveur. Ceci est particulièrement pertinent pour quelque chose comme JSON, où vous pouvez souhaiter pour sérialiser les données en JSON sur une extrémité pour l'envoi à l'autre extrémité. Pour utiliser de tels cas, si vous utilisez Java sur les deux extrémités, il contribue à éviter l'introduction d'android.* dépendances.

Ou je suppose que l'on pourrait saisir pertinentes android.* le code source et l'ajouter à votre projet de serveur, mais je n'ai pas essayé...

vous avez juste besoin d'importer ce

   import org.json.JSONObject;
constructing the String that you want to send
JSONObject param=new JSONObject();
JSONObject post=new JSONObject();

im à l'aide de deux objets, car vous pouvez avoir un jsonObject dans un autre

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

puis j'ai mis le post json dans les autres comme cette

  param.put("post",post);

c'est la méthode que j'utilise pour faire une demande de

 makeRequest(param.toString());
public JSONObject makeRequest(String param)
{
try
{

la configuration de la connexion

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

réglage de la outputstream

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

je l'utilise pour voir dans le logcat ce que je suis en envoyant

        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;

ici, la chaîne est construite

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

- je utiliser ce journal pour voir ce que sa venue dans la réponse

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

l'instanciation d'un json avec la Chaîne de caractères qui contient la réponse du serveur

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

Bien qu'il existe déjà d'excellentes réponses sont fournies par des utilisateurs, par exemple en encourageant l'utilisation de GSON etc. Je voudrais suggérer l'utilisation de org.json. Il comprend plus de GSON fonctionnalités. Il vous permet aussi de passer chaîne json comme un argument c'est JSONObject et il prendra soin du reste.e.g:

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

Cette fonctionnalité en faire mon favori personnel.