La bibliothèque JSON appelée " Jackson " permet de construire :

• la chaîne JSON d'un objet : new ObjectMapper().writeValueAsString(object) ;
• un objet à partir d'un chaîne JSON : new ObjectMapper().readValue(jsonString, Object.class).

Les deux méthodes sont susceptibles de lancer une IOException. Voici un exemple.

Soit la classe [Personne] suivante :

 

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.

package istia.st.jsondemo;

public class Personne {
  // data
  private String nom;
  private String prenom;
  private int age;
  
  // constructeurs
  public Personne(){
    
  }
  
  public Personne(String nom, String prénom, int âge){
    this.nom=nom;
    this.prenom=prénom;
    this.age=âge;
  }
  
  // signature
  public String toString(){
    return String.format("Personne[%s, %s, %d]", nom, prenom, age);
  }
  
  // getters et setters
...  
}

et la classe principale suivante :

 

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.

package istia.st.json;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.type.TypeReference;

public class App {

    static ObjectMapper mapper = new ObjectMapper();

    public static void main(String[] args) throws IOException {
        // création d'une personne
        Personne paul = new Personne("Denis", "Paul", 40);
        // affichage Json
        String json = mapper.writeValueAsString(paul);
        System.out.println("Json=" + json);
        // instanciation Personne à partir du Json
        Personne p = mapper.readValue(json, Personne.class);
        // affichage personne
        System.out.println("Personne=" + p);
        // un tableau
        Personne virginie = new Personne("Radot", "Virginie", 20);
        Personne[] personnes = new Personne[] { paul, virginie };
        // affichage Json
        json = mapper.writeValueAsString(personnes);
        System.out.println("Json personnes=" + json);
        // dictionnaire
        Map<String, Personne> hpersonnes = new HashMap<String, Personne>();
        hpersonnes.put("1", paul);
        hpersonnes.put("2", virginie);
        // affichage Json
        json = mapper.writeValueAsString(hpersonnes);
        System.out.println("Json hpersonnes=" + json);
        // relecture du Json
        Map<String, Personne> map = mapper.readValue(json, new TypeReference<Map<String, Object>>() {
        });
        System.out.println("Personne=" + map.get("1"));
    }
}

Les affichages écran sont les suivants :

 

Sélectionnez

1.
2.
3.
4.
5.

Json={"prenom":"Paul","age":40,"nom":"Denis"}
Personne=Personne[Denis, Paul, 40]
Json personnes=[{"prenom":"Paul","age":40,"nom":"Denis"},{"prenom":"Virginie","age":20,"nom":"Radot"}]
Json hpersonnes={"2":{"prenom":"Virginie","age":20,"nom":"Radot"},"1":{"prenom":"Paul","age":40,"nom":"Denis"}}
Personne={prenom=Paul, age=40, nom=Denis}

De l'exemple on retiendra :

• l'objet [ObjectMapper] nécessaire aux transformations JSON / Object : ligne 12 ;
• la transformation JSON --> [Personne] : ligne 21 ;
• la transformation [Personne] --> JSON : ligne 18 ;
• l'exception [IOException] lancée par les deux méthodes : ligne 14 ;
• ligne 38 : la classe [TypeReference] permet d'obtenir l'objet Class d'un type Java complexe.

La bibliothèque Gson de Google est analogue mais légèrement différente. Le programme précédent s'écrit comme suit :

 

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.

package istia.st.json;

import java.util.HashMap;
import java.util.Map;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

public class App {

    static Gson gson = new Gson();

    public static void main(String[] args){
    // création d'une personne
    Personne paul = new Personne("Denis", "Paul", 40);
    // affichage Json
    String json = gson.toJson(paul);
    System.out.println("Json=" + json);
    // instanciation Personne à partir du Json
    Personne p = gson.fromJson(json, Personne.class);
    // affichage personne
    System.out.println("Personne=" + p);
    // un tableau
    Personne virginie=new Personne("Radot", "Virginie", 20);
    Personne[] personnes=new Personne[]{paul,virginie};
    // affichage Json
    json=gson.toJson(personnes);
    System.out.println("Json personnes="+json);
    // dictionnaire
    Map<String,Personne> hpersonnes=new HashMap<String,Personne>();
    hpersonnes.put("1",paul);
    hpersonnes.put("2",virginie);
    // affichage Json
    json=gson.toJson(hpersonnes);
    System.out.println("Json hpersonnes="+json);
    // relecture du Json
        Map<String, Personne> map = gson.fromJson(json, new TypeToken<Map<String, Personne>>() {
        }.getType());
        System.out.println("Personne="+map.get("1"));
  }
}

