Docstoc

Dossier_Developpeur_V3

Document Sample
Dossier_Developpeur_V3 Powered By Docstoc
					Projet CAR
Dossier Développeur Version 3


20/12/2010
Département IRM
El Mehdi/Youssef/Vincent/Hadi/François-Xavier/Carolle/Pierre
Table des matières
1. Composants communs ....................................................................................................................... 5
   1.1. Télécharger et installer tous les composants communs ............................................................. 5
   1.2. Configurer Eclipse et télécharger les plug-ins communs ............................................................ 6
2. Composants pour la base de données ............................................................................................... 8
   2.1. Télécharger et installer les composants Oracle 10g .................................................................... 8
   2.2. Configurer Oracle ........................................................................................................................ 9
   2.3. Création d’une BD de test sous MySQL ..................................................................................... 10
3. Composants pour l’architecture J2EE (AN)....................................................................................... 10
   3.1. Télécharger et installer les composants J2EE ............................................................................ 11
   3.2. Télécharger les plug-ins Eclipse ................................................................................................. 12
   3.3. Configurer et créer un projet Tomcat ....................................................................................... 13
   3.4. Mettre en place la couche présentation ................................................................................... 15
   3.5. Mettre en place les couches mapping et métier ....................................................................... 23
   3.6. Utiliser Spring dans la couche métier ........................................................................................ 25
4. Composants pour la base de données mobile ................................................................................. 30
   4.1. Télécharger et installer Oracle Lite Mobile Server .................................................................... 30
   4 .2. Configurer et publier une application Webtogo ....................................................................... 31
   4.3. Lancer le serveur Mobile Server ................................................................................................ 32
   4.4. Installation d’Oracle Lite sur l’iPhone........................................................................................ 33
   4.5. Configurer Oracle Lite pour la connexion Wifi .......................................................................... 34
5. Mise en place du wiki ........................................................................................................................ 35
   5.1. Inscription à sourceforge (Create Account) ............................................................................... 35
   5.2. Identification sur sourceforge (Log In) ....................................................................................... 36
   5.3. Création d’un projet Sourceforge............................................................................................... 38
   5.4. Utilisation de Sourceforge .......................................................................................................... 40
       5.4.1. Summary.............................................................................................................................. 42
       5.4.2. Files ...................................................................................................................................... 42
       5.4.3. Forums ................................................................................................................................. 44
       5.4.4. Code..................................................................................................................................... 46
       5.4.5. Project Admin ...................................................................................................................... 48
   5.5. Mise en œuvre du versioning ..................................................................................................... 48
       5.5.1 Installation du plug-in Subversion sous NetBeans ............................................................... 48
       5.5.2 Première utilisation de Subversion ...................................................................................... 49



CAR : Dossier Développeur                                                                                                                         Page 2
    5.5.3 Cycle d’utilisation de Subversion.......................................................................................... 50




CAR : Dossier Développeur                                                                                                     Page 3
                                   HISTORIQUE DES REVISIONS


       Référence            Version           Date            Auteur(s)         Nature de la
                                                                                  révision

Dossier_Developpeur           01            14/11/2010    Tous les membres     Version initiale
                                                             du groupe

Dossier_Developpeur_V2        02            15/11/2010    Tous les membres   Rajout d’une partie
                                                             du groupe       « Mise en place du
                                                                                   wiki »

Dossier_Developpeur_V3        03            20/12/2010        Vincent        Modification de la
                                                                             partie 5.5 – Mise
                                                                               en Œuvre du
                                                                                Versioning




CAR : Dossier Développeur                                                                Page 4
Ce document, intitulé « Dossier du développeur », contient les directives permettant à tous
les acteurs du projet d’obtenir un environnement de travail identique. Il explique donc quels
outils à télécharger, comment les installer et les configurer, puis comment les intégrer à
l’environnement de travail. Pour chaque architecture à mettre en place dans le projet, un
exemple permettra la prise en main des composants.

Le document sera articulé autour des différentes applications du projet : composants
communs, bases de données, composants pour l’AN, composants pour les applications AM
et AT.


1. Composants communs

1.1. Télécharger et installer tous les composants communs
Les composants suivants sont à télécharger et installer.

Java Entreprise Edition 6 SDK : le Software Development Kit permettant de développer des
applications J2EE. Nous utilisons la version compatible avec la JVM6.
Site:http://java.sun.com/jave

Eclipse 3.6.1 Helios : environnement de développement gratuit permettant de réaliser
des applications Java.
Site :http://www.eclipse.org/
L’installation se résume directement à décompresser l’archive téléchargée dans le répértoire
d’installation.

Checkstyle 4.2 : plug-in pour Eclipse permettant d’effectuer une vérification en temps réel de
la mise en forme du code implémenté. Cela permettra de respecter les règles de
programmation instaurées au début du projet.
Site : http://checkstyle.sourceforge.net/
L’installation se résume à directement décompresser l’archive téléchargée dans le répértoire
d’installation. L’intégration à Eclipse se fait grâce à un plug-in (cf. Etape suivante).

Hibernate Tools 3.1.2 : plug-in Eclipse pour l’integration d’Hibernate
Site : http://www.hibernate.org/255.html/


JUnit : framework permettant d’effectuer des tests unitaires pour les différents modules
de l’application CAR. Il est possible d’utiliser ce framework à travers un plug-in pour
Eclipse.
Site : http://junit.org/
L’installation se résumé à directement décompresser l’archive dans le répertoire
d’installation. Son inclusion à un projet se fera à partir d’Eclipse.




CAR : Dossier Développeur                                                                 Page 5
1.2. Configurer Eclipse et télécharger les plug-ins communs


Les composants qui suivent sont des plug-ins à installer sous Eclipse. Sauf mention contraire,
l’installation de plug-ins Eclipse s’effectue par le menu « Help Software Updates Find And
Install ». Il suffit alors de choisir « Search for new features to install ». Pour ajouter un
nouveau plug-in, il faut choisir “New Remote Site” puis entrer les informations de
connexions spécifiques à chaque plug-in.

Une fois le plug-in trouvé, il suffit de cocher la case et de suivre les instructions pour
l’installation du plug-in.

 Avant toute chose, il est nécessaire d’associer eclipse à un JDK (Java Development Kit) et
non à un JRE (Java Runtime Environment). Pour cela, il faut naviguer jusqu’à « Windows
Preferences Java Installed JREs », puis ajouter un nouveau JRE, lui donner le nom du JDK et
le répertoire où le JDK est installé. Enfin, il faut cocher ce nouveau JDK dans la fenêtre «
Installed JREs ».

Subclipse

Le plug-in Subclipse permet de se connecter à un serveur Subversion (SVN) et de travailler
de façon collaborative sur des codes sources.

Informations de connexion :

      Nom : Subclipse
      URL : http://subclipse.tigris.org/update_1.0.x



Afin de configurer votre projet Eclipse pour une synchronisation SVN, les étapes suivantes
sont à réaliser.

      Affichez la vue SVN (Windows Show View Other SVN SVN Repository) • Cliquez
       dans cette fenêtre avec le bouton droit et sélectionnez : New Repository
      Location. Il s’agit du répertoire distant qui va accueillir votre projet.
      Fournissez l’URL suivant : svn://car.homeip.net et cliquez sur « Finish »

 Il convient maintenant de créer un nouveau projet et de télécharger le contenu actuel du
répertoire distant afin de pouvoir commencer à travailler dessus.



      Créez un projet SVN : File New Other SVN Checkout projects from SVN
      Sélectionnez le repository qui vient d’être créé




CAR : Dossier Développeur                                                              Page 6
      Les différents projets sont situés dans quatre dossiers : AN, AC, AL et AT. Choisissez
       celui que vous souhaitez récupérer.
      Choisissez : “Check out as a project in the workspace” et donnez un nom au projet en
       local.
      Choisissez l’emplacement du projet en local.




