Méta-modèle du Diagramme de Séquences

Diagramme de classes du diagramme de Séquences

Si vous maitrisez le diagramme de classes, vous allez mieux comprendre comment est construit un diagramme de Séquences avec les éléments qui le composent et les relations entre eux. Ce type de diagramme permet de représenter l’ordre chronologique des échanges de messages entre les acteurs et les objets d’un système pour accomplir un scénario donné (souvent dérivé d’un cas d’utilisation).

Explications

Rôles de chaque élément

• Lifeline (ligne de vie) : Représente un objet ou acteur participant à l’interaction, client, Serveur, BD,…
• Message : Interaction envoyée d’une lifeline à une autre (appel de méthode, signal), Client –> Serveur : seConnecter()
• ExecutionSpecification : Rectangle sur la ligne de vie indiquant une période d’exécution (Temps d’exécution d’une méthode)
• Return Message : Message de retour vers l’expéditeur (Serveur –> Client : Accès autorisé)
• CombinedFragment : Structure englobante pour représenter des conditions ou boucles (alt, loop, opt, par, etc.). Ainsi, alt pour if/else, loop pour itérations
• InteractionUse : Inclusion d’une autre interaction (appel d’un sous-scénario). Une ref vers une autre séquence.
• Actor : Entité externe initiant l’interaction (Utilisateur, Système externe).

Exemple simple (instanciation du méta-modèle)

Scénario : Authentification d’un utilisateur sur une application web

Interaction : Connexion

• Participants :
  • Utilisateur (acteur)
  • Interface (front-end)
  • Serveur (back-end)
  • BaseDeDonnées (données utilisateurs)
• Messages :
  • Utilisateur –> Interface : saisirIdentifiants()
  • Interface –> Serveur : vérifierLogin(mdp)
  • Serveur –> BD : requêteSQL()
  • BD –> Serveur : résultat()
  • Serveur –> Interface : afficherRésultat()
  • Interface –> Utilisateur : message(“Connexion réussie”)

Concepts à retenir

• Lifeline : Participant (objet, acteur) : Serveur, Client
• Message : Communication (appel ou signal) : Client –> Serveur : commander()
• Return Message : Retour de méthode : Serveur –> Client : confirmation()
• ExecutionSpecification : Durée d’exécution : Rectangle vertical sur lifeline
• CombinedFragment : alt, loop,… : Condition, boucle, option : alt Produit dispo / non dispo
• InteractionUse : Appel d’un autre scénario : ref AuthentifierUtilisateur

Exercice

À partir des informations ci-dessous :

Scénario : Achat en ligne

1. Le client choisit un produit et clique sur “Commander”.
2. L’application front-end envoie la commande au serveur.
3. Le serveur vérifie le stock auprès de la base de données.
4. Si le produit est disponible, le serveur confirme la commande et déclenche le paiement.
5. Le client reçoit une confirmation.

Questions :

1. Identifiez les participants (lifelines)
2. Listez les messages échangés
3. Ajoutez un fragment combiné alt pour gérer le cas “stock insuffisant”
4. Dessinez le diagramme UML correspondant (papier, plantuml ou autre)
5. Vérifiez la cohérence avec le méta-modèle (structure, chronologie, fragments).

Conclusion

Le diagramme de séquence est la chronologie d’un scénario. Il montre qui parle à qui, quand et comment. Il aide à passer du besoin fonctionnel au code (liens directs vers les méthodes d’objets). Les fragments combinés rendent visibles les décisions, boucles et parallélismes.

Bonus : Code PlantUML du diagramme de classes

@startuml
' ============================================================
'  Méta-modèle UML — Diagramme de Séquence (version française)
' ============================================================

hide empty methods
hide empty fields
skinparam classAttributeIconSize 0
skinparam wrapWidth 240
skinparam maxMessageSize 120
title Méta-modèle UML — Diagramme de séquence (FR)

' ======================
' Éléments principaux
' ======================

class Interaction {
  + nom : Chaîne
}

class Participant {
  + nom : Chaîne
  + rôle : Chaîne
}

class LigneDeVie {
  + identifiant : Chaîne
}

class Message {
  + nom : Chaîne
  + type : TypeMessage
}

enum TypeMessage {
  appel
  retour
  asynchrone
  création
  destruction
}

class SpécificationExécution {
  + durée : Temps [0..1]
}

class FragmentCombiné {
  + opérateur : TypeFragment
  + condition : ExpressionBooléenne [0..1]
}

enum TypeFragment {
  alt
  opt
  loop
  par
  break
  ref
}

class InteractionRéférencée {
  + nomRéférence : Chaîne
}

' ======================
' Relations
' ======================

Interaction "1" *-- "1..*" Participant : contient >
Participant "1" *-- "1" LigneDeVie : possède >
LigneDeVie "0..*" o-- "0..*" Message : envoie/reçoit >
Message "0..1" --> "0..1" SpécificationExécution : déclenche >
Interaction "0..*" o-- "0..*" FragmentCombiné : structure >
FragmentCombiné "0..*" --> "0..*" Message : messagesInclus >

' ======================
' Notes pédagogiques
' ======================

note top of Interaction
  Représente un scénario d’échanges entre objets.
  Composé de participants et de messages ordonnés dans le temps.
end note

note right of FragmentCombiné
  Structure de contrôle :
  - alt : alternatives (if/else)
  - opt : optionnel
  - loop : répétition
  - par : parallèle
end note

note bottom of Message
  Représente un appel, un retour ou un signal entre participants.
end note
@enduml

Correction Exercice

Remarques

• Participants = Lifelines : Client, Application, Serveur, Stock, Paiement
• Messages directs = appels séquentiels avec retours explicites
• Fragment combiné alt = deux scénarios possibles (succès / échec)
• Chronologie descendante = respectée de haut en bas
• Il n’y a pas de boucles ni parallélismes, mais on a la possibilité de faire une boucle (loop) pour répéter une commande !

Version PlantUML

@startuml
title Corrigé — Achat en ligne

actor Client
participant Application
participant Serveur
database Stock
participant Paiement

Client -> Application : commanderProduit()
Application -> Serveur : transmettreCommande()
Serveur -> Stock : vérifierStock()
Stock --> Serveur : disponibilité()

alt Produit disponible
  Serveur -> Paiement : déclencherPaiement()
  Paiement --> Serveur : paiementOK()
  Serveur -> Application : confirmerCommande()
  Application --> Client : afficherConfirmation()
else Stock insuffisant
  Serveur -> Application : afficherMessage("Produit indisponible")
  Application --> Client : message("Stock épuisé")
end
@enduml