Android pour les développeurs J2EE

Un modèle asynchrone pour les clients web

V. AVAT- Exemple 2▲

V-A. Le projet▲

Nous nous proposons de créer une application Android faisant la même chose que précédemment mais dans une architecture client / serveur . Le client sera le suivant :

C'est le serveur qui génèrera les nombres aléatoires affichés par la tablette Android :

La couche [métier] aura une méthode de génération de nombres aléatoires exposée au monde web via un service REST.

La couche AVAT du client va rester celle que l'on vient de décrire. Les tâches asynchrones vont bouger un peu : elles exécutent maintenant une méthode de la couche [métier] du client. Nous allons décrire l'application dans l'ordre suivant :

Le serveur

sa couche [métier] ;
son service REST ;

Le client

sa couche [DAO] ;
sa couche [métier] ;
sa tâche asynchrone.

Le reste ne change pas.

V-B. Le manifeste de l'application Android▲

Le fichier [AndroidManifest.xml] du projet est un peu différent de celui du projet précédent :

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.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="istia.st.avat.exemples"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="11"
        android:targetSdkVersion="16" />

    <uses-permission android:name="android.permission.INTERNET" />

    <application
        android:allowBackup="true"
        android:icon="@drawable/fleur"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="istia.st.avat.exemples.activity.MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

La ligne important est la ligne 11. C'est elle qui permet au client Android d'ouvrir des connexions réseau. Si on l'oublie, ça ne marche pas mais les messages d'erreur ne sont pas toujours explicites quant à la cause de l'erreur.

V-C. Le serveur▲

V-C-1. La couche [métier]▲

C'est elle qui génère les nombres aléatoires.

V-C-1-a. Le projet Eclipse▲

Le projet Eclipse de la couche [métier] est le suivant :

en [1], le projet est un projet [Maven] ;
en [2] :
[IMetier] est l'interface de la couche [métier] ;
[Metier] l'implémentation de cette interface ;
[ServerException] une classe d'exception.

V-C-1-b. Les dépendances Maven▲

Le fichier [pom.xml] est le suivant :

Sélectionnez

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

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>istia.st.avat.server</groupId>
  <artifactId>server-metier</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <build>
    <sourceDirectory>src</sourceDirectory>
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.0</version>
        <configuration>
          <source/>
          <target/>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

Il n'y a aucune dépendance.

V-C-1-c. L'interface [IMetier]▲

Le code de l'interface est le suivant :

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.

package istia.st.avat.server;

public interface IMetier {

    // génération d'un nombre aléatoire
    public abstract int randomNumber(int a, int b);

}

ligne 6 : la méthode qui génère un nombre aléatoire entre [a,b]

V-C-1-d. L'implémentation [Metier]▲

Le code de la classe [Metier] est le suivant :

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.

package istia.st.avat.server;

import java.io.Serializable;
import java.util.Random;

public class Metier implements Serializable, IMetier {

    private static final long serialVersionUID = 1L;

    public Metier() {
    }

    // génération d'un nombre aléatoire
    /* (non-Javadoc)
     * @see istia.st.avat.server.IMetier#randomNumber(int, int)
     */
    public int randomNumber(int a, int b) {
        // vérification des paramètres
        if (a > b) {
            throw new ServerException(String.format("%d doit être >= à %d", b, a));
        }
        // on génère une exception aléatoire 1 fois / 3
        Random random = new Random();
        int i = random.nextInt(3);
        if (i == 0) {
            throw new ServerException("Exception aléatoire");
        }
        // on rend un nombre aléatoire entre a et b
        return a + random.nextInt(b - a + 1);
    }
}

On y trouve ce qui précédemment était dans la tâche [Task_01]. Nous ne commentons pas la classe : elle rend 2 fois sur 3 un nombre aléatoire et 1 fois sur 3 lance une exception.

V-C-1-e. La classe d'exception▲

La classe d'exception est la 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.

package istia.st.avat.server;

import java.io.Serializable;

public class ServerException extends RuntimeException implements Serializable{

    private static final long serialVersionUID = 1L;

    public ServerException() {
    }

    public ServerException(String message) {
        super(message);
    }

    public ServerException(Throwable cause) {
        super(cause);
    }

    public ServerException(String message, Throwable cause) {
        super(message, cause);
    }

    public ServerException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }

}

ligne 5 : comme la classe [ClientException] chez le client, la classe [ServerException] dérive de la classe [RuntimeException].

V-C-2. Le service REST▲

Le service REST est implémenté par SpringMVC. Un service REST (RepresEntational State Transfer) est un service HTTP répondant aux demandes GET, POST, PUT, DELETE d'un client HTTP. Sa définition formelle indique pour chacune de ces méthodes, les objets que le client doit envoyer et celui qu'il reçoit. Dans les exemples de ce document, nous n'utilisons que la méthode GET alors que dans certains cas, la définition formelle de REST indique qu'on devrait utiliser une méthode PUT. Nous appelons REST notre service parce qu'il est implémenté par un service de Spring qu'on a l'habitude d'appeler service REST et non parce qu'il respecte la définition formelle des services REST.

