Command Pattern in Java: Simplifying Your Codebase

Table of Contents

1. Fundamental Concepts
2. Usage Methods
3. Common Practices
4. Best Practices
5. Code Examples
6. Conclusion
7. References

Fundamental Concepts

The Command Pattern consists of four main components:

• Command: This is an interface or an abstract class that declares an execute() method. Concrete command classes implement this method to define the specific action to be performed.
• Concrete Command: These are classes that implement the Command interface. Each concrete command class encapsulates a receiver and a set of actions to be performed on that receiver.
• Receiver: The object that performs the actual action. The command object invokes methods on the receiver.
• Invoker: The object that holds a command and is responsible for executing it. It does not need to know the details of the command; it just calls the execute() method.

The main idea behind the Command Pattern is to separate the responsibility of issuing a request from the object that will handle the request. This separation allows for greater flexibility and extensibility in the codebase.

Usage Methods

Step 1: Define the Command Interface

// Command interface
interface Command {
    void execute();
}

Step 2: Create the Receiver Class

// Receiver class
class Light {
    public void turnOn() {
        System.out.println("Light is on");
    }

    public void turnOff() {
        System.out.println("Light is off");
    }
}

Step 3: Implement Concrete Command Classes

// Concrete command classes
class TurnOnLightCommand implements Command {
    private Light light;

    public TurnOnLightCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOn();
    }
}

class TurnOffLightCommand implements Command {
    private Light light;

    public TurnOffLightCommand(Light light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.turnOff();
    }
}

Step 4: Create the Invoker Class

// Invoker class
class RemoteControl {
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void pressButton() {
        command.execute();
    }
}

Step 5: Use the Command Pattern

public class Main {
    public static void main(String[] args) {
        Light light = new Light();
        Command turnOnCommand = new TurnOnLightCommand(light);
        Command turnOffCommand = new TurnOffLightCommand(light);

        RemoteControl remoteControl = new RemoteControl();

        // Turn on the light
        remoteControl.setCommand(turnOnCommand);
        remoteControl.pressButton();

        // Turn off the light
        remoteControl.setCommand(turnOffCommand);
        remoteControl.pressButton();
    }
}

Common Practices

• Queueing Commands: You can use a queue to store commands and execute them in a sequential order. This is useful for implementing task scheduling or transaction processing.

import java.util.LinkedList;
import java.util.Queue;

public class CommandQueue {
    private Queue<Command> queue = new LinkedList<>();

    public void addCommand(Command command) {
        queue.add(command);
    }

    public void executeCommands() {
        while (!queue.isEmpty()) {
            queue.poll().execute();
        }
    }
}

• Logging Commands: You can log each command execution for auditing or debugging purposes.

import java.util.logging.Level;
import java.util.logging.Logger;

class LoggingCommand implements Command {
    private static final Logger LOGGER = Logger.getLogger(LoggingCommand.class.getName());
    private Command command;

    public LoggingCommand(Command command) {
        this.command = command;
    }

    @Override
    public void execute() {
        LOGGER.log(Level.INFO, "Executing command: " + command.getClass().getSimpleName());
        command.execute();
    }
}

Best Practices

• Keep Commands Immutable: Once a command is created, it should not be modified. This ensures that the command’s behavior remains consistent throughout its execution.
• Use Dependency Injection: Inject the receiver object into the concrete command classes instead of creating it inside the command. This makes the code more testable and flexible.
• Implement Undo and Redo: If your application requires undo and redo functionality, you can add an undo() method to the Command interface and implement it in the concrete command classes.

Conclusion

The Command Pattern is a powerful design pattern that can simplify your Java codebase by decoupling the sender of a request from the receiver. It provides a way to encapsulate a request as an object, which allows for greater flexibility and extensibility. By following the common practices and best practices outlined in this blog, you can effectively use the Command Pattern in your Java applications.

References

• Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley.
• Bloch, J. (2018). Effective Java. Addison-Wesley Professional.