Dans ce tutoriel, nous allons aborder le parsing de fichiers JSON (JavaScript Object Notation) à l’aide de la bibliothèque Jackson.


Qu’est-ce que JSON ?

JSON est un format léger d’échange de données. Il est facile à écrire et lire, facilement analysable. C’est un format totalement indépendant de tout langage. Ce qui en fait un langage d’échange de données idéal.

Il se base sur deux structures :

  • Une collection de couple “Nom / Valeur”
  • Une liste de valeurs ordonnées

Pourquoi Jackson ?

Pour cet article, nous allons utiliser la bibliothèque Jackson. Vous allez surement vous demandez “Pourquoi Jackson ?”. Tout simplement parce qu’à mon avis c’est la meilleur bibliothèque de parsing JSON en général et aussi sous Android. Ce benchmark vous aidera à être convaincu.
Jackson est une bibliothèque :

  • de Streaming (Lecture / Ecriture)
  • Rapide
  • Puissante
  • Possédant aucune dépendance
  • Open Source
  • Configurable à souhait.

Vous pouvez obtenir plus d’informations sur le site officiel de jackson.

Mise en place du projet

Pour notre projet, nous allons avoir besoin d’un exemple de fichier JSON. Voici notre petit exemple qui sera disponible sur : users.json

{
    "Users": [
        {
            "firstname": "Nazim",
            "lastname": "Benbourahla",
            "login": "n_benbourahla",
            "twitter": "@n_benbourahla",
            "web": ""
        },
        {
            "firstname": "Tutos",
            "lastname": "android",
            "login": "Tutos-android",
            "twitter": "",
            "web": "www.tutos-android.com"
        }
    ]
}

Nous allons créer un projet Android avec les caractéristiques suivantes :

  • Nom du projet : TutosAndroidJsonParser
  • Version du SDK : 2.2
  • Nom de l’application : JSON Parser
  • Package : com.tutos.android.json
  • Activité : JsonParserMainActivity

Nous allons créer un dossier lib à la racine de notre projet dans lequel nous allons mettre les jars de Jackson qui sont disponible ici.
Sans oublier de rajouter les jars au Build Path du projet.

Pour commencer nous allons créer notre vue, qui sera composé d’un bouton et d’un texte pour afficher le JSON.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    >

<Button 
    android:layout_width="match_parent" 
    android:layout_height="wrap_content" 
    android:text="Parser le fichier JSON"
    android:id="@+id/startParsing"
/>

<TextView  
    android:layout_width="match_parent" 
    android:layout_height="wrap_content" 
   	android:id="@+id/jsonDisplay"
    />
</LinearLayout>

Puis nous allons créer nos modèles, correspondant à notre objet User passer dans le JSON.
Voici notre classe User

package com.tutos.android.json.model;

public class User {
    private String firstname;
    private String lastname;
    private String login;
    private String twitter;
    private String web;
    
    public User() {
	super();
	this.firstname = "";
	this.lastname = "";
	this.login = "";
	this.twitter = "";
	this.web = "";
    }
    
    public User(String firstName, String lastName, String login, 
                String twitter, String web) {
	super();
	this.firstname = firstName;
	this.lastname = lastName;
	this.login = login;
	this.twitter = twitter;
	this.web = web;
    }

    public String getFirstname() {
        return firstname;
    }

    public void setFirstname(String firstName) {
        this.firstname = firstName;
    }

    public String getLastname() {
        return lastname;
    }

    public void setLastname(String lastName) {
        this.lastname = lastName;
    }

    public String getLogin() {
        return login;
    }

    public void setLogin(String login) {
        this.login = login;
    }

    public String getTwitter() {
        return twitter;
    }

    public void setTwitter(String twitter) {
        this.twitter = twitter;
    }

    public String getWeb() {
        return web;
    }

    public void setWeb(String web) {
        this.web = web;
    }

}

Puis la liste des utilisateurs, qui correspond tout simplement à une HashMap de correspondance

package com.tutos.android.json.model;

import java.util.ArrayList;
import java.util.HashMap;

public class Users extends HashMap<String, ArrayList<User>> {

    private static final long serialVersionUID = 1L;

}

Une fois notre modèle prêt, nous allons créer une classe qu’on nommera UserController. Cette classe s’occupera de télécharger, parser notre JSON

package com.tutos.android.json.model;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;

import org.codehaus.jackson.JsonFactory;
import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.JsonParser;
import org.codehaus.jackson.map.ObjectMapper;

import android.os.Environment;

public class UsersController {

    private static final String DL_URL = "http://www.tutos-android.com/JSON/users.json";

    private ObjectMapper objectMapper = null;
    private JsonFactory jsonFactory = null;
    private JsonParser jp = null;
    private ArrayList<User> userList = null;
    private Users users = null;
    private File jsonOutputFile;
    private File jsonFile;

    public UsersController() {
	objectMapper = new ObjectMapper();
	jsonFactory = new JsonFactory();
    }

    public void init() {
	downloadJsonFile();
	try {
	    jp = jsonFactory.createJsonParser(jsonFile);
	    users = objectMapper.readValue(jp, Users.class);
	    userList = users.get("Users");
	} catch (JsonParseException e) {
	    e.printStackTrace();
	} catch (IOException e) {
	    e.printStackTrace();
	}
    }
    
    private void downloadJsonFile() {
	try {
	    createFileAndDirectory();
	    URL url = new URL(UsersController.DL_URL);
	    HttpURLConnection urlConnection;
	    urlConnection = (HttpURLConnection) url.openConnection();
	    urlConnection.setRequestMethod("GET");
	    urlConnection.setDoOutput(true);
	    urlConnection.connect();
	    FileOutputStream fileOutput = new FileOutputStream(jsonFile);
	    InputStream inputStream = urlConnection.getInputStream();
	    byte[] buffer = new byte[1024];
	    int bufferLength = 0;
	    while ((bufferLength = inputStream.read(buffer)) > 0) {
		fileOutput.write(buffer, 0, bufferLength);
	    }
	    fileOutput.close();
	} catch (MalformedURLException e) {
	    e.printStackTrace();
	} catch (IOException e) {
	    e.printStackTrace();
	}
    }
    
    private void createFileAndDirectory() throws FileNotFoundException {
	final String extStorageDirectory = Environment
		.getExternalStorageDirectory().toString();
	final String meteoDirectory_path = extStorageDirectory + "/tutos-android";
	jsonOutputFile = new File(meteoDirectory_path, "/");
	if (jsonOutputFile.exists() == false)
	    jsonOutputFile.mkdirs();
	jsonFile = new File(jsonOutputFile, "users.json");
    }

    public ArrayList<User> findAll() {
	return userList;
    }

    public User findById(int id) {
	return userList.get(id);
    }

}

Cette classe s’occupera de :

  • Créer un dossier “tutos-android” sur le téléphone, puis un fichier users.json (createFileAndDirectory)
  • Ouvrir une connexion avec le serveur pour lire le contenu du JSON et le recopier localement (downloadJsonFile)
  • Initialise notre parseur, à l’aide du fichier JSON local
     jp = jsonFactory.createJsonParser(jsonFile);
    
  • Lecture des valeurs portant la balise “Users
    users = objectMapper.readValue(jp, Users.class);
  • Récupération de la liste des utilisateurs

    userList = users.get("Users");

Comme vous venez de le remarquer, parser un fichier JSON est très simple et rapide.

Pour finir, nous allons implémenter notre activité pour :

  • Télécharger notre fichier JSON
  • Afficher le résultat dans le TextView
package com.tutos.android.json;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.TextView;

import com.tutos.android.json.model.User;
import com.tutos.android.json.model.UsersController;

public class JsonParserMainActivity extends Activity {
    private UsersController usersController;
    private TextView displayJson;

    @Override
    public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.main);
	usersController = new UsersController();

	displayJson = (TextView) findViewById(R.id.jsonDisplay);

	Button startParsing = (Button) findViewById(R.id.startParsing);
	startParsing.setOnClickListener(new OnClickListener() {
	    @Override
	    public void onClick(View view) {
		gettingJson();
	    }
	});
    }

    final void gettingJson() {
	final Thread checkUpdate = new Thread() {
	    public void run() {
		usersController.init();
		final StringBuilder str = new StringBuilder("user : ");
		for (User u : usersController.findAll()) {
		    str.append("\n").append("first name : ").append(u.getFirstname());
		    str.append("\n").append("last name : ").append(u.getLastname());
		    str.append("\n").append("login : ").append(u.getLogin());
		    str.append("\n").append("twitter : ").append(u.getTwitter());
		    str.append("\n").append("Web : ").append(u.getWeb());
		}
		runOnUiThread(new Runnable() {
		        @Override
		        public void run() {
		            displayJson.setText(str.toString());
		        }
		    });
		
	    }
	};
	checkUpdate.start();
    }

}

Ce qui vous donnera le résultat suivant :

Pour finir je vous fournit le zip contenant le projet, vous pouvez le télécharger ici

Conclusion

Ce tutoriel s’arrête ici en espérant qu’il vous a aidé a comprendre comment fonctionne le parsing JSON sous Android, l’utilité de la bibliothèque Jackson ainsi que l’avantage que peux procurer JSON sur d’autres formats disponibles comme XML par exemple.

Categories: Tutoriels