V-C-2-a. Le projet Eclipse▲

Le projet Eclipse de la couche [web] est le suivant :

en [1], le projet dans son ensemble ;
en [2], les dépendances Maven ;
en [3], le projet ne contient qu'une classe.

V-C-2-b. Les dépendances Maven▲

Le fichier [pom.xml] du projet Maven est le suivant :

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.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>istia.st.avat.server</groupId>
  <artifactId>server-rest</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>server-rest</name>

  <properties>
    <endorsed.dir>${project.build.directory}/endorsed</endorsed.dir>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <releaseCandidate>1</releaseCandidate>
    <spring.version>3.1.1.RELEASE</spring.version>
    <jackson.mapper.version>1.5.6</jackson.mapper.version>
  </properties>

  <repositories>
    <repository>
      <id>com.springsource.repository.bundles.release</id>
      <name>SpringSource Enterprise Bundle Repository - Release</name>
      <url>http://repository.springsource.com/maven/bundles/release</url>
    </repository>
  </repositories>

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.codehaus.jackson</groupId>
      <artifactId>jackson-mapper-asl</artifactId>
      <version>${jackson.mapper.version}</version>
    </dependency>
    <dependency>
      <groupId>istia.st.avat.server</groupId>
      <artifactId>server-metier</artifactId>
      <version>0.0.1-SNAPSHOT</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      ...
    </plugins>
  </build>

</project>

le service REST est implémenté à l'aide du framework SpringMVC. On trouve donc un certain nombre de dépendances sur ce framework (lignes 29-48) ;
lignes 49-53 : le serveur REST va échanger avec ses clients des objets au format JSON (JavaScript Object Notation). C'est une représentation texte des objets. Un objet JAVA peut être sérialisé en un texte JSON. Inversement, ce dernier peut être désérialisé pour créer un objet JAVA. Côté serveur, la bibliothèque Jackson est utilisée pour faire ces opérations ;
lignes 54-58 : le serveur REST a une dépendance sur la couche [métier] que nous avons décrite.

V-C-2-c. Configuration du service REST▲

Un service REST est une application web et à ce titre est configurée par un fichier [web.xml] classique :

est le suivant :

Sélectionnez

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

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>REST for AVAT</display-name>
  <servlet>
    <servlet-name>restservices</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/rest-services-config.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>restservices</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

lignes 4-12 : définition d'une servlet, une classe capable de traiter les requêtes HTTP des clients web ;
ligne 5 : son nom restservices. On peut l'appeler comme on veut ;
ligne 6 : la servlet qui gère les requêtes HTTP des clients web. C'est la classe [DispatcherServlet] de SpringMVC ;
lignes 7-10 : indiquent le fichier de configuration de la servlet, ici [WEB-INF/rest-services-config.xml] ;
ligne 11 : la servlet sera chargée au démarrage du serveur, ici un serveur Tomcat 7 ;
lignes 13-16 : les URL (ligne 15) traitées par la servlet restservices (ligne 14).

Au final, ce fichier indique que toutes les URL (ligne 15) seront gérées par la servlet restservices (ligne 14) définie lignes 4-12.

V-C-2-d. SpringMVC▲

SpringMVC est un framework MVC (Modèle-Vue-Contrôleur). Rappelons les grands principes de ce design pattern :

Le traitement d'une demande d'un client se déroule selon les étapes suivantes :

le client fait une demande au contrôleur. Celui-ci voit passer toutes les demandes des clients. C'est la porte d'entrée de l'application. C'est le C de MVC.
le contrôleur C traite cette demande. Pour ce faire, il peut avoir besoin de l'aide de la couche métier. Une fois la demande du client traitée, celle-ci peut appeler diverses réponses. Un exemple classique est :
le contrôleur choisit la réponse (= vue) à envoyer au client. Choisir la réponse à envoyer au client nécessite plusieurs étapes :

L'étape 3 consiste donc en le choix d'une vue V et en la construction du modèle M nécessaire à celle-ci.

le contrôleur C demande à la vue choisie de s'afficher.
la vue V utilise le modèle M préparé par le contrôleur C pour initialiser les parties dynamiques de la réponse qu'elle doit envoyer au client.
la réponse est envoyée au client. Ce peut être un flux HTML, PDF, Excel…

Spring MVC implémente cette architecture de la façon suivante :

le client fait une demande au contrôleur. Celui-ci voit passer toutes les demandes des clients. C'est la porte d'entrée de l'application. C'est le C de MVC. Ici le contrôleur est assuré par une servlet générique :
org.springframework.web.servlet.DispatcherServlet
le contrôleur principal [DispatcherServlet] fait exécuter l'action demandée par l'utilisateur par une classe implémentant l'interface :
org.springframework.web.servlet.mvc.Controller
A cause du nom de l'interface, nous appellerons une telle classe un contrôleur secondaire pour le distinguer du contrôleur principal [DispatcherServlet] ou simplement contrôleur lorsqu'il n'y a pas d'ambiguïté. Le schéma ci-dessus s'est contenté de représenter un contrôleur particulier. Il y a en général plusieurs contrôleurs, un par action.
le contrôleur [Controller] traite une demande particulière de l'utilisateur. Pour ce faire, il peut avoir besoin de l'aide de la couche métier. Une fois la demande du client traitée, celle-ci peut appeler diverses réponses. Un exemple classique est :
le contrôleur choisit la réponse (= vue) à envoyer au client. Choisir la réponse à envoyer au client nécessite plusieurs étapes :

