Command Design Pattern Using Java Sample

What is Command Design Pattern?

Command Design pattern is a behavioral design pattern in which a request can be turned to action.

Where to use Command Design Pattern?

When we have a requirement of,

Do and undo action
When you want to pass method as argument or in another way when you want to call callbackfunction
When we want to log or track commands

Why use Command Design Pattern?

Command Design Pattern is a request driven design pattern. A request will help to choose which command needs to be executed without knowing which object.method to call. In this kind of case, command design pattern plays a key role which will make this easy by using ICommand. Command design pattern actually decouples command manager and command execution logic; i.e. Actual implementation.

Players in this pattern

ICommand – an interface which will do action and undo action
ConcreateCommand – implements ICommand
Invoker – carries out the action
Receive -- receives action from invoker and performs action

Problem definition

Provide interface to user to open and close the door. And if user want,s user should be able to undo his/her last action.

This example actually showcases the use case of do and undo action requirement. For other requirements I will write separate articles.

Players here,

ICommand – ICommand
ConcreateCommand – DoorCommand
Invoker – client, in our case client operation in main function
Receiver – Door

We will first define actions which we want to execute,

package com.sample.Command.Design.Pattern;
public enum Action
{
DOOR_OPEN,
DOOR_CLSOE
}

Below is the ICommand interface which will define contact to implement

package com.sample.Command.Design.Pattern;
public interface ICommand {
void execute(Action action);
void undoExecute();
}

Below is the DoorCommand class which implements the ICommand contract

package com.sample.Command.Design.Pattern;
public class DoorCommand implements ICommand {
private Door door;
Action lastAction;
public DoorCommand()
{
door = new Door();
}
public void execute(Action doorAction)
{
switch (doorAction)
{
case DOOR_OPEN:
door.open();
break;
case DOOR_CLSOE:
door.close();
break;
default:
return;
}
lastAction = doorAction;
}
public void undoExecute()
{
switch (lastAction)
{
case DOOR_OPEN:
door.close();
break;
case DOOR_CLSOE:
door.open();
break;
default:
return;
}
}
}

Below is the Door class, it actually has core logic implementation

package com.sample.Command.Design.Pattern;
public class Door {
public void open() {
System.out.println("------------Door Opened---------------");
}
public void close(){
System.out.println("------------Door Closed---------------");
}
}

Below is the Invoker, which requests for some action

package com.sample;
import com.sample.Command.Design.Pattern.DoorCommand;
import com.sample.Command.Design.Pattern.ICommand;
import static com.sample.Command.Design.Pattern.Action.DOOR_CLSOE;
import static com.sample.Command.Design.Pattern.Action.DOOR_OPEN;
public class Main {
public static void main(String[] args) {
ICommand command = new DoorCommand();
command.execute(DOOR_OPEN);
command.execute(DOOR_CLSOE);
command.undoExecute();
}
}

Below is the output Snap

Command Design Pattern Using Java Sample

Summary

In this article we understood about usage of command design pattern mainly concentrating on do and undo operations.