Developpez.com - JavaScript
X

Choisissez d'abord la catégorieensuite la rubrique :


Parsing JSON avec Jackson sous Android

Date de publication : 05/12/2011.

Par Nazim Benbourahla
 

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)
Viadeo Twitter Facebook Share on Google+        



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 :


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 :

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 :

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 :

jp = jsonFactory.createJsonParser(jsonFile);
users = objectMapper.readValue(jp, Users.class);
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 :

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)

Valid XHTML 1.0 TransitionalValid CSS!

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

Responsable bénévole de la rubrique JavaScript : Xavier Lecomte -