Pour synchronisez votre projet local avec le répertoire distant, affichez la vue « Synchronize
» : Windows Show View Other Team Synchronize.

Après avoir effectué une synchronisation, vous pouvez

- récupérer des fichiers dont la version en ligne est supérieure à la version locale (flèche
bleue vers la gauche) : Commit

- déposer des fichiers dont la version en ligne est inférieure à la version locale : Update



Eclipse UML

Le plug-in Eclipse UML d’Omondo permet de réaliser des diagrammes UML et de les lier aux
projets Java. Ce plug-in ne s’installe pas à travers Eclipse mais se télécharge à l’URL suivante :
http://www.omondo.com/ (rubrique « Download »). Il suffit ensuite d’exécuter le jar fourni.

Aucune configuration n’est requise.

Eclipse Checkstyle 4.2

Le plug-in Eclipse Checkstyle permet d’ajouter un vérificateur syntaxique à l’éditeur de code
d’Eclipse.

Informations de connexion :

      Nom : EclipseCS
      URL : http://eclipse-cs.sourceforge.net/update

Lorsque le projet est récupéré depuis le répertoire distant Subversion, toute la configuration
de Checkstyle est déjà opérationnelle. Cependant, pour information, la configuration est la
suivante :

      Accédez aux propriétés du projet (bouton droit sur l’icône du projet) et sélectionnez
       Checkstyle
      Cochez ensuite la case « Checkstyle » appliqué sur ce projet



CAR : Dossier Développeur                                                                  Page 7
2. Composants pour la base de données


La base de données est le composant central du système car. Il s’articule en plusieurs
composants :

          le serveur de base de données Central : Oracle 10g ou Oracle 10g XE (Express
           Edition)
          le module de synchronisation côté serveur : Oracle 10g Lite Mobile Server
          le module de synchronisation côté client : Oracle 10g Lite Mobile Client (iPhone)

Nous allons expliciter les différentes étapes de la configuration de cet environnement de
base de données.

2.1. Télécharger et installer les composants Oracle 10g


Il faut tout d’abord faire un choix entre la version Standard (ou Personal) et la version
Express. Le choix se porte principalement sur la taille des données à manipuler. Dans la
phase de développement du projet, la base de données Oracle Express sera suffisante. Il faut
toutefois garder à l’esprit que la base Oracle Standard sera installée dans le système final.

Voici les URL de téléchargement de ces deux versions :

      Oracle 10g Express Edition :

http://www.oracle.com/technology/software/products/database/xe/

      Oracle 10g Standard Edition Release 2 :

http://www.oracle.com/technology/software/products/database/oracle10g/



Il faut choisir la version “Western European”. Un compte Oracle est nécessaire pour le
téléchargement des produits Oracle. L’inscription est gratuite.

Installation

Le paragraphe détaille l’installation de la version Express, à partir du lancement du
programme d’installation.



      Lancer l’installeur d’Oracle préalablement téléchargé.
      Définir le mot de passe des comptes administrateurs SYSTEM et SYS.

Le mot de passe sera : admin


CAR : Dossier Développeur                                                                Page 8
      Vérifier que les paramètres suivants sont corrects :

        Port du processus d'écoute Oracle Database : 1521

        Port d'Oracle Services pour Microsoft Transaction Server : 2030

        Port du processus d'écoute HTTP : 8080

Les propriétés suivantes définissent la base de données installée

       Nom de la base : XE

       Login de l’administrateur : SYSTEM

       Mot de passe de l’administrateur : admin

       SID : XE



2.2. Configurer Oracle


Ajout d’un utilisateur

La première étape consiste à créer un nouvel utilisateur. Il est en effet dangereux de
développer des applications Oracle sous le compte System, car celui-ci à tous les droits sur la
base, notamment en ce qui concerne l’administration générale.

      Lancer la page web d’administration d’Oracle (disponible dans le Menu Démarrer
      Programmes)
      Connecter à la base de données avec le compte SYSTEM (MDP : admin)
      Naviguer dans Administration Database Users
      Créer un utilisateur (bouton « Create »), par exemple :

       Username : sysadmin

        password : admin



Port d’administration

La seconde étape consiste à modifier le port d’administration Web de la base de données.
Par défaut, la base de données est administrable à travers le port 8080. Cependant, ce port
sera également utilisé par Tomcat plus tard dans la mise en place de l’architecture J2EE.
Nous allons donc choisir un autre port pour Oracle, le port 8085.

      Dans une console Windows, entrez la commande sqlplus. Donnez le login et le mot


CAR : Dossier Développeur                                                               Page 9
       de passe Administrateur (SYSTEM/admin).
      Exécutez la commande : exec dbms_xdb.sethttpport(‘8085’);
      Quittez le programme sqlplus avec la commande exit



2.3. Création d’une BD de test sous MySQL


On a créé une BD comportant trois tables avec des liens OneToMany & ManyToMany sous
mySql5 en InnoDb, cette BD servira pour la génération des beans à l’aide du plugin
Hibernate Tools sous eclipse, et permettra la réalisation de la première couche : mapping.

La création se fait à travers l’interface d’administration fournie par mySql.

La connexion se fait à l’aide du fichier hibernate.cfg.xml, ce fichier comportera toutes les
informations nécessaires pour établir notre connexion : connection name, username, le
dialect, le driver ….


3. Composants pour l’architecture J2EE (AN)
L’application nationale du système e-CAR est bâtie sur une architecture J2EE. Plus
précisément, le modèle en couches est utilisé pour permettre une séparation claire des rôau
sein du système.

L'un des intérêts de l'intégration des différents frameworks est de permettre la mise en
place d'une architecture logicielle rigoureuse, de manière à garantir la maintenabilité,
l'évolutivité et l'exploitabilité des applications.

La figureci-dessous montre l'architecture qui sera mise en place dans le cadre de ce tutoriel.
Ce type d'architecture est trèslargement admise comme efficace et est généralisable à
n'importe quel projet Web.




CAR : Dossier Développeur                                                               Page 10
      Couche DAO : cette couche permet les accès à la BDD à travers le framework
       Hibernate.
      Couche Service : cette couche contient l'ensemble du code métier de l'application,
       elle organise et orchestreles accès à la couche DAO et ses aspects transactionnels.
       Ces différents aspects sont gérés et organisés parle framework Spring.
      Couche Front : cette couche est la couche d'entrée dans l'application du point de vue
       du client. Elle appelleles traitements de la couche Service en fonction des actions
       effectuées par le client et récupère les données retournées. Elle met ensuite en
       forme ces données pour les afficher au client. Cette couche est réalisée grâce au
       framework JSF.

3.1. Télécharger et installer les composants J2EE
Serveur Tomcat 5.5.20

 Le serveur Tomcat d’Apache est un moteur de servlets. Il est le conteneur de la couche «
Front » de notre architecture. Ce serveur est administrable par web sur le port 8080 :
http://localhost:8080 donne accès à la page d’accueil du serveur lorsque celui-ci est lancé.
Tomcat est téléchargeable à l’adresse suivante : http://tomcat.apache.org/download-
55.cgi#5.5.20 (Windows Service Installer).

L’installation se réduit à suivre les écrans proposés par l’application téléchargée.



CAR : Dossier Développeur                                                              Page 11
Hibernate 3.2.0

Hibernate est un outil permettant de calquer votre base de données sur des objets métiers
en Java. Grâce à cet outil, les opérations élémentaires de manipulation de base de données
(CRUD : Create Read Update Delete) sont encapsulées et masquées à l’utilisateur de l’API.
Hibernate est téléchargeable à l’adresse suivante : http://www.hibernate.org/6.html (choisir
« Hibernate Core »).

L’installation se fait par simple décompression du dossier dans un répertoire d’installation.

Hibernate Tools 3.2 beta 8

 Les outils supplémentaires d’Hibernate contiennent en particulier l’outil de génération des
classes Java à partir de la base de données (hbm2java, aussi appelé CodeGenerator). La
librairie est téléchargeable à l’adresse suivante : http://www.hibernate.org/255.html.

