Guide d’utilisation pour Rational Rose 2000

UML: Unified Modeling Language est un langage servant à décrire des modèles d’un système (réel ou logiciel) avec des notations. UML se base sur les concepts orienté-objets afin de :

• Spécifier le problème et la solution
• Visualiser le problème et la solution sous différents angles
• Construire la solution
• Documenter

Les modèles du système sont visualisés par des vues.

Les diagrammes UML fournissent les informations sur un problème et sa solution. Ils forment des modèles du système (spécifier, visualiser). Les combinaisons de diagrammes représentent les vues du système. En UML, on utilise deux types de diagramme :

• Les aspects dynamiques: modélisent les comportements, les collaborations et les responsabilités des objets. Ex.: les diagrammes de collaboration et de séquence.
• Les aspects statiques et structurels: modélisent les relations entre les objets. Un exemple direct considère le diagramme de classes.

Rational Rose fournit 8 différents diagrammes pour la réalisation d’un projet logiciel :

• Diagramme de classes
• Diagramme de cas d’utilisation
• Diagramme de collaboration
• Diagramme de séquence
• Diagramme des composants
• Diagramme d’état
• Diagramme d’activité
• Diagramme de déploiement

Le diagramme de classe permet de décrire d’une manière générique le comportement du système. Il présente les différentes classes du système . Les éléments associés pour la modélisation d’un diagramme de classe sont :

• Les spécifications générales de la classe (type, parent)
• Les spécifications détaillées de la classe (cardinalité, concurrence, persistance)
• Les attributs de la classe
• Les opérations (pré-condition, post-condition, sémantique)
• Les associations
• Les dépendances
• Les spécifications sur les attributs de la classe

Le diagramme de séquence permet de représenter les interactions entre les différents objets du système dans le temps (dynamique du système). Les éléments associés pour la modélisation d’un diagramme de séquence sont :

• Les objets
• Les messages entre les objets

Le diagramme de composants présente les relations de dépendance entre les composantes physiques du système (programme principal, les sous-programmes, le gestionnaire des fichiers). Les éléments associés pour la modélisation d’un diagramme des composants sont :

• Les composants
• Le programme main
• Les sous-programmes
• Les spécifications des tâches

Le diagramme d’état permet de montrer le modèle dynamique du comportement d’une classe individuelle ou d’un objet particulier. Il montre la séquence des états qu’un objet doit suivre pour passer à un autre état. Les éléments associés pour la modélisation d’un diagramme d’état sont :

• Les états
• Les transitions
• Le début des états
• La fin des états

Le diagramme d’activité représente la dynamique du système. Il montre l’enchaînement des activités d’un système ou même d’une opération. Le diagramme d’activité représente le flot de contrôle qui retrace le fil d’exécution et qui transite d’une activité à l’autre dans le système. Les éléments associés pour la modélisation d’un diagramme d’activité sont :

• Les décisions
• Les synchronisations
• Les activités
• Les états
• Les transitions
• Le début des états
• La fin des états

Le diagramme de déploiement présente les processeurs, les cartes de contrôle et les connections entre les différents processeurs. Les éléments associés pour la modélisation d’un diagramme de déploiement sont :

• Les processeurs
• Les cartes de contrôle
• Les connections

La famille des produits Rational Rose est conçue pour fournir un ensemble complet d’outils de modélisation graphique, d’analyse et de conception dans le développement de logiciels basés sur les modèles UML (Unified Modeling Language), COM (Component Object Modeling), OMT (Object Modeling Technique) et Booch ("93method for visual modeling"). Les produits Rational Rose partagent un standard universel, ce qui a pour effet de rendre accessible la modélisation même pour des non-programmeurs.

Rational Rose utilise la modélisation graphique pour raisonner sur des problèmes complexes en s’appuyant sur des modèles organisés. Un modèle facilite la compréhension du problème et permet de décrire les caractéristiques essentielles d’un système.

1. Exécutez l’application Rational Rose Entreprise Edition
2. Cliquez sur le bouton « Cancel » puisqu’on ne va pas utiliser des patrons
3. Sauvegardez le modèle que vous allez créer
4. Par défaut, Rational Rose fait la sauvegarde sous l’extension « .mdl ».

1. Allez sur le menu: -> Browse -> Use Case Diagram
2. Sélectionnez «Use Case View» et «Use Case Diagram Use CaseView/Main»
3. Cliquez sur le bouton « Rename » et renommez le diagramme de cas d’utilisation (Ex: Main)

1. Placez le curseur sur « Use Case View »
2. Cliquez avec le bouton droit de souris et choisissez « New » ; sélectionnez « Actor »
3. Renommez l’acteur «Client»