• les exceptions lancées par la bibliothèque Gson ne sont pas contrôlées par le compilateur. On n'a donc pas de try / catch ou de throws Exception ;
• ligne 17 : la méthode toJson permet d'obtenir la représentation JSON d'un objet ;
• ligne 20 : la méthode fromJson permet de créer un objet à partir de sa représentation JSON ;
• ligne 37 : on notera la classe TypeToken qui permet d'obtenir l'objet Class d'un type Java complexe.

L'affichage écran obtenu est le suivant :

 

Sélectionnez

1.
2.
3.
4.
5.

Json={"nom":"Denis","prenom":"Paul","age":40}
Personne=Personne[Denis, Paul, 40]
Json personnes=[{"nom":"Denis","prenom":"Paul","age":40},{"nom":"Radot","prenom":"Virginie","age":20}]
Json hpersonnes={"2":{"nom":"Radot","prenom":"Virginie","age":20},"1":{"nom":"Denis","prenom":"Paul","age":40}}
Personne=Personne[Denis, Paul, 40]

Plutôt qu'installer un Eclipse brut, nous allons installer SpringSource Tool Suite [http://www.springsource.com/developer/sts], un Eclipse prééquipé avec de nombreux plugins liés au framework Spring et également avec une configuration Maven préinstallée.

• aller sur le site de SpringSource Tool Suite (STS) [1], pour télécharger la version courante de STS [2A] [2B],
• le fichier téléchargé est un installateur qui crée l'arborescence de fichiers [3A] [3B]. En [4], on lance l'exécutable,
• en [5], la fenêtre de travail de l'IDE après avoir fermé la fenêtre de bienvenue. En [6], on fait afficher la fenêtre des serveurs d'applications,
• en [7], la fenêtre des serveurs. Un serveur est enregistré. C'est un serveur VMware que nous n'utiliserons pas. En [8], on appelle l'assistant d'ajout d'un nouveau serveur,
• en [9A], divers serveurs nous sont proposés. Nous choisissons d'installer un serveur Tomcat 7 d'Apache [9B],
• en [10], nous désignons le dossier d'installation du serveur Tomcat 7 installé. Si on n'a pas de serveur Tomcat, utiliser le bouton [11],
• en [12], le serveur Tomcat apparaît dans la fenêtre [Servers],
• en [13], nous lançons le serveur,
• en [14], il est lancé,
• en [15], on l'arrête.

Dans la fenêtre [Console], on obtient les logs suivants de Tomcat si tout va bien :

 

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

mai 26, 2012 8:56:51 AM org.apache.catalina.core.AprLifecycleListener init
Infos: The APR based Apache Tomcat Native library which allows optimal performance in production environments was not found on the java.library.path: ...
mai 26, 2012 8:56:55 AM org.apache.coyote.AbstractProtocol init
Infos: Initializing ProtocolHandler ["http-bio-8080"]
mai 26, 2012 8:56:55 AM org.apache.coyote.AbstractProtocol init
Infos: Initializing ProtocolHandler ["ajp-bio-8009"]
mai 26, 2012 8:56:55 AM org.apache.catalina.startup.Catalina load
Infos: Initialization processed in 4527 ms
mai 26, 2012 8:56:55 AM org.apache.catalina.core.StandardService startInternal
Infos: Démarrage du service Catalina
mai 26, 2012 8:56:55 AM org.apache.catalina.core.StandardEngine startInternal
Infos: Starting Servlet Engine: Apache Tomcat/7.0.22
mai 26, 2012 8:56:57 AM org.apache.catalina.util.SessionIdGenerator createSecureRandom
Infos: Creation of SecureRandom instance for session ID generation using [SHA1PRNG] took [218] milliseconds.
mai 26, 2012 8:56:57 AM org.apache.coyote.AbstractProtocol start
Infos: Starting ProtocolHandler ["http-bio-8080"]
mai 26, 2012 8:56:57 AM org.apache.coyote.AbstractProtocol start
Infos: Starting ProtocolHandler ["ajp-bio-8009"]
mai 26, 2012 8:56:57 AM org.apache.catalina.startup.Catalina start
Infos: Server startup in 2252 ms