L’installation se fait par simple décompression du dossier dans un répertoire d’installation.

Spring 2.0

Spring est un framework permettant d’implémenter l’inversion de contrôle à différents
niveaux de l’architecture J2EE. Le framework se décompose en plusieurs outils s’adaptant à
chaque couche spécifique.

Spring est téléchargeable à l’adresse suivante : http://www.springframework.org/download
(sans les dépendances). L’installation se fait par simple décompression du dossier dans un
répertoire d’installation.



Pilote JDBC pour Oracle

La connexion entre une base de données Oracle et une application Java se fait grâce à un
pilote, appelé pilote JDBC. Il existe un pilote JDBC pour chaque type de base de données.

Celui spécifique à Oracle est disponible à l’adresse suivante :
http://www.oracle.com/technology/software/tech/java/sqlj_jdbc/ (driver pour Oracle
10.2.0.2, ojdbc14.jar).

L’installation se fait par simple décompression du dossier dans un répertoire d’installation.



3.2. Télécharger les plug-ins Eclipse
Le téléchargement et la configuration des plug-ins Eclipse suivants sont nécessaires pour
intégrer les différents composants J2EE dans un projet Eclipse. La procédure d’installation
est, sauf indication contraire, la même que pour le chapitre précédent.



CAR : Dossier Développeur                                                              Page 12
Tomcat Plugin 3.2 beta 2

Le plug-in Tomcat permet de créer un projet Web J2EE sous Eclipse qui s’exécutera sous
Tomcat. Le téléchargement s’effectue à l’adresse suivante :

http://www.sysdeo.com/eclipse/tomcatplugin. Le fichier est à décompresser dans le
répertoire « plugins », dans le répertoire d’installation d’Eclipse.

 Afin de configurer le plug-in avec l’installation Tomcat existante, les opérations suivantes
sont à réaliser.

      Vérifier que la barre d’outils Tomcat est présente.
      Configurer les chemins d’accès à Tomcat, dans « Window -> Preferences ->Tomcat » :
             Version 5.x
             Répertoire Tomcat
      Configurer la JVM dans « Windows -> Preferences ->Tomcat -> Paramètres de la JVM
       » : choisir votre JDK 1.6



Spring IDE 1.3.6

 Le plug-in Spring IDE permet de gérer les différentes configurations à effectuer pour faire
fonctionner Spring dans un projet Eclipse. En particulier, il permet d’éditer les différents
fichiers de définition de beans.

Informations de connexion :

      Nom : Spring IDE
      URL : http://springide.org/updatesite



3.3. Configurer et créer un projet Tomcat
Après avoir installé les différents composants nécessaires à l’utilisation, les prochains
paragraphes expliquent comment créer pas à pas un projet contenant toutes les
composantes de l’architecture J2EE. La première étape consiste à mettre en place le moteur
de servlet Tomcat.

 Démarrage de Tomcat

Il convient de démarrer le serveur Tomcat grâce à l’icône correspondante dans la barre
d’outil d’Eclipse. Une fois la procédure automatique de démarrage terminée, le message
affiché dans la console Eclipse doit être : INFO: Server startup in xxxx ms.

Pour vérifier que le serveur est bien lancé, il faut aller à l’adresse http://localhost:8080 dans
un navigateur : la page d’accueil de Tomcat doit être affichée.


CAR : Dossier Développeur                                                                Page 13
Création d’un projet Tomcat

Pour créer un nouveau projet Tomcat, les opérations suivantes sont à effectuer :

• Naviguer dans le menu « File -> New -> Java -> Projet Tomcat »

• Indiquer le nom du projet, dans l’exemple « TomcatTest »

• Vérifier que le nom du contexte est « /TomcatTest » : il s’agit du répertoire d’exécution du
projet. En effet, on pourra retrouver l’application en exécutant
http://localhost:8080/TomcatTest.

• Donner au répertoire racine de l’application web le nom « /WEB_CONTENT ». Cela signifie
que la racine http://localhost:8080/TomcatTest se trouvera en fait dans le dossier <RACINE
DU PROJET>/WEB_CONTENT.

Eléments d’un projet Tomcat

Un projet Tomcat génère plusieurs répertoires et fichiers, qui ont des rôles importants quant
à l’organisation du travail :

      WEB_CONTENT : répertoire de contexte du projet, c’est la racine du répertoire qui
       est interprété par Tomcat • work : répertoire où seront générés les servlets résultant
       de l’interprétation des jsp du projet .
      WEB_INF : répertoire caché pour Tomcat, c’est le seul élément contenu dans le
       contexte qui n’est pas accessible par un navigateur. Il contient entre autres les
       fichiers de configuration du projet.
      WEB_INF/src : répertoire contenant les sources de l’application Web J2EE. Il contient
       les différents packages de l’application (couche persistance, couche métier, couche
       présentation contenant les servlets).
      WEB_INF/lib : répertoire contenant les librairies de référence du projet (API à inclure
       au projet).
      WEB_INF/classes : répertoire contenant les sources compilées (générées
       automatiquement)
      WEB_INF/web.xml : ce fichier est un fichier de configuration générale, il est à créer
       dans le répertoire WEB_INF. Par défaut, le fichier web.xml de Tomcat est utilisé, mais
       il est recommandé de modifier son propre fichier de configuration spécifique.

 Créez donc un fichier web.xml dans le répertoire WEB_INF. Il contient pour l’instant
seulement les données suivantes :

 <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>



CAR : Dossier Développeur                                                               Page 14
<display-name>TomcatTest</display-name>

</web-app>

3.4. Mettre en place la couche présentation
L’architecture MVC

La couche présentation s’appuie sur l’architecture « Modèle-Vue-Contrôleur » qui permet de
séparer, au sein de la couche présentation, le fonctionnel de l’interface.

Cette architecture est réalisée par une conjonction d’une servlet (le contrôleur) et d’un
nombre quelconque de pages JSP (les vues) qui offrent le rendu à l’utilisateur. Les données
calculées par le contrôleur et fournies aux vues pour être affichées sont les modèles ; le
contrôleur s’appuie sur les couches inférieures pour obtenir ces données.




Plus précisément, le client se connecte à un unique contrôleur, en lui demandant de réaliser
une action précise. Le contrôleur, selon l’action demandée, redirige ensuite vers la vue
associée à l’action demandée.

Spring MVC

L’architecture MVC peut être améliorée grâce à l’intégration d’un des composants du
framework Spring : SpringMVC.

L’outil fournit plusieurs améliorations :

      simplification du développement : les opérations dites « génériques » inhérentes au
       modèle MVC sont réalisées par le framework
      simplification de l’organisation des contrôleurs : à une action correspond un servlet,
       Spring fournit un « DispatcherServlet » qui redirige une action vers la servlet
       correspondante


CAR : Dossier Développeur                                                              Page 15
      inversion de contrôle pour les contrôleurs : la relation entre une action et sa servlet
       associée est donnée dans un fichier de configuration et non dans le code (c’est le «
       Handler Mapping »)
      inversion de contrôle pour les vues : la relation entre une action et la vue résultante
       est données dans un fichier de configuration et non dans le code (c’est le « View
       Resolver »)




Les flèches en rouges correspondent à des relations mises en places par Spring, par
l’intermédiaire des fichiers de configuration.

Mise en place

Pour l’exemple, il s’agit d’abord de créer une servlet qui va effectuer un traitement basique :

récupérer un nom dans un formulaire et renvoyer ce nom tout en majuscules. Nous allons
créer plusieurs fichiers pour réaliser cet exemple. Ces fichiers sont à la base de tout
traitement de la couche présentation :

      form.html : le fichier qui va appeler la couche présentation (plus précisément, le
       contrôleur) pour réaliser un service particulier
      MajusculeServlet.java : la servlet qui va réaliser le service demandé
      resultat.jsp : le fichier jsp qui va contenir le résultat du service demandé
      dispatch-servlet.xml : le fichier de configuration Spring contenant les informations
       d’inversion de contrôle.
      web.xml : le fichier de configuration du projet Tomcat, qui doit contenir la
       déclaration de la servlet « DispatcherServlet » qui sera appelée par form.html



