Modèle Command : encapsuler des actions
Encapsulez des requêtes dans des objets Command pour prendre en charge l’annulation, le rétablissement et l’enregistrement de macros.
Modèle Command : encapsuler des actions est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.
L’intention de Command
Command encapsule une requête sous forme d’objet, ce qui permet de paramétrer les clients avec différentes requêtes, de les mettre en file, de les journaliser et de prendre en charge des opérations annulables.
Interface de Command
Définissez une interface avec une méthode execute() et, éventuellement, une méthode undo(). Chaque objet commande sait effectuer une action et l’inverser.
public interface Command {
void execute();
void undo();
}Commande concrète : TextEditor
Chaque commande concrète encapsule un récepteur et les paramètres de l’action. L’exécution effectue l’action ; l’annulation l’inverse.
public class InsertTextCommand implements Command {
private final TextEditor editor;
private final String text;
private final int position;
public InsertTextCommand(TextEditor editor, String text, int pos) {
this.editor = editor; this.text = text; this.position = pos;
}
public void execute() { editor.insert(position, text); }
public void undo() { editor.delete(position, text.length()); }
}Invocateur : CommandHistory
L’invocateur conserve l’historique des commandes exécutées. Il appelle execute() et les empile. L’annulation dépile une commande et appelle undo().
public class CommandHistory {
private final Deque<Command> history = new ArrayDeque<>();
public void execute(Command cmd) {
cmd.execute();
history.push(cmd);
}
public void undo() {
if (!history.isEmpty()) history.pop().undo();
}
}Pile d’annulation et de rétablissement
Ajoutez une pile de rétablissement : lors d’une annulation, empilez la commande dans cette pile ; lors d’un rétablissement, dépilez-la et exécutez-la de nouveau.
private final Deque<Command> undoStack = new ArrayDeque<>();
private final Deque<Command> redoStack = new ArrayDeque<>();
public void redo() {
if (!redoStack.isEmpty()) {
Command cmd = redoStack.pop();
cmd.execute();
undoStack.push(cmd);
}
}Commande macro
Une commande macro est un objet composite qui contient une liste de commandes et les exécute dans l’ordre. L’annulation exécute les opérations inverses dans l’ordre inverse.
public class MacroCommand implements Command {
private final List<Command> commands;
public MacroCommand(List<Command> commands) { this.commands = commands; }
public void execute() { commands.forEach(Command::execute); }
public void undo() { for (int i = commands.size()-1; i>=0; i--) commands.get(i).undo(); }
}File de commandes pour le traitement des tâches
Stockez les commandes dans une file et traitez-les de manière asynchrone. Un fil d’exécution récupère les commandes dans la file et les exécute, découplant ainsi les producteurs du fil d’exécution chargé de l’exécution.
BlockingQueue<Command> queue = new LinkedBlockingQueue<>();
// Producer:
queue.put(new SendEmailCommand(recipient, subject, body));
// Consumer thread:
Command cmd = queue.take();
cmd.execute();Commande avec un exécuteur
Enveloppez les commandes dans des lambdas Runnable et soumettez-les à un ExecutorService : la lambda constitue l’objet commande.
ExecutorService exec = Executors.newFixedThreadPool(4);
exec.submit(() -> sendEmail(recipient, subject));
exec.submit(() -> generateReport(params));Journaliser les commandes à des fins d’audit
Les objets Command sérialisables peuvent être conservés dans un journal. Lors de la récupération, rejouez-les pour reconstituer l’état final : c’est le fondement de l’approvisionnement par événements.
void execute(Command cmd) {
cmd.execute();
auditLog.append(cmd.toString()); // log every action
history.push(cmd);
}Boutons d’action de l’interface graphique
Dans les infrastructures d’interface graphique, chaque bouton ou élément de menu contient une commande. Cliquer sur le bouton appelle command.execute(). Remplacez les commandes à l’exécution pour modifier le comportement du bouton.
Button saveBtn = new Button("Save");
saveBtn.setOnAction(() -> new SaveDocumentCommand(doc).execute());Command ou stratégie
Les deux encapsulent un comportement. La stratégie encapsule un algorithme qui peut être remplacé à l’exécution. Command encapsule une requête complète, avec ses paramètres et son récepteur, et prend en charge l’historique et la mise en file.
Command dans Spring
Le traitement par lots de Spring et le module d’intégration de Spring proposent des variantes du modèle de commande au niveau applicatif avec Tasklet et MessageHandler. Chaque Tasklet encapsule une étape d’un traitement par lots.
Vérification rapide
Quelle méthode supplémentaire Command ajoute-t-il au-delà de execute() pour prendre en charge l’annulation ?
Récapitulatif
Command encapsule les actions sous forme d’objets. Utilisez-le pour les piles d’annulation et de rétablissement, les files de tâches, l’enregistrement de macros et la journalisation d’audit. Combinez-le avec un invocateur qui conserve l’historique des commandes.
Questions Fréquemment Posées
La leçon « Modèle Command : encapsuler des actions » est-elle gratuite ?
Oui — le texte complet de « Modèle Command : encapsuler des actions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Modèle Command : encapsuler des actions » ?
Encapsulez des requêtes dans des objets Command pour prendre en charge l’annulation, le rétablissement et l’enregistrement de macros. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Java Academy ?
Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Modèle Command : encapsuler des actions » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?
Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Modèle Observer : notification d’événements
- Modèle Strategy : algorithmes interchangeables
- Modèle Command : encapsuler des actions
- Template Method : définir des squelettes d’algorithmes