1. Placez le curseur sur «Use Case View»
2. Cliquez avec le bouton droit de la souris ; choisissez «New» et sélectionnez «Use Case»
3. Renommez le cas d’utilisation « EmprunterLivre»
4. Sélectionnez l’acteur «Client» et faites-le glisser à l’aide de la souris sur le diagramme de cas d’utilisation.
5. Sélectionnez le cas d’utilisation « EmprunterLivre » et faites-le glisser sur le diagramme de cas d’utilisation
6. Sélectionnez l’association «Unidirectional Association » de la barre des objets UML et faites glisser le curseur avec la souris du «Client» vers «EmprunterLivre».

1. Sélectionnez l’objet avec le bouton gauche de la souris
2. Placez le curseur dans la fenêtre de documentation
3. Saisissez l’information sur l’objet

1. Sélectionnez l’objet avec le bouton gauche de la souris
2. Cliquez une fois sur l’objet à l’aide du bouton droit
3. Sélectionnez «Edit», puis «Delete»

1. À partir du menu principal, sélectionnez «Browse» et cliquez sur «Class Diagram» ou bien allez sur «Logical View » à Newà Class Diagram»
2. Renommez le diagramme de classe en suivant les mêmes étapes pour les cas d’utilisation

1. Sélectionnez «Logical View», puis cliquez sur «New Class»
2. Renommez la classe
3. Sélectionnez la classe créée et faites-la glisser sur le diagramme de classe

1. Sélectionnez l’objet «Classe» à l’aide du bouton gauche de la souris
2. Sélectionnez la fenêtre de documentation
3. Entrez les informations pertinentes

1. Placez le curseur de la souris sur l’objet
2. Cliquez sur le bouton droit et sélectionnez la fonction «New Attribute».
3. Indiquez le nom de variable pour l’attribut
   Note:Par défaut Rational Rose crée les attributs de type privé et des méthodes de type publique.

1. Sélectionnez l’objet à l’aide de la souris
2. Positionnez le curseur sur le nom donné à l’attribut
3. Cliquez avec le bouton droit de la souris et sélectionnez «Open Specification»
4. Sélectionnez le type de l’attribut et cliquez sur «OK»
5. Pour insérer des méthodes à la classe, répétez les étapes 4 et 5 en modifiant chaque fois «Attribute» par «Operation»

1. À partir de la barre des objets UML, sélectionnez l’association (flèche) «Unidirectionnal association».
2. Dans le diagramme de classe, positionnez-vous sur la ligne de la première classe et faites-la glisser jusqu’à la classe destinée
3. Cliquez deux fois sur la ligne ainsi créée pour ajouter les multiplicités:
   • Sélectionnez «Role A Detail» et ajoutez les multiplicités (A désigne la première classe) pour indiquer le nombre d’instances d’une classe reliées à une autre et vice versa.
   • Sélectionnez «Role B Detail» et identifiez les multiplicités (B désigne la classe destination).

Les diagrammes de séquence que vous créez sont basés sur des scénarios. Pour commencer, choisissez un scénario simple et procédez comme suit :

1. Cliquez sur «Logical View» avec le bouton droit de la souris et sélectionnez «New», puis «Sequence diagram».
2. Renommez le diagramme de séquence en suivant les mêmes étapes qu’avec le cas d’utilisation.

À partir du menu pour diagrammes UML,

• Sélectionnez les objets en fonction du diagramme créé et faites-les glisser un à un sur la fenêtre du diagramme de séquence

1. En utilisant l’icône de l’objet message à dessiner un message partant de l’objet 1 vers l’objet 2
2. Cliquez deux fois sur le message créé pour modifier ses paramètres si nécessaire

Dans cette partie, nous allons créer un diagramme de collaboration basé sur un scénario.

1. Cliquez sur «Logical View» avec le bouton droit de la souris et sélectionnez «New», puis «Collaboration Diagram».
2. Renommez le diagramme de collaboration en suivant les mêmes étapes qu’avec le cas d’utilisation

À partir du menu pour diagrammes UML,

• Sélectionnez les objets en fonction du diagramme créé et faites-les glisser un à un sur la fenêtre du diagramme de séquence

1. En utilisant l’icône de l’objet message «Object Link»( ___ ) dessinez une ligne qui part de l’objet 1 vers l’objet 2
2. Créez le message échangé entre les objets en utilisant l’icône de l’objet message «Message Link»( -> ), puis cliquez deux fois sur la ligne qui relie l’objet 1 et l’objet 2. Vous venez de créer le premier message échangé entre les deux objets

Note:Un diagramme de collaboration peut être généré directement à partir d’un diagramme de séquence et vice versa en appuyant simplement sur la touche F5 à partir du diagramme de séquence ou de collaboration.

1. Sur «Logical View» cliquez avec le bouton droit de la souris et sélectionnez «New à Activity Diagram»
2. Renommez le diagramme d’activité que vous venez de créer
3. Cliquez deux fois sur le diagramme d’activité afin de l’ouvrir : vous êtes maintenant prêt à ajouter les activités reliées à ce diagramme

1. Sur la barre d’outils, sélectionnez l’icône correspondant à «Activity»
2. Placez l’activité sur le digramme d’activité et entrez son nom