CAR : Dossier Développeur                                                               Page 16
Le DispatcherServlet sera appelé « dispatch » dans cet exemple.



Configuration initiale d’Eclipse

Reprenez le projet précédemment. En cliquant avec le bouton droit sur le projet, le menu «
Add Spring Project nature » permet d’utiliser le plug-in Spring IDE pour le projet.



Il faut également copier les libraires de Spring pour le projet. Naviguez jusqu’au répertoire
d’installation de Spring, puis dist et copiez le fichiers suivant dans le dossier WEB-INF/lib :

      spring.jar



Ensuite, importez la librairie de Spring dans le projet, en cliquant-droit sur le projet -
>Refresh puis Clic-Droit -> Properties ->Java Build Path -> Add JAR et ajoutez spring.jar.



Création du formulaire

Créez un fichier HTML « form.html » contenant un simple formulaire. Pour cela, rajoutez le
code suivant dans la balise body :

       <form name=”formulaire”

       action=”http://localhost:8080/TomcatTest/majuscule.do” method=”get”>

       <input type=”text” name=”nom”/>

       <input type=”submit” name=”envoyer” value=”Envoyer”/>

       </form>

 La propriété “Action” du formulaire une adresse fictive qui permet d’identifier l’action a
réaliser. Spring va se baser sur une méthode de mapping action/servlet pour déterminer
quelle servlet devra gérer cette action. La méthode de mapping la plus courante consiste à
se baser sur cette adresse fictive.



Configuration de l’application web

L’étape suivante consiste à déclarer la servlet « dispatch » dans le fichier web.xml.

Rajoutez le code suivant à l’intérieur de la balise « web-app » :


CAR : Dossier Développeur                                                                Page 17
          <servlet>

            <servlet-name>dispatch</servlet-name>

            <servlet-class> org.springframework.web.servlet.DispatcherServlet

          </servlet-class>

            <load-on-startup>1</load-on-startup>

          </servlet>



servlet-name : le nom de la servlet, comme il devra être appelé à partir d’un navigateur.

servlet-class : la classe qui contient le code de la servlet

load-on-startup : à 1, car la servlet doit être chargée dès le lancement de l’application web



Rajoutez également le code suivant à la suite :

          <servlet-mapping>

            <servlet-name>dispatch</servlet-name>

            <url-pattern>*.do</url-pattern>

          </servlet-mapping>



Il permet de s’assurer que seuls des fichiers de type *.do seront des pages (fictives) qui
feront appels à la servlet. Ainsi, les fichiers de type *.do déclencheront automatiquement
l’appel à la servlet DispatcherServlet.

