Command-Pattern: Aktionen kapseln
Verpacken Sie Anfragen als Command-Objekte, um Rückgängigmachen/Wiederholen und die Aufzeichnung von Makros zu unterstützen.
Command-Pattern: Aktionen kapseln ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.
Die Absicht von Command
Command kapselt eine Anfrage als Objekt. Dadurch können Clients mit unterschiedlichen Anfragen parametrisiert sowie Anfragen in Warteschlangen gestellt, protokolliert und rückgängig gemacht werden.
Command-Schnittstelle
Definieren Sie eine Schnittstelle mit einer execute()-Methode und optional einer undo()-Methode. Jedes Command-Objekt weiß, wie es eine Aktion ausführt und rückgängig macht.
public interface Command {
void execute();
void undo();
}Konkretes Command: TextEditor
Jedes konkrete Command kapselt einen Receiver und die Parameter der Aktion. execute() führt die Aktion aus, undo() macht sie rückgängig.
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()); }
}Invoker: CommandHistory
Der Invoker verwaltet eine Historie der ausgeführten Commands. Er ruft execute() auf und legt das Command auf einem Stack ab. Bei einem Undo wird es vom Stack entfernt und undo() aufgerufen.
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();
}
}Undo-/Redo-Stack
Fügen Sie einen Redo-Stack hinzu: Legen Sie ein Command beim Rückgängigmachen auf dem Redo-Stack ab. Beim Wiederholen entfernen Sie es vom Redo-Stack und führen es erneut aus.
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);
}
}Makro-Command
Ein Makro-Command ist ein Composite, das eine Liste von Commands enthält und sie nacheinander ausführt. Beim Undo werden die Aktionen in umgekehrter Reihenfolge rückgängig gemacht.
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(); }
}Command-Warteschlange zur Aufgabenverarbeitung
Speichern Sie Commands in einer Warteschlange und verarbeiten Sie sie asynchron. Ein Worker-Thread entfernt Commands aus der Warteschlange und führt sie aus – dadurch werden Produzenten und Ausführungs-Thread entkoppelt.
BlockingQueue<Command> queue = new LinkedBlockingQueue<>();
// Producer:
queue.put(new SendEmailCommand(recipient, subject, body));
// Consumer thread:
Command cmd = queue.take();
cmd.execute();Command mit Executor
Verpacken Sie Commands als Runnable-Lambdas und übergeben Sie sie an einen ExecutorService – das Lambda ist dabei das Command-Objekt.
ExecutorService exec = Executors.newFixedThreadPool(4);
exec.submit(() -> sendEmail(recipient, subject));
exec.submit(() -> generateReport(params));Commands zur Protokollierung für Audits
Serialisierbare Command-Objekte können in einem Protokoll persistiert werden. Spielen Sie sie bei der Wiederherstellung erneut ab, um den endgültigen Zustand zu rekonstruieren – das ist die Grundlage von Event Sourcing.
void execute(Command cmd) {
cmd.execute();
auditLog.append(cmd.toString()); // log every action
history.push(cmd);
}Aktionsschaltflächen in GUIs
In GUI-Frameworks enthält jede Schaltfläche und jedes Menüelement ein Command. Beim Anklicken der Schaltfläche wird command.execute() aufgerufen. Tauschen Sie Commands zur Laufzeit aus, um das Verhalten der Schaltfläche zu ändern.
Button saveBtn = new Button("Save");
saveBtn.setOnAction(() -> new SaveDocumentCommand(doc).execute());Command vs. Strategy
Beide Muster kapseln Verhalten. Strategy kapselt einen Algorithmus, der zur Laufzeit ausgetauscht werden kann. Command kapselt eine vollständige Anfrage einschließlich ihrer Parameter und ihres Receivers und unterstützt dadurch Historien und Warteschlangen.
Command in Spring
Das Tasklet von Spring Batch und der MessageHandler von Spring Integration sind Command-Muster auf Anwendungsebene. Jedes Tasklet kapselt einen Schritt eines Batch-Jobs.
Kurzer Test
Welche zusätzliche Methode fügt Command über execute() hinaus hinzu, um Undo zu unterstützen?
Zusammenfassung
Command kapselt Aktionen als Objekte. Verwenden Sie es für Undo-/Redo-Stacks, Aufgabenwarteschlangen, die Aufzeichnung von Makros und Audit-Protokollierung. Kombinieren Sie es mit einem Invoker, der die Command-Historie verwaltet.
Häufig gestellte Fragen
Ist die Lektion „Command-Pattern: Aktionen kapseln“ kostenlos?
Ja — der vollständige Text von „Command-Pattern: Aktionen kapseln“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Command-Pattern: Aktionen kapseln“?
Verpacken Sie Anfragen als Command-Objekte, um Rückgängigmachen/Wiederholen und die Aufzeichnung von Makros zu unterstützen. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Java Academy zu starten?
Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Command-Pattern: Aktionen kapseln“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?
Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Observer-Pattern: Ereignisbenachrichtigung
- Strategy-Pattern: Austauschbare Algorithmen
- Command-Pattern: Aktionen kapseln
- Template Method: Algorithmusgerüste definieren