Padrão Command: Encapsulamento de Ações
Empacote solicitações como objetos Command para permitir desfazer/refazer e gravação de macros.
Padrão Command: Encapsulamento de Ações é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.
A intenção de Command
Command encapsula uma solicitação como um objeto, permitindo parametrizar clientes com diferentes solicitações, enfileiramento, registro e operações que podem ser desfeitas.
Interface de Command
Defina uma interface com um método execute() e, opcionalmente, um método undo(). Cada objeto Command sabe como executar e reverter uma ação.
public interface Command {
void execute();
void undo();
}Command concreto: TextEditor
Cada comando concreto encapsula um receptor e os parâmetros da ação. A execução realiza a ação; desfazer a reverte.
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()); }
}Invocador: CommandHistory
O invocador mantém um histórico de comandos executados. Ele chama execute() e empilha o comando. Desfazer retira um comando da pilha e chama 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();
}
}Pilha de desfazer/refazer
add uma pilha de refazer: ao desfazer, faça push para a pilha de refazer; ao refazer, faça pop da pilha de refazer e execute novamente.
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);
}
}Macro de Command
Uma macro de Command é um composto que contém uma lista de comandos e os executa em sequência. Desfazer executa as reversões na ordem inversa.
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(); }
}Fila de Command para processamento de tarefas
Armazene comandos em uma fila e processe-os de forma assíncrona. Uma linha de execução de trabalho retira e executa os comandos — desacoplando os produtores da linha de execução que realiza a execução.
BlockingQueue<Command> queue = new LinkedBlockingQueue<>();
// Producer:
queue.put(new SendEmailCommand(recipient, subject, body));
// Consumer thread:
Command cmd = queue.take();
cmd.execute();Command com um executor
Encapsule comandos como lambdas Runnable e envie-os para um ExecutorService — a lambda é o objeto Command.
ExecutorService exec = Executors.newFixedThreadPool(4);
exec.submit(() -> sendEmail(recipient, subject));
exec.submit(() -> generateReport(params));Registro de Command para auditoria
Objetos Command serializáveis podem ser persistidos em um registro. Durante a recuperação, reproduza-os para reconstruir o estado final — a base da Origem de Eventos.
void execute(Command cmd) {
cmd.execute();
auditLog.append(cmd.toString()); // log every action
history.push(cmd);
}Botões de ação da GUI
Em estruturas de GUI, cada botão ou item de menu contém um Command. Clicar no botão chama command.execute(). Troque os comandos durante a execução para alterar o comportamento do botão.
Button saveBtn = new Button("Save");
saveBtn.setOnAction(() -> new SaveDocumentCommand(doc).execute());Command versus Estratégia
Ambos encapsulam comportamento. A Estratégia encapsula um algoritmo que pode ser trocado durante a execução. Command encapsula uma solicitação completa, incluindo seus parâmetros e receptor, oferecendo suporte a histórico e enfileiramento.
Command no Spring
O Tasklet do Spring Batch e o MessageHandler do Spring Integration são padrões de Command no nível da aplicação. Cada Tasklet encapsula uma etapa de um trabalho em lote.
Verificação rápida
Qual método adicional Command acrescenta além de execute() para oferecer suporte ao desfazer?
Recapitulação
Command encapsula ações como objetos. Use-o para pilhas de desfazer/refazer, filas de tarefas, gravação de macros e registro de auditoria. Combine-o com um invocador que mantenha o histórico de comandos.
Perguntas Frequentes
A aula “Padrão Command: Encapsulamento de Ações” é grátis?
Sim — o texto completo de “Padrão Command: Encapsulamento de Ações” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.
O que vou aprender em “Padrão Command: Encapsulamento de Ações”?
Empacote solicitações como objetos Command para permitir desfazer/refazer e gravação de macros. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Java Academy?
Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Padrão Command: Encapsulamento de Ações”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Java Academy?
Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Padrão Observer: Notificação de Eventos
- Padrão Strategy: Algoritmos Intercambiáveis
- Padrão Command: Encapsulamento de Ações
- Template Method: Definição de Esqueletos de Algoritmos