Cours au département INFO - IUT - UNS

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== TD1 : Prise en main de l'environnement de développement ======

<callout type="info" icon="true"> 
**Objectifs :** Par le développement d'un mini-bus à messages tels que Twitter ou un mur facebook, nous mettons en place notre environnement de travail et rappelons les notions de base de la COO.
</callout>

<callout type="tip" icon="true"> 
Commencer par lancer IntelliJ ou Eclipse et Modelio qui sont long à charger !!
</callout>

<note warning>Ce module exige que vous utilisiez un environnement de développement, pas un éditeur de texte ! 
JCreator, Notexxx ne sont pas de tels environnements de développement.
Vous devez utiliser **IntelliJ** ou **Eclipse**.

Le téléchargement de ces outils peut être long, il doit avoir été fait avant le TD.

   * [[http://www.eclipse.org/downloads/packages/eclipse-ide-java-ee-developers/keplersr2|Eclipse]]
   * [[https://www.jetbrains.com/idea/|IntelliJ]]

Et pour GIT, vous devez déjà l'avoir sur vos ordinateurs.
Vous pouvez aussi installer un client GIT pour vous faciliter son utilisation (en principe..)
    * [[https://www.sourcetreeapp.com/|SourceTree]]
Mais vos environnements intègrent également une connexion à GIT...
</note>




<note warning>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. </note>





===== Présentation de l'application =====

<note>Un **bus à messages** (//e.g.// Twitter) permet à un "producteur" (//e.g.// un membre)   d'envoyer un "message" (texte, contenu multimedia, ...) vers des consommateurs (//e.g.// un autre membre). 
Les consommateurs peuvent lire les messages quand ils le veulent. 

</note> 

/* Selon les modèles de bus, les consommateurs sont notifiés immédiatement du message (//twitter par exemple//), ou bien doivent aller eux-même chercher leurs messages (//email par exemple//).
*/

Il s'agit de construire les **bases "rudimentaires" d'un "bus à messages"**, //pensez flux d'informations par exemple (flux RSS).//
  * Un membre peut créer un bus.
  * Des producteurs émettent des messages vers un bus. 
  * Des consommateurs demandent à lire des messages sur le bus. 
  * Un membre peut effacer des messages sur le bus. 
  * Un consommateur peut demander à lire des messages et qu'il n'y en ait aucun. 


<accordion  collapsed="true">
<panel  title="Pour en savoir plus">
{{ :2016_2017:s3:concprogobjet:td:value_of_mb_on_zos_esb.jpg?nolink&300 |((extraite de http://www.ibm.com/developerworks/websphere/library/techarticles/0604_odowd/0604_odowd.html))}}

Il existe beaucoup de modèles de "bus" : choix des consommateurs par filtrage sur le message, abonnement des consommateurs à des boîtes spécialisées, envoi des messages à la demande des consommateurs, dés qu'un message est lu, il n'est plus accessible aux autres consommateurs, ... Ces modèles d'architectures sont très utilisés pour faciliter des communications asynchrones et l'envoi d'informations à un groupe de destinataires (pensez au principe des tags sous Twitter par exemple).

[[http://docs.oracle.com/cd/E19798-01/821-1841/bnced/index.html| en savoir plus]]

</panel>
</accordion>
==== 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" (//Membre//) crée un bus logiciel "Nice-circulation".\\
La voiture A (//Producteur//) émet un message //mAttente : "Attente de 5mn"// sur le 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". 

<html>
<!-- http://www.journaldev.com/1739/observer-design-pattern-in-java-example-tutorial

http://www.rabbitmq.com/tutorials/tutorial-one-java.html
--!>
</html>



===== Comprendre le contexte de l'application : 5mn =====

  - <todo> Quels sont les grands cas d'utilisation? Vous pouvez les faire simplement sur Papier.</todo>

===== De l'analyse à la conception du bus logiciel =====


==== Analyse : 15mn  ====

  - <todo> Commencez par créer un projet (Attention à bien sélectionner **Java Project**)</todo> sous [[:modelio|MODELIO]]
  - <todo> Définissez un diagramme de classes de niveau Analyse.</todo> 
  - <todo> 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 qui vous permettent d'identifier les méthodes et mettre à jour vos diagrammes de classes.</todo> 


<note tip>
  * 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?
</note>
==== Conception : 15mn  ====


  - <todo> Compléter votre modèle à classes pour préparer l'implémentation : </todo>
        * 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.


<note tip>
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...</note>
===== Mise en oeuvre =====

==== Un projet java (5mn)  ====


   - Créez un projet **MAVEN** ( **voir comment faire ici [[https://mbf-iut.i3s.unice.fr/doku.php?id=eclipse#creer_un_projet_maven|avec eclipse]] [[https://mbf-iut.i3s.unice.fr/doku.php?id=intellij#creer_un_projet_maven|avec intelliJ]]** ) 
         - Nom du projet : busV1
         - GroupID = fr.unice.iut.info.coo
         - ArtefactID = bus
   - La structure contient 
          - src -> main -> Java ...
          - test -> java -> ...
          - Exécutez le main et les tests... 
   - Ok maintenant vous êtes prêts.




<html>
<!-- 

==== Un projet sous le gestionnaire de version (10mn) ====

<note important>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.</note>

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

  - Pour "partager" votre travail dans SVN, sélectionner le projet (clique droit) et choisir //Team > Share Project//((Basé sur http://www.ibm.com/developerworks/opensource/library/os-ecl-subversion/)); 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 {{ :2014_2015:s3:concprogobjet:td:shareproject.png?direct&200 |}} 
  - Dans la nouvelle perspective, sélectionner "MonScenario.java", clique droit puis commiter {{ :2014_2015:s3:concprogobjet:td:commitinitial.png?direct&200 |}}
  - 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.
  - Evidemment, l'autre étudiant du binôme peut se connecter au même répertoire et faire un "checkout" de cet espace.



--!>
</html>


==== 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 Modelio. 
Aujourd'hui nous faisons le choix de générer les codes puis de travailler ces derniers sans chercher, au moins pour l'instant, à maintenir les modèles en cohérence.

  - Générez les codes (voir [[https://mbf-iut.i3s.unice.fr/doku.php?id=modelio#generer_les_codes|ici]] et choisissez comme répertoire de génération celui sous src/main/java/fr/unice/iut/info/coo
  -       - Sélectionner votre diagramme de classe en conception;
      - Vérifier que vous avez bien toutes les classes prévues; 
      - 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** (si besoin, spécifiez le nom du package fr.unice.iut.info.coo directement dans le code généré) {{ :2014_2015:s3:concprogobjet:td:generationcodejava.png?direct&200 |}}
  - Retourner sous votre IDE. Si votre répertoire est mal organisé (nouveau package par exemple, déplacer simplement les codes comme vous le voulez, par glisser/coller.)
  - Corriger vos codes pour qu'ils soient "compilables" : 
          -  Afin que les annotations de Modelio soient comprises, ajouter {{:javadesigner.jar|}} comme une library du projet 
                 * sous [[https://mbf-iut.i3s.unice.fr/doku.php?id=eclipse#ajouter_un_jar_externe|Eclipse]] 
                 * sous IntelliJ
                      - déposer sous idea/libraries... puis sélectionner le .jar et l'enregistrer comme une librairie utilisée par le projet
                      - **ou bien** placez vous sur le projet puis avec le menu contextuel (clique droit) > Open module Setting > Librairies et ajouter le .jar
<html>
<!--
  - 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.
--!>
</html>



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

Voici ce que doit faire a minima votre programme principal, pour cela retourner dans le fichier de test et ajouter un cas de test : "testMonScenario.java"  ou des tests pour : 
  - créer un bus de nom "Nice-Circulation",
  - créer un message annonçant "une attente de 5mn"
  - créer un message annonçant "un accident"
  - récupérer les messages sur le bus de nom "Nice-Circulation",
  - afficher le contenu des messages.


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

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. 
La structuration du projet en une partie principale et une partie test est, elle, exigée pour toute la suite de ce module.
Vous avez déjà utilisé JUnit l'an dernier, il devrait s'agir uniquement de rappels. 

<accordion  collapsed="true">
/* ----------------
*/
<panel title="Eclipse"  >
    - Dans le menu contextuel de, par exemple la classe //Message//, cliquez sur //New – Others - Java - JUnit Test Case//((Cette partie du TD reprend en partie le tutoriel JUNIT : http://www.junit.fr/2011/11/20/tutoriel-eclipse-junit-mon-premier-test-automatique/)). {{ :2014_2015:s3:concprogobjet:td:junittestcase.png?direct&200 |}} Dans le panneau qui s'affiche {{ :2014_2015:s3:concprogobjet:td:messagetest.png?direct&200 |}}
          * Sélectionnez le bouton radio //New JUnit 4 test//.
          * Changez le dossier Source folder pour //bus/src/test/java//.
          * 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.
    -  Eclipse a maintenant créé automatiquement le squelette de la classe de test. Il ne reste plus alors qu’à remplir cette dernière. 
    - Dans le menu contextuel, cliquez sur //Run As – JUnit test//.
Enfin, le premier rapport de tests s’affiche ! 
{{ :2014_2015:s3:concprogobjet:td:testok.png?direct&200 |}}

</panel>


<panel title="IntelliJ"  >
    - Pour créer des tests sur votre classe //Message//, suivez les instructions sous https://www.jetbrains.com/help/idea/2016.2/creating-tests.html. La classe de test créée se trouve sous test/java/...
          * Cochez les cases ''setUp()'' ((est exécutée avant tout test)) et ''tearDown()'' ((est exécutée après tout test)).
    -  IntelliJ a maintenant créé automatiquement le squelette de la classe de test. Il ne reste plus alors qu’à remplir cette dernière.
</panel>
</accordion>

 
   - <todo> Complétez la classe de Test à présent et l'exécuter. </todo> Voir un exemple de code ci-dessous.
   - <todo> Vérifier la couverture de votre code (menu contextuel, coverage as) si vous êtes sous Eclipse. Vous pouvez aussi les voir sous properties. </todo> 

Voici un exemple de code de test.

<code java>
        protected Message mToTest;
	protected String contents;

	@Before
	public void setUp() throws Exception {
		contents = "mon message";
		mToTest = new Message(contents);
	}

	@Test
	public void setContents() throws Exception {
		String nv = "newValue";
		mToTest.setContenu("newValue");
		assertEquals(" message contents is as expected",nv,mToTest.getContents());
		assertFalse(" message contents has been modified", mToTest.getContents().equals(content));
	}

</code>




====  Développement (20mn)  ====
  - Terminez la mise en oeuvre du bus en complétant les tests au fur et à mesure.


Pensez à tester : 
  * Retrouver un bus de nom donné




<accordion  collapsed="true">
<panel  title="Pour en savoir plus">
==== 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. 
</panel>
</accordion>

===== EVALUATION de CE TD ===== 

  - Le programme est fonctionnel et le scénario de base est bien réalisé.
  - Les modèles sont cohérents avec le code.

[[http://jalon.unice.fr/cours/blay/Cours-blay-20160929210709/BoiteDepot-blay-20160929210839376812?mode_etudiant=false|Jalon de dépôt pour Mme Blay-Fornarino : donner comme nom du dépot : Gr<NumeroGroupe><Noms des étudiants>]] Pour les groupes de Mme Blay-Fornarino date limite 26 septembre minuit
===== Je sais =====
 
<box round rgb(255,204,153) rgb(255,255,204) 97%|Je sais  :   >
  * Créer un projet sous un IDE avancé, et le structurer correctement.
  * (Rappel) Faire correspondre le code java et un modèle de classes en UML.
  * Mettre en place des tests unitaires. 
  * Utiliser un IDE pour améliorer mon développement en utilisant les outils d'aide au développement.
</box>

===== Pour les avancés =====


[[https://github.com/iluwatar/java-design-patterns/tree/master/producer-consumer/src/main/java/com/iluwatar/producer/consumer|Des exemples de code Producteur/Consommateur]]