Table of Contents

TD1 : Prise en main de l'environnement de développement

Objectifs : Par le développement d'un mini-bus à messages nous mettons en place notre environnement de travail et rappelons les notions de base de la COO.

Le sujet est dans cette version initiale très facile. Il doit être traité dans les 2 heures ! Les temps donnés expriment le temps maximum estimé pour faire la tâche. A vous de voir si vous parvenez à les respecter.

Présentation de l'application

Il s'agit de construire les bases “rudimentaires” d'un “bus à messages”.

Un exemple de scénario :

Attention, il s'agit d'un exemple concret mais c'est bien la notion de bus que l'on vous demande dans un premier temps de mettre en oeuvre.

L'agence “oogle-Agency” (Agent) crée un bus logiciel “Nice-circulation”. La voiture A (Producteur) émet un message mAttente : “Attente de 5mn” vers du bus logiciel “Nice-circulation”. La voiture B (Consommateur) demande s'il y a de l'information sur le bus logiciel et obtient le message mAttente. La voiture B (Consommateur) pose la même question et obtient le même message. La voiture B (Producteur) émet un message mAccident : “Accident sortie Saint-Augustin”. Les messages postés il y a plus de 30s sont détruits par “oogle-Agency”.

En savoir plus :

Comprendre le contexte de l'application : 5mn

  1. Quels sont les grands cas d'utilisation? Vous pouvez les faire simplement sur Papier.

De l'analyse à la conception du bus logiciel

Analyse : 15mn

  1. Sous Visual Paradigme, commencer par créer un “modèle” : bus-analyse. Pour cela, vous pouvez par exemple, ouvrir le volet “Explorateur de modèles” (Apercu→Volet) qui est très utile. Cette approche nous permettra de clairement identifier les éléments produits par l'analyse et ceux produits par la conception.

Visualisation partielle de la vue "Explorateur de modèles" à la fin de ce TD

  1. Définissez un modèle à classes de niveau Analyse.
  2. Définissez, par cas d'utilisation, un diagramme de séquence élémentaire mettant en jeu les objets de votre système et compléter votre diagramme de classes au fur et à mesure. Pour cela utilisez, évidemment des lignes de vie qui font référence à des classes et les messages “Call” qui vous permettent d'identifier les méthodes d'appels et mettent automatiquement à jour vos diagrammes de classes
  • Avez-vous vérifié que le scénario initial est bien couvert par votre modélisation? Même pour la destruction des messages postés il y a “longtemps”?
  • Un bus délivre un ou plusieurs messages? Quel est le problème avec l'unique scénario qui est donné?
  • Votre modélisation tient-elle compte de l'absence de messages en attente?

Conception : 15mn

  1. Dérivation du diagramme : Pour bien différencier votre modèle d'analyse du modèle de conception, dériver votre diagramme. Pour cela vous vous placez dans le diagramme de classes, par un clique droit, vous sélectionnez “utilities” tout en bas → Transitez vers un nouveau diagramme puis créez un modèle Bus-Conception pour bien distinguer vos éléments. Attention à présent de bien travailler dans le modèle en conception
  2. Compléter votre modèle à classes pour préparer l'implémentation :
    • Réfléchir au sens des relations
    • Vérifier les “couplages”
    • Cet exemple est très petit, en conséquence, il est possible qu'il n'y ait quasi rien à faire à cette étape.
Attention, ce tout petit exemple sera très largement étendu par la suite. Prenez-donc un soin particulier pour bien construire un modèle qui respecte les propriétés DRY et de faibles couplages…

Mise en oeuvre

Un projet java (5mn)

On travaille avec Eclipse Luna qui se trouve sur le disque local.
  1. Créer un projet java “busV1
  2. Placez vous dans la perspective “Java” (Window → Open Perspective)
  3. Créer la classe “MonScenario
    • En sélectionnant le projet, clique droit, new class
    • Bien sélectionner le main et les commentaires sur la classe MonScenario

Un projet sous le gestionnaire de version (10mn)

Pour cette séance, vous travaillez dans le répertoire personnel de l'un de vous, c-à-dire
  • Vous allez sur la forge,
  • Vous vous connectez
  • Vous allez dans configuration et là vous voyez le nom du dépôt
  • C'est ce nom que vous donnez

Pour la suite, nous verrons pour travailler dans un répertoire accessible à plusieurs étudiants et aux professeurs.

A partir de maintenant vous devez prendre l'habitude de travailler avec un gestionnaire de version, nous allons en particulier le faire depuis Eclipse.

  1. Pour “partager” votre travail dans SVN, sélectionner le projet (clique droit) et choisir Team > Share Project1); sélectionnez SVN puis Next. Créer une nouvelle localisation puis saisir l'adresse du dépôt SVN par exemple https://svn-iutinfo.unice.fr/svn/users-XXX où il faut remplacer users-XXX par l'identifiant du dépôt
  2. Dans la nouvelle perspective, sélectionner “MonScenario.java”, clique droit puis commiter
  3. Vérifier que votre fichier est bien, à présent, accessible depuis la forge, pour cela connectez vous sur la forge si ce n'est pas encore fait.
  4. Evidemment, l'autre étudiant du binôme peut se connecter au même répertoire et faire un “checkout” de cet espace.