• toujours dans la fenêtre [Servers], on ajoute un nouveau serveur [16],
• en [17], le serveur Glassfish n'est pas proposé,
• dans ce cas, on utilise le lien [18],
• en [19], on choisit d'ajouter un adaptateur pour le serveur Glassfish,
• celui est téléchargé et de retour dans la fenêtre [Servers], on ajoute un nouveau serveur,
• cette fois-ci en [21], les serveurs Glassfish sont proposés,
• en [22], on choisit le serveur Glassfish 3.1.2 téléchargé avec Netbeans,
• en [23], on désigne le dossier d'installation de Glassfish 3.1.2 (faire attention au chemin indiqué en [24]),
• si on n'a pas de serveur Glassfish, utiliser le bouton [25],
• en [26], l'assistant nous demande le mot de passe de l'administrateur du serveur Glassfish. Pour une première installation, c'est normalement adminadmin,
• lorsque l'assistant est terminé, dans la fenêtre [Servers], le serveur Glassfish apparaît [27],
• en [28], on le lance,
• en [29] un problème peut survenir. Cela dépend des informations données à l'installation. Glassfish veut un JDK (Java Development Kit) et non pas un JRE (Java Runtime Environment),
• pour avoir accès aux propriétés du serveur Glassfish, on double-clique dessus dans la fenêtre [Servers],
• on obtient la fenêtre [20] dans laquelle on suit le lien [Runtime Environment],
• en [31], on va remplacer le JRE utilisé par défaut par un JDK. Pour cela, on utilise le lien [32],
• en [33], les JRE installés sur la machine,
• en [34], on en ajoute un autre,
• en [35], on choisit [Standard VM] (Virtual Machine),
• en [36], on sélectionne d'un JDK (>=1.6),
• en [37], le nom donné au nouveau JRE,
• revenu au choix du JRE pour Glassfish, nous choisissons le nouveau JRE déclaré [38],
• une fois l'assistant de configuration terminé, on relance [Glassfish] [39],
• en [40], il est lancé,
• en [41], l'arborescence du serveur,
• en [42], on accède aux logs de Glassfish :

 

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

...
Infos: Running GlassFish Version: GlassFish Server Open Source Edition 3.1.2 (build 23)

Infos: Grizzly Framework 1.9.46 started in: 125ms - bound to [0.0.0.0:7676]
Infos: Grizzly Framework 1.9.46 started in: 125ms - bound to [0.0.0.0:3700]
Infos: Grizzly Framework 1.9.46 started in: 188ms - bound to [0.0.0.0:8080]
Infos: Grizzly Framework 1.9.46 started in: 141ms - bound to [0.0.0.0:4848]
Infos: Grizzly Framework 1.9.46 started in: 141ms - bound to [0.0.0.0:8181]
Infos: Registered org.glassfish.ha.store.adapter.cache.ShoalBackingStoreProxy for persistence-type = replicated in BackingStoreFactoryRegistry

Infos: GlassFish Server Open Source Edition 3.1.2 (23) heure de démarrage : Felix (13 790 ms), services de démarrage (2 028 ms), total (15 818 ms)

Infos: JMX005: JMXStartupService had Started JMXConnector on JMXService URL service:jmx:rmi://Gportpers3.ad.univ-angers.fr:8686/jndi/rmi://Gportpers3.ad.univ-angers.fr:8686/jmxrmi

• en [43], nous arrêtons le serveur Glassfish.

• en [1], pourquoi on a besoin du SDK d'Android ;
• en [2], on est dans le cadre d'un IDE déjà installé ;

On trouvera le SDK Manager d'Android à l'adresse [http://developer.android.com/sdk/index.html] (mars 2013). Faire l'installation du SDK. Une fois installé, le lancer. L'assistant suivant s'affiche :

• télécharger les quatre paquetages ci-dessus ;

La suite se fait sous Eclipse.

• en [1], sélectionner l'option Help / Eclipse Marketplace ;
• en [2], dans la zone de recherche, mettre les mots clés [android maven] pour obtenir les outils Maven pour Android ;
• en [3], choisir l'application [Android Configurator for M2E] et l'installer [4] ;
• en [5], désélectionner [m2e], les outils Maven pour Eclipse qui sont déjà installés puis aller jusqu'au bout de l'assistant. Redémarrer Eclipse ;

Ceci fait, on configure le plugin Android :

• en [1], choisir l'option Window / Preferences ;
• en [2], indiquez le répertoire d'installation du SDK Manager d'Android qui a été installé précédemment, puis valider ;

Nous allons créer un premier projet Android :

• en [1], créer un nouveau projet de type Android [2] ;
• donner les trois informations ci-dessus et aller jusqu'au bout de l'assistant en acceptant les valeurs proposées par défaut ;
• en [4], utiliser l'option Run / Run Configurations pour définir une configuration d'exécution pour le projet Android ;
• en [5], sélectionner le type [Android Application] et cliquer l'icône + ;
• en [6], mettre le nom du projet à exécuter ;
• en [7], donner un nom quelconque à cette configuration ;
• en [8], sélectionner l'onglet [Target] ;
• en [9], il nous faut définir un émulateur de tablette Android ;
• pour cela, on utilise le bouton [10] ;
• en [11], on crée un nouvel émulateur ;
• en [12], donner un nom à l'émulateur de la tablette ;
• en [13], choisir l'objet à émuler, une tablette ;
• en [14], choisir l'API d'Android à utiliser. Précédemment, lors de l'installation du SDK Manager, une seule API a été téléchargée. C'est celle qui est proposée ;
• en [15], la saisie n'est pas possible. [Intel Atom] est l'un des quatre paquetages que nous avons téléchargés. Valider le tout ;
• de retour dans le gestionnaire de configuration, le nouvel émulateur doit apparaître en [16]. Utiliser [17] si ce n'est pas le cas ;
• en [18], on exécute le projet Android [exemple1] avec cette configuration ;

L'émulateur est alors lancé et l'interface visuelle du projet affichée :

Pour créer un projet Maven Android, on pourra suivre la démarche suivante :

• en [1] et [2], créer un nouveau projet Android comme il a été fait précédemment pour le projet [exemple1] ;
• en [3], ajouter à la racine du projet le fichier [pom.xml] suivant (faire un copier / coller à partir de ce document) :

 

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>exemples</groupId>
    <artifactId>exemple2</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>apk</packaging>

    <properties>
        <platform.android.version>4.1.1.4</platform.android.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.google.android</groupId>
            <artifactId>android</artifactId>
            <version>${platform.android.version}</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>com.jayway.maven.plugins.android.generation2</groupId>
                <artifactId>android-maven-plugin</artifactId>
                <version>3.1.1</version>
                <configuration>
                    <androidManifestFile>${project.basedir}/AndroidManifest.xml</androidManifestFile>
                    <assetsDirectory>${project.basedir}/assets</assetsDirectory>
                    <resourceDirectory>${project.basedir}/res</resourceDirectory>
                    <nativeLibrariesDirectory>${project.basedir}/src/main/native</nativeLibrariesDirectory>
                    <sdk>
                        <platform>16</platform>
                    </sdk>
                    <undeployBeforeDeploy>true</undeployBeforeDeploy>
                    <proguard>
                        <skip>true</skip>
                    </proguard>
                </configuration>
                <extensions>true</extensions>
            </plugin>

            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

• puis en [4], convertir le projet en projet [Maven]  puis l'exécuter comme il a été fait pour le projet [exemple1] ;

Importer l'exemple 1 du document dans Eclipse :

• en [1] importer un projet de type [Maven] [2] ;
• en [3], désigner le dossier du projet et l'importer ;
• en [4], le projet importé présente une erreur. Il lui manque la dépendance Maven [android-avat] ;

En suivant la même démarche, importer le projet manquant :

• en [5], le projet [android-avat-exemple1] ne présente plus d'erreurs ;
• en suivant la démarche vue précédemment, créer une configuration d'exécution [6] pour ce projet puis l'exécuter :

La configuration qui suit a été faite avec une tablette Samsung Galaxy Tab 2 10.1.

• on doit configurer la tablette en mode développement [ Paramètres / Système / Options de développement / Débogage / Débogage USB coché]. Cela permet d'installer sur la tablette une application Android à partir du port USB de l'ordinateur de développement ;
• brancher la tablette sur le port USB de l'ordinateur de développement ;

Charger comme il a été décrit l'application exemple [android-avat-exemple1] et modifier sa configuration d'exécution de la façon suivante :

• en [1], on demande qu'à l'exécution on nous laisse choisir où elle doit s'exécuter ;
• on lance l'exécution et en [2], Eclipse nous propose deux cibles :
• l'émulateur déjà utilisé (ligne 1),
• la tablette qu'on a connectée au port USB et qu'il a reconnue. On la sélectionne. L'application est alors transférée sur la tablette et exécutée.

Dans le cas des applications client / serveur des exemples 2 et 7 :

• le serveur est sur le PC ;
• le client est sur la tablette ;

Pour qu'ils se voient, le plus simple est de les mettre sur le même réseau Wifi. Sur le PC, il faut désactiver le pare-feu voire parfois l'antivirus.

[WampServer] est un ensemble de logiciels pour développer en PHP / MySQL / Apache sur une machine Windows. Nous l'utiliserons uniquement pour le SGBD MySQL.

• sur le site de [WampServer] [1], choisir la version qui convient [2],
• l'exécutable téléchargé est un installateur. Diverses informations sont demandées au cours de l'installation. Elles ne concernent pas MySQL. On peut donc les ignorer. La fenêtre [3] s'affiche à la fin de l'installation. On lance [WampServer],
• en [4], l'icône de [WampServer] s'installe dans la barre des tâches en bas et à droite de l'écran [4],
• lorsqu'on clique dessus, le menu [5] s'affiche. Il permet de gérer le serveur Apache et le SGBD MySQL. Pour gérer celui-ci, on utiliser l'option [PhpPmyAdmin],
• on obtient alors la fenêtre ci-dessous,

Nous donnerons peu de détails sur l'utilisation de [PhpMyAdmin]. Nous montrerons dans le document comment l'utiliser pour créer la base de données de l'application exemple 7.