Parsing JSON avec Jackson sous Android

Date de publication : 05/12/2011.

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

Version PDF (Miroir) Version hors-ligne (Miroir)

1. Qu'est-ce que JSON ?
2. Pourquoi Jackson ?
3. Mise en place du projet
4. Conclusion

1. 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

2. 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.

3. 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.

<?xmlversion="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

packagecom.tutos.android.json.model;

publicclassUser {
    privateString firstname;
    privateString lastname;
    privateString login;
    privateString twitter;
    privateString web;

    publicUser() {
    super();
    this.firstname = "";
    this.lastname = "";
    this.login = "";
    this.twitter = "";
    this.web = "";
    }

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

    publicString getFirstname() {
        returnfirstname;
    }

    publicvoidsetFirstname(String firstName) {
        this.firstname = firstName;
    }

    publicString getLastname() {
        returnlastname;
    }

    publicvoidsetLastname(String lastName) {
        this.lastname = lastName;
    }

    publicString getLogin() {
        returnlogin;
    }

    publicvoidsetLogin(String login) {
        this.login = login;
    }

    publicString getTwitter() {
        returntwitter;
    }

    publicvoidsetTwitter(String twitter) {
        this.twitter = twitter;
    }

    publicString getWeb() {
        returnweb;
    }

    publicvoidsetWeb(String web) {
        this.web = web;
    }

}

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

packagecom.tutos.android.json.model;

importjava.util.ArrayList;
importjava.util.HashMap;

publicclassUsers extendsHashMap<String, ArrayList<User>> {

    privatestaticfinallongserialVersionUID = 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

packagecom.tutos.android.json.model;

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

importorg.codehaus.jackson.JsonFactory;
importorg.codehaus.jackson.JsonParseException;
importorg.codehaus.jackson.JsonParser;
importorg.codehaus.jackson.map.ObjectMapper;

importandroid.os.Environment;

publicclassUsersController {

    privatestaticfinalString DL_URL = "";http://www.tutos-android.com/JSON/users.json

    privateObjectMapper objectMapper = null;
    privateJsonFactory jsonFactory = null;
    privateJsonParser jp = null;
    privateArrayList<User> userList = null;
    privateUsers users = null;
    privateFile jsonOutputFile;
    privateFile jsonFile;

    publicUsersController() {
    objectMapper = newObjectMapper();
    jsonFactory = newJsonFactory();
    }

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

    privatevoiddownloadJsonFile() {
    try{
        createFileAndDirectory();
        URL url = newURL(UsersController.DL_URL);
        HttpURLConnection urlConnection;
        urlConnection = (HttpURLConnection) url.openConnection();
        urlConnection.setRequestMethod("GET");
        urlConnection.setDoOutput(true);
        urlConnection.connect();
        FileOutputStream fileOutput = newFileOutputStream(jsonFile);
        InputStream inputStream = urlConnection.getInputStream();
        byte[] buffer = newbyte[1024];
        intbufferLength = 0;
        while((bufferLength = inputStream.read(buffer)) > 0) {
        fileOutput.write(buffer, 0, bufferLength);
        }
        fileOutput.close();
    } catch(MalformedURLException e) {
        e.printStackTrace();
    } catch(IOException e) {
        e.printStackTrace();
    }
    }

    privatevoidcreateFileAndDirectory() throwsFileNotFoundException {
    finalString extStorageDirectory = Environment
        .getExternalStorageDirectory().toString();
    finalString meteoDirectory_path = extStorageDirectory + "/tutos-android";
    jsonOutputFile = newFile(meteoDirectory_path, "/");
    if(jsonOutputFile.exists() == false)
        jsonOutputFile.mkdirs();
    jsonFile = newFile(jsonOutputFile, "users.json");
    }

    publicArrayList<User> findAll() {
    returnuserList;
    }

    publicUser findById(intid) {
    returnuserList.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

packagecom.tutos.android.json;

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

importcom.tutos.android.json.model.User;
importcom.tutos.android.json.model.UsersController;

publicclassJsonParserMainActivity extendsActivity {
    privateUsersController usersController;
    privateTextView displayJson;

    @Override
    publicvoidonCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    usersController = newUsersController();

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

    Button startParsing = (Button) findViewById(R.id.startParsing);
    startParsing.setOnClickListener(newOnClickListener() {
        @Override
        publicvoidonClick(View view) {
        gettingJson();
        }
    });
    }

    finalvoidgettingJson() {
    finalThread checkUpdate = newThread() {
        publicvoidrun() {
        usersController.init();
        finalStringBuilder str = newStringBuilder("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(newRunnable() {
                @Override
                publicvoidrun() {
                    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

4. 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.

Version PDF (Miroir) Version hors-ligne (Miroir)

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2011 Benbourahla Nazim. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.