Pattern Command: incapsulare le azioni
Racchiuda le richieste in oggetti Command per supportare annullamento, ripristino e registrazione di macro.
Pattern Command: incapsulare le azioni è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.
Intento di Command
Command incapsula una richiesta come oggetto, consentendo di parametrizzare i client con richieste diverse e di accodare, registrare e annullare le operazioni.
Interfaccia di Command
Definisca un'interfaccia con un metodo execute() e, facoltativamente, un metodo undo(). Ogni oggetto comando sa come eseguire e annullare una singola azione.
public interface Command {
void execute();
void undo();
}Command concreto: TextEditor
Ogni comando concreto incapsula un ricevitore e i parametri dell'azione. L'esecuzione svolge l'azione; l'annullamento la inverte.
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()); }
}Invocatore: CommandHistory
L'invocatore conserva la cronologia dei comandi eseguiti. Chiama execute() e inserisce il comando in uno stack. L'annullamento estrae il comando dallo stack e chiama 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();
}
}Stack di undo / redo
Aggiunga uno stack di redo: quando annulla un'operazione, la inserisca nello stack di redo; quando la ripristina, la estragga dallo stack di redo e la esegua nuovamente.
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);
}
}Macrocomando
Un macrocomando è un composito che contiene un elenco di comandi e li esegue in sequenza. L'annullamento esegue le operazioni inverse in ordine inverso.
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(); }
}Coda di comandi per l'elaborazione delle attività
Conservi i comandi in una coda ed elabori la coda in modo asincrono. Un thread worker estrae ed esegue i comandi, disaccoppiando i produttori dal thread di esecuzione.
BlockingQueue<Command> queue = new LinkedBlockingQueue<>();
// Producer:
queue.put(new SendEmailCommand(recipient, subject, body));
// Consumer thread:
Command cmd = queue.take();
cmd.execute();Command con Executor
Avvolga i comandi in lambda Runnable e li invii a un ExecutorService: la lambda è l'oggetto comando.
ExecutorService exec = Executors.newFixedThreadPool(4);
exec.submit(() -> sendEmail(recipient, subject));
exec.submit(() -> generateReport(params));Registrazione dei comandi per l'audit
Gli oggetti Command serializzabili possono essere salvati in un log. Durante il ripristino, li riproduca per ricostruire lo stato finale: è il principio alla base dell'Event Sourcing.
void execute(Command cmd) {
cmd.execute();
auditLog.append(cmd.toString()); // log every action
history.push(cmd);
}Pulsanti di azione della GUI
Nei framework GUI, ogni pulsante o voce di menu contiene un Command. Facendo clic sul pulsante si chiama command.execute(). Sostituisca i comandi a runtime per modificare il comportamento del pulsante.
Button saveBtn = new Button("Save");
saveBtn.setOnAction(() -> new SaveDocumentCommand(doc).execute());Command e Strategy
Entrambi incapsulano un comportamento. Strategy incapsula un algoritmo che può essere sostituito a runtime. Command incapsula una richiesta completa, inclusi i parametri e il ricevitore, supportando la cronologia e l'accodamento.
Command in Spring
Tasklet di Spring Batch e MessageHandler di Spring Integration sono implementazioni del pattern Command a livello applicativo. Ogni Tasklet incapsula un singolo passaggio di un processo batch.
Verifica rapida
Quale metodo aggiuntivo introduce Command oltre a execute() per supportare l'annullamento?
Riepilogo
Command incapsula le azioni come oggetti. Lo utilizzi per gli stack di undo/redo, le code di attività, la registrazione di macro e il logging di audit. Lo combini con un invocatore che mantiene la cronologia dei comandi.
Domande Frequenti
La lezione «Pattern Command: incapsulare le azioni» è gratuita?
Sì — il testo completo di «Pattern Command: incapsulare le azioni» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.
Cosa imparerò in «Pattern Command: incapsulare le azioni»?
Racchiuda le richieste in oggetti Command per supportare annullamento, ripristino e registrazione di macro. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Java Academy?
Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Pattern Command: incapsulare le azioni»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Java Academy?
Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Pattern Observer: notifica degli eventi
- Pattern Strategy: algoritmi intercambiabili
- Pattern Command: incapsulare le azioni
- Template Method: definire scheletri di algoritmi