Command Pattern
The Command pattern encapsulates requests as objects, decoupling the invoker (which triggers the request) from the receiver (which performs the action). By wrapping a request's details, such as the operation, receiver, and parameters, into a command object, the invoker doesn't need to know how the receiver processes the request, promoting loose coupling and flexibility. This encapsulation enables advanced features like undo operations, where a command object stores the necessary state or logic to reverse its action. It also supports queuing, allowing commands to be stored and executed later in a controlled manner, and macro operations, where multiple commands can be grouped into a single composite command for execution as a unit. These capabilities make the Command pattern ideal for systems requiring flexible, reversible, or scheduled operations.
The Command pattern encapsulates a request as an object. This lets you parameterize invokers with different actions, queue or log requests, compose macro commands, and support undo/redo— while keeping senders (invokers) independent of receivers.
execute()), ConcreteCommand (stores a
receiver and implements execute()), Receiver (business logic), Invoker (triggers
execute()), Client (wires everything).Flow: Client creates Receiver → wraps it in ConcreteCommand → gives Command to Invoker → Invoker calls
execute() → ConcreteCommand calls receiver.action().
Why use Command?
- Decoupling: Invokers know only
Command, not concrete receivers. - Undo/redo: Commands can store state needed to reverse operations.
- Queue & schedule: Treat requests as data; enqueue, persist, or retry.
- Macro commands: Compose multiple commands to run as one unit.
- Open/Closed: Add new commands without changing invokers.
When to use it
- GUI or CLI actions (buttons/menus mapped to commands).
- Job queues, schedulers, and task runners.
- Transactional operations that require undo/redo or compensation.
- Remote execution (RPC) or logging/auditing of user actions.
Variations & extensions
- UndoableCommand: add
unexecute()and keep prior state. - MacroCommand: a composite that holds and runs a list of commands.
- AsyncCommand: run
execute()off-thread with retries/backoff.
Trade-offs
- More classes (one per command) increases code count.
- Stateful undo needs careful snapshotting or inverse operations.
Java implementation
See the runnable example with Invoker, Receiver, and multiple ConcreteCommand classes: Command Pattern in Java (code)