Génération des codes (10 mn)

Nous allons à présent travailler sur les codes. Pour cela nous allons les générer à partir des modèles. Pour cette tâche, vous retournez sous Visual Paradigm. Aujourd'hui nous faisons le choix de générer les codes puis de travailler ces derniers dans chercher, au moins pour l'instant, à maintenir les modèles en cohérence.

  1. Générer les codes
    1. Sélectionner votre diagramme de classe en conception;
    2. Vérifier que vous avez bien toutes les classes prévues;
    3. Préciser si vous voulez travailler avec des vecteurs ou autres (Réfléchissez!!), et préciser bien comme répertoire pour la génération votre répertoire src sous Eclipse
  2. Retourner sous Eclipse, sous la perspective Java, et faîtes un refresh (clique droit sur le projet). Si votre répertoire est mal organisé (nouveau package par exemple, déplacer simplement les codes comme vous le voulez, par glisser/coller.)
  3. Corriger vos codes pour qu'ils soient “compilables” en utilisant simplement les petites boules jaunes sur le côté, mais ne passez pas à l'implémentation, nous ferons cela un peu plus tard.
  4. Quand il n'y a plus d'erreurs, mémoriser les codes dans SVN (pour s'entraîner ;-) ) . Donc cette fois-ci simplement, clique droit sur le package (car évidemment, vous travaillez bien dans un package), puis Team puis commit. Il vous propose directement les fichiers à ajouter au commit. N'oublier de mettre un message.

Mise en place du programme principal préliminaire (10mn)

Voici ce que doit faire a minima votre programme principal, pour cela retourner sur “MonScenario.java” et modifier le main pour :

  1. créer un bus de nom “Nice-Circulation”,
  2. créer un message annonçant “une attente de 5mn”
  3. publier le message sur le bus,
  4. créer un message annonçant “un accident”
  5. publier le message sur le bus,
  6. lire les messages,
  7. afficher le contenu des message.

Ce programme ne peut pas tourner puisque quasi rien n'est implémenté, par contre vous pouvez vous aider d'Eclipse pour que au moins il soit “syntaxiquement” juste et créer les bonnes méthodes si elles n'existent pas déjà, ou les appeler!

Vous pouvez à présent l'exécuter et il vous signale les méthodes non encore implémentées. A la fin de ce TD, évidemment, il fonctionnera.

Un projet sous "tests" (15mn)

Notre objectif est à présent de préparer les tests qui accompagneront notre développement. Pour cela, nous utiliserons l'environnement JUNIT. Bien sûr vous pouvez utiliser un autre environnement de tests si vous le désirez mais la structuration du projet en une partie principale et une partie test est, elle, exigée pour toute la suite de ce module.

  1. Ajoutez un nouveau dossier de sources nommé tests au même niveau d’arborescence que src
    • sur le projet, faire un new source-folder, et l'appeler tests
  2. Dans le menu contextuel de, par exemple la classe Message, cliquez sur New – JUnit Test Case2). Dans le panneau qui s'affiche
    • Sélectionnez le bouton radio New JUnit 4 test.
    • Changez le dossier Source folder pour tests.
    • Nommez la classe MessageTest.
    • Cochez les cases setUp() et tearDown().
    • Enfin cliquez sur Finish.
    • Eclipse va remarquer que la bibliothèque de JUnit est absente du projet et vous propose d’ajouter automatiquement cette dernière au projet.
    • Dans le panneau qui apparaît, cliquez sur OK.
  3. Eclipse a maintenant créé automatiquement le squelette de la classe de test. Il ne reste plus alors qu’à remplir cette dernière.
  4. Dans le menu contextuel, cliquez sur Run As – JUnit test.

Enfin, le premier rapport de tests s’affiche !

Développement (20mn)

  1. Terminez la mise en oeuvre du bus en complétant les tests au fur et à mesure et en n'oubliant pas de commiter.

Pour aller plus loin

Un “bus à messages” s'appuie sur plusieurs design patterns 'Observeur/Observable“ et plus précisément “Publish/Subscribe”. Il existe aujourd'hui de nombreuses implémentations de ces systèmes permettant des communications asynchrones, où les consommateurs sont automatiquement notifiés de l'arrivée de message, où les consommateurs peuvent faire des demandes spécifiques, avec des systèmes de filtres complexes, etc.

EVALUATION de CE TD

  1. Tous les étudiants ont donné accès à leur professeur sur un de leur espace.
  2. Tous les étudiants ont bien sauvegardé dans leur espace SVN.
  3. Tous les étudiants ont au moins une fois fait un commit dans cet espace de travail.
  4. Le programme est fonctionnel et le scénario de base est bien réalisé.

Je sais

Je sais :

  • Créer un projet sous Eclipse, et le structurer correctement.
  • Générer le code à partir d'un modèle de classes en UML.
  • Connecter mon code à un répertoire SVN.
  • Structurer mon projet pour intégrer les tests unitaires.
  • Utiliser Eclipse pour améliorer mon développement en utilisant les outils d'aide au développement.
2)
Cette partie du TD reprend en partie le tutoriel JUNIT : http://www.junit.fr/2011/11/20/tutoriel-eclipse-junit-mon-premier-test-automatique/