L'étape 4 consiste donc en le choix d'une vue V et la construction du modèle M nécessaire à celle-ci.

le contrôleur DispatcherServlet demande à la vue choisie de s'afficher. Il s'agit d'une classe implémentant l'interface

org.springframework.web.servlet.View

Spring MVC propose différentes implémentations de cette interface pour générer des flux HTML, Excel, PDF… Le schéma ci-dessus s'est contenté de représenter une vue particulière. Il y a en général plusieurs vues.

le générateur de vue View utilise le modèle Map préparé par le contrôleur Controller pour initialiser les parties dynamiques de la réponse qu'il doit envoyer au client.
la réponse est envoyée au client. La forme exacte de celle-ci dépend du générateur de vue. Ce peut être un flux HTML, PDF, Excel…

Dans notre cas, la classe [DispatcherServlet] est configurée par le fichier [] suivant :

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.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
                            http://www.springframework.org/schema/util
                              http://www.springframework.org/schema/util/spring-util-3.0.xsd">


    <!-- couche métier -->
    <bean id="metier" class="istia.st.avat.server.Metier" />

    <!-- Recherche des annotations SpringMVC dans les classes du package nommé -->
    <context:component-scan base-package="istia.st.avat.server" />

    <!-- L'unique View utilisée. Elle génère du JSON -->
    <bean
        class="org.springframework.web.servlet.view.json.MappingJacksonJsonView">
        <property name="contentType" value="text/plain" />
    </bean>

    <!-- Le convertisseur JSON -->
    <bean id="jsonMessageConverter"
        class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />

        <!-- la liste des convertisseurs de messages. Il n'y en qu'un : le JSON ci-dessus -->
    <bean
        class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
        <property name="messageConverters">
            <util:list id="beanList">
                <ref bean="jsonMessageConverter" />
            </util:list>
        </property>
    </bean>


</beans>

ligne 13 : le bean de la couche [métier]. Il sera instancié par Spring ;
ligne 16 : il est possible de configurer Spring à l'aide d'annotations dans le code Java. C'est ce qui a été fait ici. La ligne 16 dit à Spring d'exploiter les annotations qu'il trouvera dans le package [istia.st.avat.server] ;

Il y trouvera trois genres d'annotations :

Sélectionnez

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

@Controller
public class RestMetier {

    // couche métier
    @Autowired
    private IMetier metier;
    @Autowired
    private View view;

    // nombre aléatoire
    @RequestMapping(value = "/random/{a}/{b}", method = RequestMethod.GET)
    public ModelAndView randomNumber(@PathVariable("a") int a,
            @PathVariable("b") int b) {
...
}

ligne 1 : l'annotation @Controller fait de la classe [RestMetier] un contrôleur SpringMVC, c-à-d une classe capable de traiter des requêtes HTTP. Celles-ci sont définies par l'annotation @RequestMapping qu'on voit en ligne 11 ;
lignes 5 et 7 : l'annotation @Autowired tague des champs qui sont des références sur des beans définis dans le fichier de configuration de SpringMVC. Dans notre cas, ce sont les beans des lignes 2 et 8 du fichier [rest-services-config.xml] ci-dessous. Les champs des lignes ainsi taguées sont automatiquement initialisés par Spring.

Revenons au code du fichier [rest-services-config.xml] :

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.

<!-- couche métier -->
    <bean id="metier" class="istia.st.avat.server.Metier" />

    <!-- Recherche des annotations SpringMVC dans les classes du package nommé -->
    <context:component-scan base-package="istia.st.avat.server" />

    <!-- L'unique View utilisée. Elle génère du JSON -->
    <bean
        class="org.springframework.web.servlet.view.json.MappingJacksonJsonView">
        <property name="contentType" value="text/plain" />
    </bean>

    <!-- Le convertisseur JSON -->
    <bean id="jsonMessageConverter"
        class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter" />

        <!-- la liste des convertisseurs de messages. Il n'y en qu'un : le JSON ci-dessus -->
    <bean
        class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
        <property name="messageConverters">
            <util:list id="beanList">
                <ref bean="jsonMessageConverter" />
            </util:list>
        </property>
    </bean>

lignes 8-10 : les vues générées par l'unique contrôleur seront du type [MappingJacksonJsonView] (ligne 9). Cette vue va transformer son modèle en un unique objet JSON qu'elle va transmettre à son client. La ligne 10 configure un entête HTTP envoyé par le serveur à son client : elle dit que le serveur envoie du texte, ici l'objet JSON ;
lignes 14-16 : un « convertisseur de messages ». Je ne sais pas bien ce que signifie cette expression. Il semble que cela définisse une classe capable de créer un objet à partir d'une requête ou d'une réponse HTTP et inversement. Ici la classe [MappingJacksonHttpMessageConverter] va créer un objet JSON à partir du modèle de la vue. Inversement, elle est capable de produire un objet Java à partir de données JSON postées par le client ;
lignes 18-25 : il peut y avoir plusieurs « convertisseurs de messages » pour différents cas de figure. Entre les lignes 21-23, on met les beans chargés de « convertir des messages ». On y met donc le bean défini ligne 14. C'est le seul.

V-C-2-e. Le serveur REST▲

Maintenons que nous avons vu comment le service REST était configuré, examinons son code :

Le code de la classe [RestMetier] est le suivant :

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.avat.server;


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

@Controller
public class RestMetier {