Les transitions sont déclenchées par la fin du comportement d’une activité. Elles sont utilisées pour montrer le passage du flot de contrôle d’une activité qui vient de finir vers une activité qui commence.

1. Sélectionnez l’icône correspondant à une transition dans la barre d’outils («State Transition»).
2. Cliquez sur l’activité d’origine et étirez la flèche de la transition vers l’activité suivante

Pour indiquer le début ou la fin d’une activité:

1. Sélectionnez l’icône d’état initial ou final sur la barre d’outils
2. Placez-la sur le diagramme d’activité
3. Sélectionnez l’icône de transition et reliez l’état initial (final) à l’activité du début (fin)

1. Sélectionnez l’icône de décision sur la barre d’outils
2. Placez-la sur le diagramme d’activité et donnez-lui un nouveau nom
3. Sélectionner l’icône de transition et étirez-le étirer afin de relier l’activité et la décision
4. Cliquez deux fois sur la décision : une fenêtre s’affiche. Dans «General à Name» saisissez le nom de cette condition

1. Sélectionnez l’icône correspondant à une transition dans la barre d’outils
2. Cliquez sur le point de branchement et étirez la flèche de la transition vers l’activité en aval
3. Cliquez deux fois sur la flèche de transition et allez sur «Detail -> Guard Condition» et saisissez la condition (oui ou non)

1. Sur «Logical View», sélectionnez la classe que vous voulez pour créer le diagramme d’état et avec le bouton droit de la souris cliquez sur «New -> StateChart Diagram».
2. Renommez le diagramme d’état que vous venez de créer
3. Cliquez deux fois sur le diagramme d’état afin de l’ouvrir

1. Sur la barre d’outils, sélectionnez l’icône «State»
2. Cliquez sur le diagramme d’état pour y placer l’état et entrez son nom
3. Créez les transitions entre les états en suivant les mêmes étapes que pour les diagrammes d’activités
4. Créez les états finaux et initiaux
5. Cliquez deux fois sur la flèche de transition et saisissez l’événement relié à cette transition

1. Sélectionnez l’état en question
2. Avec le bouton droit de la souris, sélectionnez «Open Specification»
3. Sélectionnez «Actions»
4. Dans le champ «Actions », cliquez avec le bouton droit de la souris et sélectionnez «Insert». Cette action aura comme effet la création d’une entrée
5. Cliquez deux fois sur «Entry»
6. Choisissez le moment où l’action doit se produire : «When» : «On Entry» (en entrée), «On Exit» (en sortie) ou «On Event» (à la réception d’un événement)
7. Dans «Type», choississez «Action » ou «Sent Event»
8. Saisissez les informations relatives à l’événement

• La génération du code se limite à produire seulement le squelette de votre programme. L’implantation des corps des fonctions est laissée à votre soin
• La génération du code peut se faire à partir d’une classe, d’un diagramme de classe ou d’un paquetage

1. Vérifiez votre modèle «.mdl : Tools -> Check Model ». S’il y a des erreurs, c’est le moment de les corriger. Cette opération est importante pour avoir un squelette complet pour votre programme.
2. Créez deux variables d’environnement : une pour votre répertoire de travail et l’autre pour le répertoire c:\j2sdk1.4.0_version\src.zip
   • «File -> Edit Path Map». À titre d’exemple, initialisez les variables d’environnement : JAVA_PROJET pour votre répertoire de travail et J2SDK_SRC pour c:\j2sdk1.4.0_version\src.zip

1. Configurez le projet avec «Tools -> Java -> Project Specification» en ajoutant le chemin d’accès de votre répertoire de travail ainsi que du répertoire où se trouve src.zip. Vérifiez s’ils font respectivement référence à JAVA_PROJET et J2SDK_SRC en sélectionnant « Resolve Pathmap Variables »
2. Pour générer du code Java, sélectionnez l’ensemble des classes de votre diagramme de classes et allez à : «Tools -> Java/J2EE -> Generate Code»
3. Révisez le code source généré (constructeurs, attributs, opérations...) et complétez-le s’il y a lieu

La rétro-ingénierie est l’opération qui nous permet d’avoir une modélisation automatique des classes et des variables d’un programme écrit en Java avec UML (inverse à la génération du code). Par exemple, à partir d’un programme écrit en langage Java, vous pourrez générer automatiquement les classes de ce programme modélisées en UML

1. Mettez les fichiers.java dans un sous-répertoire de votre répertoire de travail
2. Allez à «Tools -> Java/J2EE -> reverse engineering»
3. Sélectionnez le nom du fichier pour lequel vous voulez faire la rétro-ingénierie
4. Cliquez sur «Add», puis sur «Select All» et finalement sur «Reverse»
5. Après avoir effectué la rétro-ingénierie des fichiers Java, visualiser le contenu des classes générées avec Rational Rose et compléter les dépendances avec les autres classes s’il y a lieu.

(Dernière modification: