Les Design Patterns comportementaux, en programmation, représentent des solutions éprouvées aux problèmes récurrents liés à la communication entre les objets et les responsabilités de ces objets. Ces design patterns se concentrent sur la manière dont les objets interagissent et communiquent entre eux.
Les designs patterns comportementaux les plus utilisés sont les suivants :
Ici nous nous attaquerons au design pattern Commande.
Le design pattern Commande
Définition
Le design pattern Commande est une approche qui prend une action à réaliser et la convertit en un objet autonome qui encapsule tous les détails de cette action. Cette conversion permet de paramétrer des méthodes avec différentes actions, de planifier leur exécution, de les mettre en file d'attente ou d'annuler des opérations déjà effectuées.
Exemple d'implémentation
Pour la suite de cet article, nous utiliserons comme exemple votre éditeur de document / texte préféré (Notepad++, BBEdit, Microsoft Word...) et sa barre de menu contextuel.
Les composants principaux de ce pattern sont :
- Commande (ActionListenerCommand) : interface définissant une méthode execute() qui encapsule l'action à effectuer.
public interface ActionListenerCommand {
void execute();
}
- Commande Concrete (ActionOpen et ActionSave): Implémentation de l'interface commande et la méthode execute()
public class ActionOpen implements ActionListenerCommand {
private Document doc;
public ActionOpen(Document doc) {
this.doc = doc;
}
@Override
public void execute() {
doc.open();
}
}
public class ActionSave implements ActionListenerCommand {
private Document doc;
public ActionSave(Document doc) {
this.doc = doc;
}
@Override
public void execute() {
doc.save();
}
}
- Un Expéditeur (MenuOption) : Demande à la commande d'effectuer une requête.
public class MenuOptions {
private ActionListenerCommand openCommand;
private ActionListenerCommand saveCommand;
public MenuOptions(ActionListenerCommand open, ActionListenerCommand save) {
this.openCommand = open;
this.saveCommand = save;
}
public void clickOpen(){
openCommand.execute();
}
public void clickSave(){
saveCommand.execute();
}
}
- Un Destinataire (Document) : Objet qui sait comment effectuer l'opération associée à une requête.
public class Document {
public void open(){
System.out.println("Document Opened");
}
public void save(){
System.out.println("Document Saved");
}
}
Utilisation
- Un objet Commande est créé et associé à une action spécifique.
ActionListenerCommand clickOpen = new ActionOpen(doc);
ActionListenerCommand clickSave = new ActionSave(doc);
- L'objet Commande est passé à l'expéditeur qui sera responsable de l'orchestration des appels à la méthode execute()
MenuOptions menu = new MenuOptions(clickOpen, clickSave);
menu.clickOpen();
menu.clickSave();
Le résultat du code ci-dessus en console sera le suivant :
Document Opened
Document Saved
En conclusion
Le design pattern commande offre aux développeurs la possibilité de découper les opérations en objets autonomes, facilitant ainsi la gestion des actions utilisateurs dans les applications logicielles.
En encapsulant chaque action en tant qu'objet autonome, ce modèle favorise la modularité, la réutilisation et la flexibilité du code.
Si vous souhaitez approfondir le sujet, tout le code utilisé dans cet article est disponible juste ici !