    // couche métier
    @Autowired
    private IMetier metier;
    @Autowired
    private View view;

    // nombre aléatoire
    @RequestMapping(value = "/random/{a}/{b}", method = RequestMethod.GET)
    public ModelAndView randomNumber(@PathVariable("a") int a,
            @PathVariable("b") int b) {

        // on utilise la couche métier
        int n = 0;
        try {
            n = metier.randomNumber(a, b);
            // suivi
            return new ModelAndView(view, "data", String.valueOf(n));
        } catch (Exception e) {
            // suivi
            return createResponseError("103", e.getMessage());
        }
    }

    // crée une réponse d'erreur
    private ModelAndView createResponseError(String numero, String message) {
        Map<String, Object> modèle = new HashMap<String, Object>();
        modèle.put("error", numero);
        modèle.put("message", message);
        return new ModelAndView(view, modèle);
    }
}

ligne 19 : la méthode qui génère le nombre aléatoire. Lorsqu'elle s'exécute, les champs des lignes 13 et 15 ont été initialisés par SpringMVC. Par ailleurs, si elle s'exécute, c'est parce que le serveur web a reçu une requête HTTP GET pour l'URL de la ligne 18 ;
ligne 18 : l'URL traitée est de la forme /random/{a}/{b} où {x} représente une variable. Les deux variables {a} et {b} sont affectées aux paramètres de la méthode lignes 19 et 20. Cela se fait via l'annotation @PathVariable(" x "). On notera que {a} et {b} sont des composantes d'une URL et sont donc de type String. La conversion de String vers le type des paramètres peut échouer. SpringMVC lance alors une exception. Résumons : si avec un navigateur je demande l'URL /random/100/200, la méthode random de la ligne 19 s'exécutera avec les paramètres entiers 100 et 200 ;
ligne 25 : on demande à la couche [métier] un nombre aléatoire dans l'intervalle [a,b]. On se souvient que la méthode [metier].random peut lancer des exceptions. On les gère ;
ligne 27 : le contrôleur MVC rend une vue (View) avec son modèle (Map). Ici la View sera celle de la ligne 15, une JacksonView définie dans le fichier de configuration de Spring, donc une vue qui transforme son modèle en objet JSON. Le modèle ici sera un dictionnaire (Map) avec la clé " data " et la valeur associée le nombre aléatoire, par exemple " 140 ". La chaîne JSON correspondant à ce modèle est la suivante :

Sélectionnez

{"data":"140"}

C'est donc cette chaîne que recevra le client.

lignes 35-39 : la vue envoyée lorsque se produit une exception ;
lignes 36-38 : on construit un dictionnaire avec deux clés :
"error" : un n° d'erreur. Ici ce sera 103,
"message" : le message de l'erreur ;

La chaîne JSON envoyée au client aura la forme

Sélectionnez

{"error":"103","message":"..."}

Ceux qui ne connaissent pas le format JSON trouveront page , paragraphe , un exemple de lecture / écriture de JSON avec la bibliothèque Jackson.

V-C-2-f. Déploiement et test du service REST▲

en [1, 2] : le service REST est exécuté sur le serveur Tomcat ;
en [3], le fichier [index.jsp] de l'application web a été exécuté ;
en [4], on demande l'URL du service de génération du nombre aléatoire. Ici, on demande un nombre entre 100 et 200 ;
en [5], la réponse JSON ;
en [6] : en rafraîchissant la page un certain nombre de fois, on récupère l'exception aléatoire générée par la couche [métier], de nouveau au format JSON.

V-D. Le client Android▲

Le client Android a l'architecture suivante :

Le client a trois composantes :

la couche [AVAT] que nous avons étudiée dans l'exemple précédent ;
la couche [métier] qui va présenter une interface analogue à celle de la couche [métier] du serveur ;
la couche [DAO] qui s'adresse au service REST que nous avons étudié précédemment.

V-D-1. La couche [metier]▲

V-D-1-a. Le projet Eclipse▲

Le projet Eclipse est le suivant :

en [1], le projet Eclipse de la couche [métier] ;
en [2], les dépendances Maven du projet ;
en [3], l'implémentation de la couche [métier] ;

V-D-1-b. Les dépendances Maven▲

Le fichier [pom.xml] du projet Maven est le suivant :

Sélectionnez

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

<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>istia.st.avat.client</groupId>
    <artifactId>android-metier</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>istia.st.avat.client</groupId>
            <artifactId>android-dao</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

Le projet de la couche [métier] a une unique dépendance (lignes 12-15) sur la couche [DAO] que nous n'avons pas encore écrite.

V-D-1-c. Implémentation de la couche [métier]▲

Rappelons l'interface de la couche [métier] du serveur :

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.

package istia.st.avat.server;

public interface IMetier {

