Diagramme de Séquence

Ce laboratoire présente le diagramme de séquence, un outil essentiel pour modéliser les interactions dynamiques entre acteurs et objets dans un système. Il permet de représenter de manière chronologique les échanges de messages dans un scénario donné. Ce TP vous guidera à travers les concepts fondamentaux, les éléments graphiques, les types de messages, ainsi que les fragments d'interactions combinés. Pour réaliser ce TP, il est nécessaire d'avoir des connaissances de base en modélisation UML et en programmation orientée objet.

Objectifs

• Comprendre la structure et la fonction d’un diagramme de séquence.
• Identifier et représenter les acteurs, objets et messages dans un scénario.
• Distinguer les différents types de messages (synchrone, asynchrone, création, destruction, réflexif).
• Utiliser la syntaxe correcte des messages et des messages de retour.
• Appliquer les fragments d’interaction combinés pour modéliser des comportements complexes.

Prérequis et installation

• Connaissances de base en UML, notamment en diagrammes de classes et cas d’utilisation.
• Compréhension des concepts de programmation orientée objet (objets, méthodes, classes).
• Un outil de modélisation UML capable de créer des diagrammes de séquence (exemple : StarUML, Visual Paradigm, ou tout autre logiciel UML).

Introduction au diagramme de séquence

Le diagramme de séquence fait partie de la description logique et dynamique d’un système. Il représente le déroulement chronologique des échanges entre acteurs et objets dans un scénario. Chaque participant est représenté par une ligne de vie verticale, tandis que les messages échangés sont dessinés horizontalement entre ces lignes.

Un diagramme de séquence regroupe tous les objets et acteurs impliqués dans un scénario donné et illustre leurs interactions par des messages, ce qui permet de visualiser un cas d’utilisation de manière détaillée.

Éléments de base du diagramme de séquence

Les éléments fondamentaux sont :

• Acteurs : entités externes au système qui interagissent avec lui.
• Objets (instances) : représentés par un carré contenant l’identifiant de l’objet et le nom de sa classe, suivi d’une ligne verticale symbolisant sa durée de vie.
• Messages : échanges entre acteurs et objets, ou entre objets, qui peuvent être des appels d’opération, des signaux, ou des événements de création/destruction.

La ligne de vie d’un objet ou acteur est une ligne verticale attachée au carré représentant l’objet, orientée vers le bas pour indiquer le temps qui passe.

Représentation des messages

Les messages sont les éléments clés du diagramme. Ils indiquent la communication entre lignes de vie dans un ordre chronologique. Les principaux types sont :

• Message synchrone : l’émetteur est bloqué jusqu’à la réponse du récepteur. Typiquement un appel de méthode. Un message de retour (en pointillés) peut indiquer la fin du traitement.
• Message asynchrone : non bloquant, le récepteur peut traiter le message à son rythme ou l’ignorer. Correspond souvent à un signal.
• Création d’objet : matérialisée par une flèche pointant vers le sommet de la ligne de vie de l’objet créé.
• Destruction d’objet : indiquée par une croix à la fin de la ligne de vie.
• Message réflexif : un objet s’envoie un message à lui-même.

Message synchrone

Lorsqu’un objet A invoque une méthode d’un objet B, A reste bloqué jusqu’à ce que B termine son traitement. Le flot de contrôle passe de A à B. Le message de retour, optionnel, indique la reprise du contrôle par A.

class B {
  C c;
  op1(p: Type) {
    c.op2(p);
    c.op3();
  }
}
class C {
  op2(p: Type) {
    ...
  }
  op3() {
    ...
  }
}

Message asynchrone

Un message asynchrone ne bloque pas l’émetteur. Le récepteur peut le traiter ultérieurement ou ne pas le prendre en compte. Ce type de message correspond aux signaux dans UML.

Syntaxe des messages

La syntaxe générale d’un message est :

nomSignalOuOperation(parametres)

Les paramètres peuvent être passés sous forme :

• nomParametre = valeurParametre
• nomParametre : valeurParametre (pour un argument modifiable)

Exemples :

appeler("Capitaine Hadock", 54214110)
afficher(x, y)
initialiser(x=100)
f(x:12)

Message de retour

Le message de retour est envoyé par le récepteur d’un message synchrone pour rendre la main à l’émetteur. Il est représenté par une flèche en pointillés et peut spécifier une valeur de retour.

Syntaxe :

attributCible = nomOperation(params) : valeurRetour

Les paramètres suivent la même syntaxe que pour les messages d’appel.

Fragments d’interaction combinés

Pour modéliser des interactions complexes, on utilise des fragments combinés, représentés par un rectangle avec un pentagone dans le coin supérieur gauche indiquant le type d’opérateur d’interaction.

Les principaux opérateurs sont :

• alternative (alt) : opérateur conditionnel équivalent à un SWITCH, avec plusieurs branches conditionnelles.
• option (opt) : comportement facultatif qui peut se produire ou non.
• boucle (loop) : répétition d’un fragment un nombre minimum et maximum de fois, avec une condition booléenne.
• parallèle (par) : exécution parallèle de fragments indépendants.
• strict sequencing (strict) : exécution séquentielle stricte de fragments, utile lorsque les fragments n’ont pas de lignes de vie communes.

Exemple de boucle

Syntaxe :

loop(minNbIterations, maxNbIterations)

La boucle s’exécute au moins minNbIterations fois, puis continue tant que la condition booléenne est vraie, au plus maxNbIterations fois.

Notations simplifiées :

• loop(valeur) équivaut à loop(valeur, valeur)
• loop équivaut à loop(0, *) où * signifie illimité

Exemple d’opérateur alt

L’opérateur alternative permet de représenter un choix multiple avec plusieurs conditions de garde. Si aucune condition n’est vraie, la condition else s’applique.

Réutilisation d’une interaction

Une interaction peut être réutilisée en plaçant un fragment portant la référence ref à l’endroit où l’interaction est nécessaire, ce qui évite la duplication.

Résultats attendus

• Un diagramme de séquence clair représentant les acteurs, objets et leurs lignes de vie.
• Messages correctement identifiés et positionnés dans l’ordre chronologique.
• Distinction claire entre messages synchrones et asynchrones, avec leurs retours éventuels.
• Fragments d’interaction combinés utilisés pour modéliser des comportements conditionnels, répétitifs ou parallèles.
• Respect de la syntaxe des messages et des paramètres.

Pièges courants

• Confondre message synchrone et asynchrone : un message synchrone bloque l’émetteur, un asynchrone ne le fait pas.
• Oublier de représenter la ligne de vie verticale pour chaque objet ou acteur.
• Ne pas indiquer clairement la création ou la destruction d’un objet (flèche vers le sommet ou croix à la fin de la ligne de vie).
• Mal utiliser les fragments combinés, notamment en ne respectant pas les conditions de garde ou l’ordre d’exécution.
• Ignorer les messages de retour, qui sont essentiels pour comprendre la reprise du contrôle dans les messages synchrones.