servlet-name : le nom de la servlet concernée url-pattern : motif de reconnaissance de l’url
de l’appelant (exemples : « *.jsp », « app-*.* » ou plus strict, « login.html ».



Création de la servlet

Nous allons créer la servlet MajusculeServlet qui réalise l’opération de mise en majuscule du
nom. Dans le répertoire « WEB_INF/src », créez un dossier « presentation » qui sera le
package qui contiendra la servlet. Créez dans ce dossier une classe « MajusculeServlet »,
dans le package « presentation ».



CAR : Dossier Développeur                                                               Page 18
 Une servlet incluse dans le framework Spring doit obligatoirement implémenter l’interface «
Controller ». Cependant, Spring propose des classes de contrôleurs déjà implémentées,
contenant des opérations génériques, par exemple, à la réception d’un formulaire, à la
réception d’un login, etc… Notre servlet pourrait donc hériter de la classe «
AbstractFormController », qui donne des outils pour gérer les formulaires mal remplis, la
redirection vers une page d’erreur ou une page de validation.

Pour l’exemple, nous n’allons pas utiliser cet héritage.

Voici le code de la servlet :

       package presentation;

       import java.util.HashMap;

       import java.util.Map;

       import javax.servlet.http.HttpServletRequest;

       import javax.servlet.http.HttpServletResponse;

        import org.springframework.web.bind.ServletRequestUtils;

       import org.springframework.web.servlet.ModelAndView;

       import org.springframework.web.servlet.mvc.Controller;

        public class MajusculeServlet implements Controller

       {

           public ModelAndView handleRequest(HttpServletRequest request,

       HttpServletResponse response) throws Exception

            {

           // Récupération du paramètre

           String nom = ServletRequestUtils.getStringParameter(request, "nom");

           // Mise en majuscule

           nom = nom.toUpperCase();

            // Création des paramètres pour la vue et redirection

           Map<String,Object> model = new HashMap<String,Object>();

           model.put("majNom", nom);


CAR : Dossier Développeur                                                           Page 19
           return new ModelAndView("/resultat.jsp",model);

            }

       }

Création du fichier de configuration Spring

Il est maintenant nécessaire de créer un fichier de configuration Spring, qui va contenir les
informations de mapping pour la servlet « dispatch ». Cela correspond à la première flèche
rouge de notre schéma.

Le fichier s’appellera toujours « <nom de la servlet>-servlet.xml », dans notre cas le fichier
se nomme : dispatch-servlet.xml. Il est situé dans le répertoire WEB-INF.




Pour effectuer un contrôle permanent sur le contenu de ce fichier, il faut définir sa nature,
i.e. un script de configuration Spring. Pour cela, cliquez-droit sur le projet, puis naviguez vers
« Spring ->Config Files ».

Ajoutez ensuite le fichier dispatch-servlet.xml à la liste des fichiers de configurations. Le
fichier doit maintenant apparaître avec l’icône « S » dans l’explorateur d’Eclipse.

Affichez ensuite la fenêtre de contrôle SpringIDE, en sélectionnant « Window -> Show View -
> Other -> Spring -> Spring Beans ». Cette fenêtre sert de vérificateur et d’explorateur de
fichier Spring.

 Editez maintenant le fichier. Ce fichier doit contenir l’information de mapping entre l’action
requise et la servlet qui va traiter la requête. Spring offre plusieurs façons d’effectuer ce
mapping, la plus classique étant en identifiant la page qui a déclenché l’action (dans
l’exemple, « form.html »).

Important : un fichier Spring est constitué d’un ensemble de « beans » qui sont nommés par
un identifiant et toujours rattachés à une classe java.

Il faut dans un premier temps déclarer la méthode de mapping, en affectant au bean «
handlerMapping » la classe « BeanNameUrlHandlerMapping » de Spring, qui effectue le
mapping classique décrit plus haut.

       <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

           "http://www.springframework.org/dtd/spring-beans.dtd">

       <beans>



CAR : Dossier Développeur                                                                 Page 20
        <bean id="handlerMapping"

       class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>

       </beans>

Ensuite, il faut associer les actions provenant de « majuscule.do » à la servlet «
MajusculeServlet ». Pour cela, il faut rajouter le code suivant à l’interieur de la balise
<beans> :

       <bean name="/majuscule.do" class="presentation.MajusculeServlet" />

 Création de la JSP de résultat Pour finir notre mise en place de la couche Présentation, il est
nécessaire de coder la JSP de retour (la vue de notre architecture). Créez un fichier JSP dans
le répertoire WEB_CONTENT (New -> Other -> Web -> JSP).

Une jsp contient du code Java situé entre balise <% %>. Un cas particulier : pour simplement
écrire une expression, la balise <%= expression %> est utilisable.

Rajoutez le code suivant dans la balise body.

        <% String nom = (String)request.getAttribute("majNom"); %>

       <p> Votre nom en majuscules : <%=nom %> </p>



Vous pouvez maintenant tester l’ensemble, en redémarrant le serveur Tomcat, afin que les
fichiers de configurations soient pris en compte. Tapez ensuite dans le navigateur :

       http://localhost:8080/TomcatTest/form.html.

Utilisation d’un View Resolver

Spring fournit également des classes permettant d’implémenter l’inversion de contrôle en ce
qui concerne les vues. Cela correspond à la deuxième flèche rouge dans notre schéma.

Le but est de ne pas implémenter directement les adresses des vues (par exemple,
resultat.jsp) dans le code des servlets, mais plutôt utiliser des identifiants de beans. Ensuite,
dans un fichier de configuration, Spring retrouve la relation entre le bean et l’adresse de la
page jsp associée.

Il existe de nombreux ViewResolvers fournis par Spring, nous allons utiliser le plus classique :
XmlViewResolver. Il s’appuie sur un fichier XML donnant les relations beans/adresses.

Il faut dans un premier temps notifier à Spring que nous utilisons ce ViewResolver, dans le
fichier dispatch-servlet.xml. Pour cela, rajoutez le bean suivant :

         <bean id="viewResolver"


CAR : Dossier Développeur                                                                    Page 21
        class="org.springframework.web.servlet.view.XmlViewResolver">

        <property name="location"><value>WEB-INF/views.xml</value></property>

        </bean>

La propriété « location » donne le nom du fichier XML qui contiendra les relations
beans/adresses.

 Créez maintenant un fichier « views.xml » dans le répertoire WEB-INF, qui va contenir le
code suivant :

        <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

        "http://www.springframework.org/dtd/spring-beans.dtd">

       <beans>

        <bean name="resultatMaj"

        class="org.springframework.web.servlet.view.InternalResourceView">

         <property name="url">

          <value>/resultat.jsp</value>

         </property>

        </bean>

       </beans>

bean name : l’identifiant de bean, qui sera appelé parle code de la servlet

bean class : la classe permettant de générer la vue. Il existe de nombreux générateurs de
vues

fournis par Spring : InternalResourceView gère les JSP, mais on trouve aussi
AbstractExcelView, AbstractPdfView qui peuvent être implémentés pour exporter des vues
en XLS ou PDF.

property value : l’adresse de la vue concernée

Il ne reste plus qu’à modifier le code de la servlet en remplaçant l’adresse du jsp par le nom
du bean correspondant :

return new ModelAndView("resultatMaj",model);

Documentation sur les formulaires Spring à rédiger



CAR : Dossier Développeur                                                              Page 22
Documentation sur les displays tags à rédiger.



3.5. Mettre en place les couches mapping et métier


Le rôle d’Hibernate

Hibernate est un outil de mapping objet/relationnel. Il gère le dialogue entre les objets
métiers (couche métier) et les tables de base de données (couche physique). Son rôle est,
d’une part, de permettre de réaliser les opérations génériques sur une donnée (CRUD :
Create Read Update Delete). Pour le développeur, il suffit de modifier l’objet Java ;
Hibernate transforme cette opération en requête SQL et l’exécute.

D’autre part, Hibernate fournit un langage de requête plus évolué, permettant d’obtenir
l’équivalent des clauses SELECT. Ce langage, le HQL est très proche du SQL mais fait
intervenir les objets Java et leurs attributs au lieu des noms de tables et leurs champs.

Afin de connaître la relation précise entre une classe Java et son équivalent en base de
données, Hibernate s’appuie sur des fichiers de mapping, au format XML.



Chargement des librairies

Afin d’utiliser Hibernate dans votre projet, vous devez copier les librairies suivantes dans le
répertoire WEB-INF/lib :

      hibernate3.jar, présent dans le répertoire d’installation d’Hibernate
      antlr-2.7.6rc1.jar, présent dans le répertoire « lib » d’Hibernate
      asm.jar, présent dans le répertoire « lib » d’Hibernate
      cglib-2.1.3.jar, présent dans le répertoire « lib » d’Hibernate
      commons-collection-2.1.1.jar, présent dans le répertoire « lib » d’Hibernate
      commons-logging-1.0.4.jar, présent dans le répertoire « lib » d’Hibernate
      dom4j-1.6.1.jar, présent dans le répertoire « lib » d’Hibernate
      ehcache-1.1.jar, présent dans le répertoire « lib » d’Hibernate
      jta.jar, présent dans le répertoire « lib » d’Hibernate



Vous devez également ajouter dans ce répertoire le pilote JDBC pour oracle (OJDBC14.jar)
ainsi que les Hibernate Tools (hibernatetools.jar) téléchargés préalablement.




CAR : Dossier Développeur                                                                Page 23
Toutes ses libraires doivent être ensuite chargées dans le projet, en cliquant-droit sur le
projet -> Refresh puis Clic-Droit -> Properties -> Java Build Path -> Add JAR et ajoutez
spring.jar.

Générer les fichiers de mapping et des classes Java avec Middlegen

 Middlegen et son plug-in pour Eclipse, MiddlegenIDE permettent de se connecter à la base
de données existante, d’analyser les tables et les relations présentes et de générer les
fichiers de mapping et les objets métiers correspondants.

Voici les étapes à suivre pour réaliser cette opération :

      Créez un package « business » dans le dossier « WEB-INF/src », celui-ci contiendra les
       objets métiers.
      Créez un package « mapping » dans le dossier « WEB-INF/src », celui-ci contiendra les
       fichiers de mapping Hibernate.
      Dans le dossier WEB-INF, créez un MiddleGen Build File (New -> Other -> Middlegen -
       >Middlegen Build File), qui s’appelera middlegen-build.xml. Ce fichier contiendra les
       informations qui seront passées à Middlegen pour la génération.
      Les informations suivantes sont à fournir :
        JDBC Jar : le fichier ojdbc14.jar, pilote JDBC pour Oracle téléchargé plus tôt
        JDBC Driver : oracle.jdbc.driver.OracleDriver
        Database URI : jdbc:oracle:thin:@localhost:1521:XE
        User : l’utilisateur créé pour Oracle
        Password : le mot de passe associé
        Schéma : l’utilisateur en majuscule
        Cliquez sur Load Table pour vérifier la connexion : les tables de la base de
           données doivent s’afficher. Sélectionnez (Ctrl+Clic) les tables qui sont à mapper.
        Package : com.esil.car.mapping
        Plugin : Hibernate
      Cliquez sur « Finish » : Middlegen va être lancé après avoir extrait les différentes
       tables de la base de données.
      Cliquez sur « Generate ».

Vous pourrez alors trouver dans le dossier mapping plusieurs fichiers .hbm.xml et .java. Les
fichiers hbm.xml sont les fichiers de mapping qui seront utilisés par Hibernate : il y en a un
par table de données. Les fichiers .java sont les objets métiers créées à partir de la base de
données.




Le modèle DAO



CAR : Dossier Développeur                                                               Page 24
L’architecture du système, dans les couches d’accès aux données, suit le modèle DAO (Data
Access Objects). Le principe de ce modèle est de séparer un objet métier des opérations
relatives à l’accès aux bases de données. Par exemple, le calcul de dérivations ne peut
s’effectuer qu’à partir de requêtes spéciales dans la base de données, souvent écrites en
SQL.

Hibernate fournit un langage de requêtes de plus haut niveau, le HQL. Néanmoins,
l’implémentation de requêtes HQL doit être séparée des objets métiers car elles
représentent une implémentation spécifique à Hibernate. On pourrait vouloir fournir une
tout autre implémentation, par exemple en SQL natif.

On crée donc une interface DAO, définissant les fonctions à implémenter concernant l’accès
à données. Puis, une implémentation spécifique, par exemple à Hibernate, sera effectuée
dans un objet dérivé de l’interface DAO.

3.6. Utiliser Spring dans la couche métier
Spring propose de nombreuses extensions pour gérer plus simplement la couche métier.
Une partie de code de développement sera prise en charge par Spring, ce qui constitue un
gain de temps dans le développement. Concernant la couche métier, Spring peut intervenir à
deux niveaux : pour la liaison des DAO et le mapping Hibernate.

Création d’un contexte d’application

A l’image du fichier « dispatch-servlet.xml », un fichier XML est nécessaire afin de configurer
Spring pour la couche métier. Ce fichier définit ce que l’on appelle le contexte de
l’application. On le représentera dans le dossier WEB-INF par le fichier
applicationContext.xml. Ce fichier se constitue des mêmes éléments que le fichier «
dispatch-servlet.xml », i.e. des définitions de beans.

La première étape consiste à indiquer à l’application où se trouve le fichier de contexte et
qu’il doit être chargé. On utilise pour cela un contextLoaderListener, classe Spring que l’on va
déclarer dans le fichier web.xml (fichier de configuration de l’application pour Tomcat).

         <listener>

       <listener-class>

        org.springframework.web.context.ContextLoaderListener

       </listener-class>

        </listener>

        <context-param>

          <param-name>contextConfigLocation</param-name>



CAR : Dossier Développeur                                                               Page 25
           <param-value>/WEB-INF/applicationContext.xml</param-value>

         </context-param>

Le fichier applicationContext.xml contiendra, a minima, les informations suivantes :

         <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

         "http://www.springframework.org/dtd/spring-beans.dtd">

        <beans>

        </beans>



Utiliser Spring pour le modèle DAO

Le modèle DAO présenté précédemment permet de séparer logique métier et
implémentation spécifique. Dans notre exemple, notre objet Employé possède une
propriété, référence à un objet dérivé de « EmployéDAO ». Cependant, il est nécessaire lors
de l’initialisation d’un objet Employé d’instancier un objet EmployéDAO, et donc d’indiquer
lequel des objets dérivés sera utilisé (EmployéDAOHibernate, EmployéDAOSQL, …).

Ce qui introduit une dépendance de code entre l’objet Employé et une implémentation
particulière de l’objet DAO :

 public Employe()

  {

      this.employeDAO = new EmployeDAOHibernate();

  }

Spring permet de déplacer cette dépendance dans un fichier XML. L’instanciation d’un objet
DAO dérivé est prise en charge par Spring, qui saura quelle classe charger d’après son fichier
de configuration. L’objet Employé n’aura alors qu’à manipuler qu’un objet de type abstrait «
EmployéDAO ». La liaison gérée par Spring est indiquée par une ligne rouge.

Pour réaliser cette opération, il suffit de rajouter dans le fichier applicationContext.xml la
déclaration d’un « bean » qui indiquera quelle classe spécifique est liée au DAO :

        <bean name="employeDao"

         class="com.car.central.services.employe.EmployeDAOHibernate">

        </bean>




CAR : Dossier Développeur                                                                 Page 26
L’identifiant “employeDao” est totalement arbitraire, il permet de faire appel à ce bean lors
de l’installation. La propriété class indique la véritable classe reliée à ce bean, et qui devra
être instanciée par Spring.



Ainsi, l’instanciation du bean se fait par simple invocation du contexte Spring :

Resource resource = new FileSystemResource("/WEB_CONTENT/WEB-
INF/applicationContext.xml");

XmlBeanFactory factory = new XmlBeanFactory(resource);

  employeDAO = (EmployeDAO)factory.getBean("employeDao");



Utiliser Spring pour le mapping Hibernate

L’outil Hibernate encapsule les opérations principales d’accès à la base de données.

Cependant, le développement de classes utilisant Hibernate doit gérer l’ouverture d’une
session Hibernate, l’instanciation d’une transaction avec la base de données, effectuer les
opérations désirées, et lancer un « commit » de la transaction.

Spring permet de dispenser le développeur de ces opérations génériques et fastidieuses.

 Il suffit pour cela de signifier à Spring que le module pour Hibernate doit être chargé. Il
faudra fournir à Spring les paramètres de connexions à la base de données car Spring va
jouer les intermédiaires entre l’application et l’outil Hibernate.

Pour cela, rajoutez ceci dans le fichier applicationContext.xml :

       <bean id="dataSource"

        class="org.springframework.jdbc.datasource.DriverManagerDataSource">

        <property name="driverClassName">

       <value>oracle.jdbc.driver.OracleDriver</value>

       </property>

       <property name="url">

       <value>jdbc:oracle:thin:@localhost:1521:XE</value>

       </property>


CAR : Dossier Développeur                                                                Page 27
          <property name="username"><value>car</value></property>

           <property name="password"><value>car</value></property>

          </bean>



driverClassName : le nom de la classe gérant le pilote de connexion à la base de données

url : l’url de connexion à la base de données

username & password : identifiant et mot de passe d’authentification à la base de données

Une fois le module indiqué dans le contexte d’application de Spring, vous devez lister les
objets qui devront être mappés. Pour réaliser cela, il suffit de rajouter dans le fichier la liste
des fichiers de mapping (.hbm.xml) générés précédemment.

 <bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<property name="dataSource"><ref local="dataSource"/></property>

 <property name="mappingResources">

<list>

<value>com/car/central/mapping/Affecter.hbm.xml</value>
<value>com/car/central/mapping/Categorie.hbm.xml</value>

...

<value>com/car/central/mapping/Produit.hbm.xml</value>
<value>com/car/central/mapping/Visite.hbm.xml</value>

</list>

</property>

<property name="hibernateProperties">

      <props>

      <prop key="hibernate.dialect">

org.hibernate.dialect.OracleDialect

</prop>

<prop key="hbm2java">update</prop>


CAR : Dossier Développeur                                                                  Page 28
  </props>

 </property>

</bean>



Par la suite, toute classe qui utilise directement les primitives Hibernate devra hériter de la
classe HibernateDaoSupport. Pour invoquer une primitive Hibernate, il suffit d’appeler la
fonction getHibernateTemplate() qui fournit un objet « Hibernate » permettant d’accéder à
tous les services de l’API.



Exemple :

getHibernateTemplate().find("from mapping.DirecteurComm as dc where dc.empId = " +
id);

Dernière configuration, toute classe utilisant les primitives Hibernate devra être déclarée
sous forme de bean dans le fichier applicationContext.xml, et contenir la propriété suivante :

 <property name="sessionFactory">

       <ref local="sessionFactory"/>

 </property>

Par exemple, incluez cette propriété dans les balises “bean” de chaque objet DAO déclaré
dans le paragraphe précédent :

       <bean id="employeDao"

        class="com.esil.car.services.employe.EmployeDAOHibernate">

        <property name="sessionFactory">

       <ref local="sessionFactory"/>

       </property>

       </bean>




CAR : Dossier Développeur                                                               Page 29
4. Composants pour la base de données mobile
Le paragraphe suivant explique l’installation d’une base de données Oracle Lite, tant coté serveur
que côté client.

La configuration qui nous intéresse est la suivante :




4.1. Télécharger et installer Oracle Lite Mobile Server
Le logiciel Oracle Lite est téléchargeable à l’adresse suivante :

http://www.oracle.com/technology/software/products/lite/, dans sa version 10g release 2
(10.2.0.1.1). Après téléchargement, le lancement de l’installeur est nécessaire. Il faut choisir
une installation personnalisée et sélectionnez toutes les possibilités : serveur, MDK,
documentation et dépendances. Au fur et à mesure des écrans successifs, les données
suivantes doivent être fournies :



       Informations sur la base de données

        Nom d’hôte :car.homeip.net (l’adresse IP du serveur central, ou le nom d’hôte DNS)

        Port : 1521

        SID : XE




CAR : Dossier Développeur                                                                    Page 30
      Informations sur le schéma fourni par Oracle Lite Mobile Server

       Nom du schéma : MOBILEADMIN

       MDP : admin

      Informations pour la connexion au Mobile Server :

       Nom administrateur : Administrator

       MDP : admin

       Informations pour la connexion à l’application d’exemple

       Nom du schéma d’exemple : master

       MDP : admin



4 .2. Configurer et publier une application Webtogo
Le serveur mobile utilise une technologie appelée « Webtogo ». Chaque application utilisant
une synchronisation Oracle Lite doit être publiée. La partie de la base de donnée centrale qui
doit être synchronisée est appelée un snapshot ou un cliché. Ce snapshot est défini par un
ensemble de tables caractérisées par des requêtes. On peut assimiler le mécanisme avec la
définition de vues.

Pour publier une application, il faut utiliser le Packaging Wizard, situé dans le répertoire
d’installation d’Oracle Lite, puis dans Mobile/SDK/Bin, sous le nom wtgpack.exe.

Création de l’application

Sélectionnez « Créer une définition d’application », puis la plate forme «Oracle Lite PPC2003
ARMV4;US ». Remplissez ensuite les informations suivantes :

      Nom d’application : CAR
      Chemin virtuel : « /CAR »
      Description : CAR pour iPhone

Ensuite, validez, passez également l’écran suivant sans sélectionner de fichiers.

Choisissez ensuite comme nom de base de données « CAR ». Il s’agit du DSN que l’on devra
utiliser pour se connecter à la base de données mobile dans l’application .NET embarquée.




CAR : Dossier Développeur                                                                Page 31
 Dans l’écran suivant, cliquez sur importer pour sélectionner les tables que vous souhaitez
synchroniser. Entrez les informations suivantes :

 Nom utilisateur : caruser

 Mot de passe : admin

 URL de la base de données : jdbc:oracle:thin:@car.homeip.net:1521:XE

Validez, puis choisissez les tables que vous souhaitez synchroniser. Cliquez ensuite sur
Ajouter et fermez la fenêtre.

 Pour chaque table ajoutée, il convient maintenant d’éditer la requête qui va déterminer,
avec précision, le sous-ensemble de la table qui sera synchronisée. Sélectionnez pour cela la
table concernée et cliquez sur « Modifier ». Sélectionnez ensuite l’onglet « Oracle Lite
PPC2003 ARMV4 ;US », et personnalisez le champ « Modèle ».

Les derniers écrans n’ont pas à être modifiés. Vous pouvez ainsi publier l’application en
sélectionnant « Créer des fichiers », puis en cochant « packager l’application dans un fichier
JAR ».



4.3. Lancer le serveur Mobile Server
Accédez au répertoire d’installation d’Oracle Lite, puis
Mobile\Server\bin\runmobileserver.bat.

Pour vérifier la mise en route du serveur, connectez-vous avec un serveur web à la page
http://localhost/webtogo.

Inscription de l’application sur le serveur

Il convient maintenant d’inscrire l’application créée préalablement sur le serveur mobile.
Pour cela, connectez-vous au serveur et entrez les informations de connexion :

      Login : Administrator
      Mot de passe : admin

Sélectionnez ensuite le Mobile Manager, puis cliquez sur le nom d’hôte qui correspond à la
machine locale. Naviguez dans le menu « Applications » et cliquez sur « Publier l’application
».

Entrez les informations suivantes :

      Assistant Packager une application – Fichier JAR
      Fichier JAR : le fichier JAR créé lors de l’étape précédente

Puis, publiez l’application.


CAR : Dossier Développeur                                                              Page 32
Création d’un utilisateur

 La dernière étape de préparation consiste à créer un utilisateur qui aura les droits de
synchronisation sur cette application. Il ne s’agit pas des utilisateurs qui auront accès à la
base de données embarquée, mais des utilisateurs qui peuvent se connecter au serveur
mobile à partir d’un client pour solliciter une synchronisation.

Toujours dans le Mobile Manager, naviguez dans le menu « Ajouter un utilisateur », puis
entrez les informations suivantes :

      Nom d’affichage : Car User
      Nom utilisateur : CARUSER
      Mot de passe : admin
      Privilège : USER

Ne modifiez rien d’autre et validez.

L’utilisateur apparaît dans la liste des utilisateurs. Cliquez sur l’utilisateur nouvellement créé
et naviguez sur l’onglet : « Accès ». Cochez l’application CAR puis enregistrez.



4.4. Installation d’Oracle Lite sur l’iPhone
L’installation d’Oracle Lite Mobile Client sur iPhone est réalisée en téléchargeant les fichiers
à partir du Mobile Server.

Connectez-vous (en USB ou en WiFi) au PC contenant le serveur Mobile, puis accédez au
serveur grâce à un navigateur web : http://adresseIP/webtogo/setup. Choisissez ensuite la
langue français et recherchez des Mobile Client : il s’agit là de trouver le fichier d’installation
pour Oracle Lite Mobile Client. Sélectionnez le package « Oracle Lite PPC2003 XScale » et
téléchargez le dans un répertoire de l’ iPhone.

Exécutez ensuite le fichier « Setup.exe » et installez Oracle Lite sur l’ iPhone.

Naviguez ensuite, grâce à l’explorateur de fichiers, jusqu’à la racine de l’ iPhone, puis le
dossier « orace » créé par l’installation. Cliquez sur le fichier « olite ».

Une fois l’installation terrminée, une première synchronisation doit être effectuée. Exécutez
le programme mSync. Pour se connecter, utilisez le login « CARUSER » et le mot de passe «
admin », puis donnez comme serveur l’adresse IP de votre PC contenant le mobile Server (ou
le nom de la machine dans le cas d’une connexion par USB). Ensuite, en appuyant sur « Sync
», la synchronisation doit s’effectuer.




CAR : Dossier Développeur                                                                  Page 33
 ATTENTION : En cas d’erreur de nom d’utilisateur ou de mot de passe, le module de
synchronisation doit être complèment réinstallé. Ceci est encore du à une incompatibilité
avec la version 5 de Windows Mobile.



4.5. Configurer Oracle Lite pour la connexion Wifi
Afin de réaliser une synchronisation par réseau Wifi, plusieurs paramètres sont à positionner
sur l’iPhone.

       Activer la carte WiFi, grâce à la première icône dans le gestionnaire de
       communications. Le réseau WiFi fourni doit être détecté dans la liste des connexions
       Wifi : Naviguer dans Paramètres -> Connexions -> Cartes réseau : Connexion Wifi
       (Configuration réseau sans fil)




       Dans cette même fenêtre, cliquer sur le réseau WiFi fourni est vérifier les
       paramètres suivants :
        Onglet « Général » : Se connecter à Internet
        Onglet « Clé réseau » : Authentification = ouvert, Cryptage = désactivé

      Naviguer dans Paramètres ->Connexions -> Cartes réseau et vérifier les paramètres
       suivants :
        Ma carte réseau se connecte à Internet

      Cliquer sur la carte SDIO WLAN Wireless Adapter :
        Adresse IP : Adresse IP allouée par serveur
        Serveurs de nom : rien




CAR : Dossier Développeur                                                             Page 34
5. Mise en place du wiki


Le wiki est un site de travail collaboratif. Il permet notamment le partage de documents et
du code source avec versioning, il aide à la planification des tâches et à la communication au
sein de l’équipe. Compte-tenu des contraintes (pas de serveur personnel, pas d’abonnement
payant à un wiki en ligne), il a été décidé d’utiliser les services proposés par le site
Sourceforge. Sourceforge est un site de développement open-source, mettant à la
disposition des développeurs un espace réservé et une multitude d’outils.



5.1. Inscription à sourceforge (Create Account)


Il faut tout d’abord créer un compte sur sourceforge. Allez sur le site
http://sourceforge.net et cliquez sur le lien « Create Account » en haut à droite de la page :




CAR : Dossier Développeur                                                              Page 35
Vous arrivez sur la page « Account Registration » suivante :




Renseignez tous les champs nécessaires.

Vous allez recevoir un email de confirmation à l’adresse email que vous venez d’indiquer.
Cliquer sur le lien de confirmation pour finaliser votre inscription.



5.2. Identification sur sourceforge (Log In)


Allez sur la page d’accueil de sourceforge (http://sourceforge.net). Pour vous identifiez,
cliquez sur le lien « Log In » en haut à droite de l’écran :




CAR : Dossier Développeur                                                              Page 36
Vous arrivez sur la page suivante :




Entrez vos informations d’identification (username + password). Vous pouvez cliquer la case
« Remember Me » pour ne pas avoir à répéter cette étape lors de vos prochaines visites.
Pour finir cliquez sur le bouton « Log In ». Vous revenez sur la page d’accueil de sourceforge.
Vous pouvez vérifier que vous êtes bien identifié si votre username apparaît en haut droite.




CAR : Dossier Développeur                                                              Page 37
5.3. Création d’un projet Sourceforge


Cette étape est à réaliser une seule fois par un des membres de l’équipe (par exemple le
responsable de projet).

Allez sur la page d’accueil de sourceforge. Si ce n’est pas déjà le cas, identifiez-vous. Cliquez
sur le lien « Create Project » :




CAR : Dossier Développeur                                                                 Page 38
Vous arrivez sur la page suivante :




Cliquez sur le bouton « Create a Project ». Vous arrivez sur la page Create Project :




CAR : Dossier Développeur                                                               Page 39
Rentrez le nom de votre projet, l’URL qui sera utilisé par tous les utilisateurs pour accéder au
projet (vous pouvez cliquez sur le bouton « Suggest Unix Name »), et une brêve description
du projet. Cochez la case « I have read […] » et cliquez sur le bouton « Complete
Registration ».



5.4. Utilisation de Sourceforge


Pour pouvoir accéder à la plateforme relative au projet, vous devez d’abord communiquer
votre identifiant sourceforge à votre responsable de projet, qui aura préalablement créé et
configuré le projet. Attendez qu’il vous ajoute au projet, vous recevrez un email de
confirmation.

Une fois rajouté au projet, vous pouvez y accéder en cliquant sur le lien « Develop » depuis
la page d’accueil de sourceforge (vous devez être loggé) :




CAR : Dossier Développeur                                                               Page 40
Vous arrivez sur la page suivante :




Cliquez sur le nom de votre projet dans la colonne « My Projects » pour aller sur la page de
votre projet. Vous arrivez sur la page suivante :




CAR : Dossier Développeur                                                             Page 41
Un total de 9 onglets sont disponibles. Nous ne traiterons que de ceux utiles dans le cadre de
ce projet.



5.4.1. Summary


L’onglet « Summary » est un résumé des informations importantes du projet : la description,
l’url, les news relatives au projet, etc.



5.4.2. Files


L’onglet « Files » permet un partage de document. Tous les développeurs peuvent visualiser
et télécharger les documents. Seul un administrateur peut uploader un document. Pour cela,
il faut cliquer sur l’onglet « Project Admin » puis sur « File Manager » :




CAR : Dossier Développeur                                                             Page 42
Vous arrivez sur la page « File Manager » :




Cliquez sur le bouton « Upload File » pour uploader un fichier depuis votre ordinateur, ou
bien sur le bouton « Create New Folder » pour créer un nouveau dossier.




CAR : Dossier Développeur                                                            Page 43
5.4.3. Forums


L’onglet « Forums » permet d’accéder à un forum, divisé en 3 parties : Developers, Help et Open
Discussion :




Le sous-forum « Developers » n’est accessible qu’aux développeurs ayant été ajouté au projet. Vous
pouvez donc l’utiliser librement pour des discussions sur le projet, son organisation, etc. Cliquez sur
le lien « Developers » pour accéder à cette sous-partie.

Pour ajouter un nouveau topic, entrez un titre de topic et le corps de votre message, puis cliquez sur
le bouton « Add Topic ». Cochez au passage la case « Monitor This » si vous voulez être averti par
email à chaque fois que quelqu’un répond sur ce topic :




CAR : Dossier Développeur                                                                      Page 44
Nous vous conseillons de cliquer sur le bouton général « Monitor » en haut à droite pour
monitorer tout le forum :




CAR : Dossier Développeur                                                           Page 45
5.4.4. Code


L’onglet « Code » sera utilisé pour le versioning du code source. Par défaut, l’outil Subversion (SVN)
est installé. Si vous le souhaitez, vous pouvez utiliser un autre outil tel que CVS, mais nous vous
recommandons l’utilisation de SVN.

L’url du repository est indiqué sur la première page :




CAR : Dossier Développeur                                                                      Page 46
Dans le sous-menu de l’onglet « Code », vous pouvez cliquer sur « SVN Browse » pour afficher la liste
des fichiers du repository :




Pour uploader des fichiers sur le repository depuis votre ordinateur sous Windows, vous pouvez
utiliser le logiciel TortoiseSVN, ou bien le plug-in Subversion Client for Windows sous NetBeans.




CAR : Dossier Développeur                                                                     Page 47
5.4.5. Project Admin


Dans l’onglet « Project Admin », vous pouvez cliquer sur « Feature Settings » pour rendre disponible
un certain nombre d’outils utiles pour la réalisation du projet. Entre autre : wiki, bug tracker,
guestbook, forum, etc.



5.5. Mise en œuvre du versioning
5.5.1 Installation du plug-in Subversion sous NetBeans


Vous devez d’abord installer le client Subversion sous NetBeans. Dans NetBeans, cliquez sur Tools ->
Plugins. Dans le pop-up qui apparaît, cliquez sur l’onglet « Available Plugins » et sélectionnez le
« Bundled Subversion Client for Windows » :




Cliquez sur Install. Le pop-up « NetBeans IDE Installer » apparait. Cliquez sur Next, cochez la case « I
accept the terms […] » puis cliquez sur Install. Vous devrez redémarrer NetBeans après l’installation.




CAR : Dossier Développeur                                                                       Page 48
5.5.2 Première utilisation de Subversion


Sourceforge met à votre disposition un « Subversion repository », arbre qui contiendra le code
source de votre projet. Lors de la première utilisation, il vous faudra importer le projet une unique
fois sur le repository.

Dans NetBeans, faites un clic droit sur votre projet dans la fenetre Project. Puis Versioning -> Import
into Subversion repository.

Dans le pop-up Import qui apparait, entrer l’URL du repository (dans notre cas,
https://esil.svn.sourceforge.net/svnroot/esil). Renseignez également votre nom d’utilisateur et mot
de passe de votre compte sourceforge :




Cliquez sur Next. Patientez quelques instants le temps que la connexion au repository s’effectue.
Spécifiez éventuellement le Repository Folder, dossier dans lequel sera stocké le code et cliquez sur
Next. Patientez quelques instants et cliquez sur Finish.




CAR : Dossier Développeur                                                                       Page 49
5.5.3 Cycle d’utilisation de Subversion


L’utilisation d’un système de versioning dans le développement d’un projet en équipe est
relativement simple. Il correspond au cycle : Update -> Edit -> Update -> Commit.

Avant de commencer à modifier votre code, vous devez récupérer la dernière version du code avec la
commande Update. Faites un clic droit sur le projet puis Subversion -> Update.

Vous pouvez ensuite travailler sur votre code. Quand vous désirez envoyer votre code sur le
repository, refaites d’abord la commande Update. Ceci vous permettra de récupérer les
modifications effectuées pendant votre travail et de vérifier que personne n’a modifié les mêmes
sources que vous. Faites ensuite clic droit sur le projet puis Subversion -> Commit pour envoyer vos
changements sur le repository. Entrez un commentaire explicite pour permettre aux autres de
comprendre le changement.

En cas de conflit entre votre working copy (les codes sources locaux sur lesquels vous travaillez) et le
repository, vous verrez apparaître en bleu les différences. Vous pouvez afficher la Diff Window pour
mieux visualiser les différences entre votre version du code et la version la plus récente du
repository. Vous pouvez ensuite décider d’appliquer ou non les changements.




CAR : Dossier Développeur                                                                       Page 50

				
DOCUMENT INFO
Categories:
Tags:
Stats:
views:5
posted:3/30/2012
language:
pages:50