    // génération d'un nombre aléatoire
    public abstract int randomNumber(int a, int b);

}

Celle du client sera analogue :

Sélectionnez

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

package istia.st.avat.client;

import istia.st.avat.client.dao.IDao;

public interface IMetier {

    // génération d'un nombre aléatoire
    public abstract int randomNumber(String urlServiceRest,int a, int b);

    public abstract void setDao(IDao dao);
}

ligne 8 : la méthode de génération du nombre aléatoire. Un nouveau paramètre s'ajoute : celle de l'URL du service REST qui délivre ce nombre ;
ligne 10 : la couche [métier] a besoin de la couche [DAO]. C'est cette dernière qui assure les échanges avec le service REST.

L'implémentation [Metier] du client est la 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.

package istia.st.avat.client;

import istia.st.avat.client.dao.ClientException;
import istia.st.avat.client.dao.IDao;

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

import com.google.gson.Gson;

public class Metier implements IMetier {

    // couche [dao]
    private IDao dao;
    // mapper JSON
    private Gson gson = new Gson();

    // génération d'un nombre aléatoire
    public int randomNumber(String urlServiceRest, int a, int b) {
        // adresse du service REST
        String urlService = String.format("http://%s/random/{a}/{b}", urlServiceRest);
        // paramètres service REST
        Map<String, String> paramètres = new HashMap<String, String>();
        paramètres.put("a", String.valueOf(a));
        paramètres.put("b", String.valueOf(b));
        // exécution service
        String réponse = dao.executeRestService("get", urlService, null, paramètres);
        // exploitation réponse
        try {
            return Integer.parseInt(gson.fromJson(réponse, String.class));
        } catch (Exception ex) {
            throw new ClientException(String.format("Réponse incorrecte du serveur: %s", réponse), ex);
        }
    }
    // setters

    public void setDao(IDao dao) {
        this.dao = dao;
    }
    
}

lignes 3-4 : la couche [métier] s'appuie sur la couche [DAO] ;
ligne 9 : elle utilise une bibliothèque JSON de Google appelée Gson. Ceci nous est imposé par la bibliothèque utilisée [spring-android-rest-template]. Cette bibliothèque de Spring va s'interfacer avec le serveur REST SpringMVC. On trouvera page , paragraphe , un exemple de lecture / écriture de JSON avec la bibliothèque Gson ;
ligne 14 : une référence sur la couche [DAO]. Elle sera instanciée par la fabrique d'objets du modèle AVAT ;
ligne 16 : l'objet Gson qui va nous permettre de sérialiser / désérialiser des objets JSON ;
ligne 19 : la méthode de génération du nombre aléatoire. Le 1^er paramètre est l'adresse du service REST, les deux autres les bornes de l'intervalle [a,b] dans lequel on tire le nombre aléatoire ;
ligne 21 : on construit l'URL complète du service REST demandé. On notera bien la syntaxe des variables a et b dans l'URL ;
lignes 23-25 : un dictionnaire dont les clés sont les variables de l'URL demandée ;
ligne 27 : on exécute la méthode [dao].executeRestService de la couche [DAO] avec les paramètres suivants :

la méthode " get " ou " post " de la requête HTTP à émettre,
l'URL complète du service REST à exécuter,
un dictionnaire des données transmises par une opération HTTP POST. Donc null ici, puisqu'on fait une opération HTTP GET,
sous la forme d'un dictionnaire, les valeurs des variables de l'URL, ici les variables {a} et {b} ;

On ne gère pas d'exception. On verra prochainement que la couche [DAO] lance des exceptions non contrôlées. Elles vont remonter toutes seules jusqu'à la couche [Présentation] assurée par le modèle AVAT ;

lignes 29-33 : on a reçu une chaîne JSON du serveur. On attend un entier aléatoire dans l'intervalle [a,b]. On essaie donc de transformer la chaîne en entier. Si on y arrive, on rend ce nombre (ligne 30) comme résultat de la méthode sinon on lance une exception (ligne 32).

V-D-2. La couche [DAO]▲

V-D-2-a. Le projet Eclipse▲

Le projet Eclipse est le suivant :

en [1], le projet Eclipse de la couche [DAO] ;
en [2], les dépendances Maven du projet ;
en [3], l'implémentation de la couche [DAO] ;

V-D-2-b. Les dépendances Maven▲

Le fichier [pom.xml] du projet Maven est le suivant :

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.

<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>istia.st.avat.client</groupId>
    <artifactId>android-dao</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring-android-version>1.0.1.RELEASE</spring-android-version>
    <com.google.code.gson-version>2.2.2</com.google.code.gson-version>                    
    </properties>

    <repositories>
        <repository>
            <id>springsource-repo</id>
            <name>SpringSpring Repository</name>
            <url>http://repo.springsource.org/release</url>
        </repository>
    </repositories>

    <dependencies>
        <dependency>
            <groupId>org.springframework.android</groupId>
            <artifactId>spring-android-rest-template</artifactId>
            <version>${spring-android-version}</version>
        </dependency>
    <!-- Gson JSON Processor -->
    <dependency>
      <groupId>com.google.code.gson</groupId>
      <artifactId>gson</artifactId>
      <version>${com.google.code.gson-version}</version>
    </dependency>        
    </dependencies>
</project>

Le projet de la couche [DAO] a deux dépendances :

la communication avec le serveur REST va être assurée par un client REST fourni par la bibliothèque [spring-android-rest-template] (lignes 23-27) ;
l'échange d'objets JSON entre le client et le serveur REST nous oblige à avoir une bibliothèque de sérialisation / désérialisation d'objets JSON. Ce sera la bibliothèque Gson de Google (lignes 29-33).

V-D-2-c. Implémentation de la couche [DAO]▲

L'interface de la couche [DAO] est la suivante :

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.

package istia.st.avat.client.dao;

import java.util.Map;

public interface IDao {
    public String executeRestService(String method, String urlService, Object request, Map<String, String> paramètres);

    public void setTimeout(int millis);
}

ligne 6 : la méthode [executeRestService] dont nous avons parlé précédemment ;
ligne 8 : une méthode pour fixer un temps de réponse maximal de la part du serveur REST. Passé ce délai, la couche [DAO] lance une exception [ClientException]. Ce temp est fixé en millisecondes.

L'implémentation est la suivante :

Sélectionnez

package istia.st.avat.client.dao;

...

import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.http.converter.json.GsonHttpMessageConverter;
import org.springframework.web.client.RestTemplate;

public class Dao implements IDao {

    // client REST
    private RestTemplate restTemplate;
    // mapper JSON
    private Gson gson = new Gson();
    // délai d'attente maximal
    private int timeout;

    // constructeur
    public Dao() {
        // on crée un objet [RestTemplate]
        restTemplate = new RestTemplate();
        // on le configure
        restTemplate.getMessageConverters().add(new GsonHttpMessageConverter());
        restTemplate.getMessageConverters().add(new StringHttpMessageConverter());
    }

    // exécution de l'appel au service REST
    public String executeRestService(String method, String urlService, Object request, Map<String, String> paramètres) {

        // on vérifie que le serveur distant répond assez vite
        // une exception est lancée sinon
        checkResponsiveness(urlService);
        // vérification méthode HTTP
        method = method.toLowerCase();
        if (!method.equals("get") && !method.equals("post")) {
            throw new ClientException("L'argument [method] doit avoir la valeur post ou get dans [%s]");
        }
        try {
            // exécution service
            String réponse = null;
            if (method.equals("get")) {
                réponse = restTemplate.getForObject(urlService, String.class, paramètres);
            } else {
                réponse = restTemplate.postForObject(urlService, request, String.class, paramètres);
            }
            // résultat
            Map<String, Object> map = gson.fromJson(réponse, new TypeToken<Map<String, Object>>() {
            }.getType());
            // erreur ?
            String erreur = (String) map.get("error");
            if (erreur != null) {
                throw new ClientException(String.format("Le serveur a renvoyé l'erreur suivante : %s",
                        (String) map.get("message")));
            }
            // data ?
            Object data = map.get("data");
            if (data == null) {
                throw new ClientException(String.format("Réponse incorrecte du serveur : %s", réponse));
            }
            // c'est bon - on rend le résultat
            return gson.toJson(data);
        } catch (Exception ex) {
            throw new ClientException(String.format("Une erreur s'est produite : %s",ex.getMessage()));
        }
    }

    private void checkResponsiveness(String urlService) {
...
    }

    // délai d'attente maximal
    public void setTimeout(int millis) {
        this.timeout = millis;
    }

}

lignes 5-7 : la couche [DAO] s'appuie sur un client REST fourni par la bibliothèque [spring-android-framework]. Le principal élément de cette bibliothèque est la classe [RestTemplate] de la ligne 7. Le cœur du framework Spring n'a pas encore été porté sur Android. Alors qu'habituellement, le champ de la ligne 7 aurait été initialisé par Spring, ici il le sera par le constructeur ;
ligne 21 : l'objet [RestTemplate] est instancié ;
lignes 23-24 : il est configuré. On lui donne ici à la main la liste de " convertisseurs de message " qu'on avait définie dans le fichier de configuration du serveur REST. Dans ce dernier, on n'avait défini que le convertisseur [JacksonHttpMessageConverter]. Ici pour le remplacer on utilise le convertisseur [GsonHttpMessageConverter] qui utilise la bibliothèque Gson. On définit également le convertisseur [StringHttpMessageConverter]. On n'en avait pas eu besoin pour le serveur. Ici, le client plante sans ce convertisseur ;
ligne 28 : la méthode [executeRestService] reçoit les paramètres suivants :
ligne 32 : on vérifie que le serveur REST répond au bout de timeout millisecondes. Si ce n'est pas le cas, la méthode [checkResponsiveness] lance une exception ;
lignes 34-37 : vérification de la méthode HTTP ;
lignes 38-45 : exécution du service REST par l'objet [RestTemplate] de Spring (ligne 12). Cette classe a de nombreuses méthodes pour dialoguer avec un service REST. Celles utilisées ici vont rendre comme résultat, la chaîne JSON renvoyée par le serveur. On se rappelle que celui-ci peut renvoyer deux types de chaînes JSON :

la méthode " get " ou " post " de la requête HTTP à émettre,
l'URL complète du service REST à exécuter,
un dictionnaire des données transmises par une opération HTTP POST ;
sous la forme d'un dictionnaire, les valeurs des variables de l'URL ;

Sélectionnez

1.
2.

{"data":"131"}
{"error":"103","message":"Exception aléatoire"}

Ligne 1, la chaîne contenant le nombre aléatoire, ligne 2, la chaîne contenant un message d'erreur.

ligne 47 : on transforme la chaîne JSON reçue en dictionnaire ;
ligne 50 : on regarde si dans ce dictionnaire il y a la clé "error". Si oui, on lance une [ClientException] (lignes 51-54) ;
ligne 56-59 : on regarde si dans ce dictionnaire il y a la clé "data". Si non, on lance une [ClientException] (lignes 57-59) ;
ligne 61 : on retourne le nombre aléatoire.

La méthode [checkResponsiveness] est la 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.

private void checkResponsiveness(String urlService) {
        // on crée l'URI du service distant
        String url = urlService.replace("{", "").replace("}", "");
        URI service = null;
        try {
            service = new URI(url);
        } catch (URISyntaxException ex) {
            throw new ClientException(String.format("Format d'URL incorrect [%s]", urlService), ex);
        }
        // on se connecte au service
        Socket client = null;
        try {
            // avec attente maximale définie par configuration
            client = new Socket();
            client.connect(new InetSocketAddress(service.getHost(), service.getPort()), timeout);
        } catch (IOException e) {
            // le serveur n'a pas répondu
            throw new ClientException(String.format("Le service distant n'a pas répondu assez vite : %s", e.getMessage()));
        } finally {
            // on libère les ressources
            if (client != null) {
                try {
                    client.close();
                } catch (IOException ex) {
                    Logger.getLogger(Dao.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }

ligne 1 : le paramètre [urlService] est de la forme [http://localhost:8080/server-rest/random/{a}/{b}];
ligne 3 : l'URL précédente devient [http://localhost:8080/server-rest/random/a/b];
lignes 5-9 : à partir de cette URL, on essaie de construire un objet URI. Si on n'y arrive pas c'est que l'URL est incorrecte ;
lignes 14-15 : on se connecte à la machine et au port définis par l'URI qui vient d'être construite et on donne un temps maximum de timeout millisecondes pour obtenir la réponse (ligne 15) ;
ligne 18 : si pour une raison ou une autre (absence du serveur ou délai d'attente dépassé), la connexion échoue alors on lance une exception.

V-D-3. La couche [AVAT]▲

La couche [AVAT] change peu vis à vis de la version précédente :

la vue demande une information supplémentaire, l'URL du service REST ;
la tâche asynchrone [Task_01] évolue.

V-D-3-a. Le projet Eclipse▲

en [1], le projet Eclipse de la couche [AVAT] ;
en [2], les dépendances Maven du projet ;
en [3], l'implémentation de la couche [AVAT] ;

V-D-3-b. Les dépendances Maven▲

Le fichier [pom.xml] du projet est le suivant :

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.

<?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>istia.st.avat.exemples</groupId>
    <artifactId>android-ui2</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>
        <android.sdk.path>D:\\Programs\\devjava\\Android\\sdk</android.sdk.path>
        <spring-android-version>1.0.1.RELEASE</spring-android-version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.google.android</groupId>
            <artifactId>android</artifactId>
            <version>${platform.android.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>istia.st.android</groupId>
            <artifactId>android-avat</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>
        <dependency>
            <groupId>istia.st.avat.client</groupId>
            <artifactId>android-metier</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
        ...
        </plugins>
    </build>
</project>

lignes 18-23 : dépendance sur la plateforme Android ;
lignes 24-29 : dépendance sur le modèle [AVAT] ;
lignes 30-34 : dépendance sur la couche [métier] du client ;

V-D-3-c. La tâche [Task_01]▲

La classe [Task_01] devient la suivante :

Sélectionnez

package istia.st.avat.exemples.tasks;

...

public class Task_01 extends Task {

    // info renvoyée par la tâche
    private Object info;

    @Override
    public void onPreExecute(){
...
    }

    @Override
    // on exécute la tâche (urlSrviceRest, a, b, sleepTime)
    protected Void doInBackground(Object... params) {
        // il faut quatre paramètres
        if (params.length != 4) {
            info = new ClientException("Il faut quatre paramètres");
            return null;
        }
        // on récupère les paramètres
        String urlServiceRest = null;
        int a = 0;
        int b = 0;
        int sleepTime = 0;
        
        try {
            urlServiceRest = (String) params[0];
            a = (Integer) params[1];
            b = (Integer) params[2];
            sleepTime = (Integer) params[3];            
        } catch (Exception ex) {
            info = new ClientException(String.format("Paramètres incorrects [%s,  %d, %d, %d]", urlServiceRest, a, b, sleepTime));
            return null;
        }
        // vérification des bornes [a,b]
        if (a > b) {
            info = new ClientException(String.format("%d doit être >= à %d", b, a));
            return null;
        }
        // attente
        try {
            Thread.sleep(sleepTime);
        } catch (InterruptedException e) {
            info = e;
            return null;
        }        
        // on demande le nombre à la couche métier
        IMetier metier = (IMetier) factory.getObject(Factory.METIER, (Object[]) null);
        try {
            info = metier.randomNumber(urlServiceRest, a, b);
        } catch (Exception ex) {
            info = ex;
        }
        // fin
        return null;
    }

    @Override
    // traitement fin de tâche dans le thread de l'UI
    protected void onPostExecute(Void result) {
...
    }

}

ligne 17 : dans la version précédente, la méthode [doWork] recevait trois paramètres. Elle en reçoit maintenant un de plus : l'URL du service REST qui délivre les nombres aléatoires ;
ligne 51 : le nombre aléatoire est délivré par la couche [métier] du client. La tâche demande à la fabrique d'objets une référence sur cette couche. Celle-ci est un singleton. La fabrique ne la crée qu'en un unique exemplaire ;
ligne 53 : le nombre aléatoire est demandé à la couche [métier].

V-D-3-d. La vue [Vue_01]▲

La vue [Vue_01] évolue pour demander une information supplémentaire : l'URL du service REST :

Pour mettre la bonne URL en [1], on peut procéder ainsi :

taper la commande [ipconfig] dans une fenêtre [DOS] :
prendre l'adresse IP [2] de la carte Wifi [1] ;
déployer le serveur REST sous Eclipse et demander l'URL du service REST avec un navigateur. Utiliser l'adresse IP précédente ;
l'URL du service REST à taper sur la tablette est alors [172.16.1.84:080/server-rest]. Il faudra peut-être désactiver le pare-feu du PC voire inhiber un éventuel logiciel antivirus qui pourrait bloquer les connexions entrantes. C'est par exemple le cas de Mcafee.

V-D-3-e. La configuration de l'application▲

La classe [Config] qui configure l'application est la suivante :

Sélectionnez

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

package istia.st.avat.exemples.activity;

public class Config {

    // le mode verbeux ou non
    private boolean verbose = true;
    // le temps d'attente de la réponse du serveur REST en millisecondes
    private int timeout=1000;
    
    // getters et setters
    public boolean isVerbose() {
        return verbose;
    }

    public int getTimeout() {
        return timeout;
    }
    
}

V-D-3-f. La fabrique d'objets▲

Il y a davantage d'objets dans cette application que dans la précédente. La fabrique d'objets est la suivante :

Sélectionnez

package istia.st.avat.exemples.activity;

...

public class Factory implements IFactory {

    // constantes
    public static final int CONFIG = -1;
    public static final int METIER = -2;
    public static final int TASK_01 = 1;
    public static final int ACTION_01 = 3;
    public static final int VUE_01 = 4;

    // ------------------------------------- DEBUT SINGLETONS
    // la configuration
    private Config config;
    private boolean verbose;
    private int timeout;

    // la couche [métier]
    private IMetier metier;

    // les vues
    private Vue vue_01;

    // l'activité principale
    private Activity activity;

    // ------------------------------------- FIN SINGLETONS

    // constructeur
    public Factory(Activity activity, Config config) {
        // l'activité
        this.activity = activity;
        // la configuration
        this.config = config;
        // le mode verbeux ou non
        verbose = config.isVerbose();
        // le temps d'attente de la réponse du serveur REST
        timeout = config.getTimeout();
    }

    @Override
    public Object getObject(int id, Object... params) {
        switch (id) {
        case METIER:
            return getMetier();
        case CONFIG:
            return config;
        case TASK_01:
            return getTask_01(params);
        case ACTION_01:
            return getAction_01(params);
        case VUE_01:
            return getVue_01(params);
        }
        return null;
    }

    private Object getMetier() {
        // metier est un singleton
        if (metier == null) {
            // couche [dao]
            IDao dao = new Dao();
            dao.setTimeout(timeout);
            // couche [metier]
            metier = new Metier();
            metier.setDao(dao);
        }
        // fin
        return metier;
    }

    private Object getVue_01(Object... params) {
    ...
    }

    // une tâche reçoit deux paramètres : IBoss, id
    private Object getTask_01(Object[] params) {
    ...
    }

    // une action reçoit deux paramètres : IBoss, id
    private Object getAction_01(Object[] params) {
...
    }

}

lignes 60-72 : instanciation de la couche [métier] ;
ligne 64 : on instancie la couche [DAO] ;
ligne 65 : on lui injecte son timeout ;
ligne 67 : on instancie la couche [métier] ;
ligne 68 : on lui injecte une référence sur la couche [DAO] ;
ligne 62 : la couche [métier] est un singleton. Une fois créé, il est recyclé.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants :

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 © 2013 Serge Tahé. 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.