42 Responses so far.


  1. sabri dit :

    slt,
    merci pour ce projet ,
    j’ai telechargé ce projet et j’ai l’executé avec AVD2.2—> mais un msg s’affiche :”the application JSON Parser (process com.tutos.android.json) has stopped unexpectedly.Please try again.Force close”
    (il n’affiche pas que ce message)
    note: je fait que le telechargemnet et l’execution !
    SVP aidez moi !!!! je besoin de vos réponses SVP !!!

    • Attar oussama dit :

      tu peut tout simplement crée un nouveau projet android avec la version que vous désirer(2.1 ou 2.2 par exemple ) et tu dois crée tous les classes qui existe dans le projet télécharger , et tu n’a qu a copier coller le code , après tu dois copier les ressources disponible tels que les images s il y on a quelque un ou tu dois crée un fichier ressources row s il y on un a l ancien projet .

      finalement tu dois implémenter la bibliothèque jackson car elle est nécaissaire pour exécuter un projet , alors tu dois chercher comment implementer une bibliotheque JACKSON , (c est facile juste tu dois telecharger un fichier zip et tu dois l integrer a ton projet on cliquant avec la droite sur ton projet > build path>add external archive , et tu pointe sur l archive télécharger de JACKSON , et tu remarque l ajout de la bib dans ton projet )

      et finalement n oublie pas de recopier le contenu du manifeste de l ancien projet dans le nouveau et tu exécute et ca marche
      cet méthode et valable presque pour tous les projet télécharger de internet .
      et si le projet marchera , tu dois comparer entre l arboraissance du projet de l ancien et du nouveau pour comprendre ou consiste le pblm et pkoi ça n ‘a pas marcher

  2. Maitre dit :

    08-06 10:54:06.370: E/AndroidRuntime(328): FATAL EXCEPTION: Thread-8
    08-06 10:54:06.370: E/AndroidRuntime(328): java.lang.NullPointerException
    08-06 10:54:06.370: E/AndroidRuntime(328): at com.tutos.android.json.JsonParserMainActivity$2.run(JsonParserMainActivity.java:39)

  3. Maitre dit :

    Le logcat :
    08-06 10:54:06.370: E/AndroidRuntime(328): FATAL EXCEPTION: Thread-8
    08-06 10:54:06.370: E/AndroidRuntime(328): java.lang.NullPointerException
    08-06 10:54:06.370: E/AndroidRuntime(328): at com.tutos.android.json.JsonParserMainActivity$2.run(JsonParserMainActivity.java:39)

  4. Cédric dit :

    Hello.
    Bon tuto mais j’ai trouvé une solution bien plus simple, la librairie google-gson.
    http://code.google.com/p/google-gson/

    Elle permet de convertir du JSON en Objet Java et vice versa, et ce en 2 lignes.
    Il suffit simplement d’avoir bien déclarer sa classe au préalable.

    Exemple extrait du site:

    Object Examples

    class BagOfPrimitives {
    private int value1 = 1;
    private String value2 = “abc”;
    private transient int value3 = 3;
    BagOfPrimitives() {
    // no-args constructor
    }
    }

    (Serialization)
    BagOfPrimitives obj = new BagOfPrimitives();
    Gson gson = new Gson();
    String json = gson.toJson(obj);
    ==> json is {“value1″:1,”value2″:”abc”}

    Note that you can not serialize objects with circular references since that will result in infinite recursion.

    (Deserialization)
    BagOfPrimitives obj2 = gson.fromJson(json, BagOfPrimitives.class);
    ==> obj2 is just like obj

    • yasso dit :

      J’ai fais de même dans mon application sauf que j’ai le message d’erreur suivant:
      09-25 21:36:27.852: E/AndroidRuntime(771): java.lang.NoClassDefFoundError: com.google.gson.Gson

      Comment vous avez l’intégrer dans votre application

  5. julien dit :

    Salut à toi et merci beaucoup pour ce tuto, il m’a été d’une grande utilité …
    je t’écris car dans mon cas le JSON est “un peu” plus hard et je m’emmele les pinceaux quand à l’ArrayList final… je m’explique :
    Un fichier JSON de traduction est composé d’items (des objets langues avec seulement des Strings), ainsi que d’autres String d’info, et d’autre items divers. On peut voir donc que par rapport à ton exemple, on peut dire que j’ai une couche de plus à traverser pour aller lire le bloc d’item “Langue” (parralellement à ton bloc Users). En gros ca donne ca:
    Fichier JSON:
    ////////
    String a
    String b
    String c
    Langue:{
    langue a
    langue b

    langue i
    }
    Item a
    Item b

    Item i
    ////////

    J’ai créée une classe hasmap d’objet Langue, les items Item a/b…./i sont des classes aussi, tout est défini, mon problème est que je n’arrive pas à voir comment changer ces lignes de codes là de ton tuto(dans le UserController) :
    jp = jsonFactory.createJsonParser(jsonFile);
    users = objectMapper.readValue(jp, Users.class);
    userList = users.get(“Users”);

    En espérant que quelqu’un puisse m’aider, car là le vendredi soir je commence à saturer aha !!

    • Maitre dit :

      Bonjour
      merci pour le tuto
      J’ai un probleme :
      apres que je clic sur le bouton” parser le fichier JSON ” , il affiche le message
      le système affiche un message d’erreur et ferme l’application ( force close)

      • Maitre dit :

        Logcat :

        08-06 10:54:06.370: E/AndroidRuntime(328): FATAL EXCEPTION: Thread-8
        08-06 10:54:06.370: E/AndroidRuntime(328): java.lang.NullPointerException
        08-06 10:54:06.370: E/AndroidRuntime(328): at com.tutos.android.json.JsonParserMainActivity$2.run(JsonParserMainActivity.java:39)

Leave a Reply


Notifiez-moi des commentaires à venir via email. Vous pouvez aussi vous abonner sans commenter.