Command Design Pattern

Design Pattern > Behavioral Design Pattern > Command Design Pattern

In Command design pattern a request is pass to an invoker as an Object, here invoker does not knows to serve the request but uses the command to perform an action.

Benefits of Using Command Pattern :
. it hides the details of the actions that needs to be performed, so that the client code does not need to be concerned about the details when it needs to execute the actions. The client code just needs to tell the application to execute the command that was stored.
. It's easy to add new comands without changing the existing classes.

Key Terms :
Command - Interface with concrete method declaration
ConcreteCommand -

• Implements Command
• Set Receiver in it's method or constructor
• Call Receiver's method in execute()

Receiver -

• Define Actions to be performed

Invoker - Command Object passed to Invoker and it instructs the command to perform an action.

• Set Command object in it's method or constructor
• Call execute on Command object

Client -

• Create Receiver object
• Create Concreate Command object(s)
• Create invoker object and call it's method

Java Implementation :
     In the above key terms you have already seen the Pseudocode. Now, we will see the complete implementation in Java

// Command Interface
public interface Order {

void execute();
}

// ConcreteCommand
public class StockBuy implements Order {

private StockTrade stock;
public StockBuy(StockTrade trade){
stock = trade;
}
@Override
public void execute() {
// call receiver's method
stock.buy();
}

}

// ConcreteCommand
public class StockSell implements Order {

private StockTrade stock;
public StockSell(StockTrade trade){
stock = trade;
}
@Override
public void execute() {
// call receiver's method
stock.sell();
}

}

// Receiver class
public class StockTrade {

public void buy() {
System.out.println("buying stock");
}

public void sell() {
System.out.println("selling stock");
}

}

// Invoker Class
public class Broker {
Order order;
public Broker(Order odr){
order = odr;
}
void placeOrder(){
order.execute();
}
}

// Client Class
public class Client {

public static void main(String[] args) {
// Create Receiver object
StockTrade st = new StockTrade();
// Create Concreate Command object(s)
StockBuy sb = new StockBuy(st);
StockSell ss = new StockSell(st);
// Create invoker object
Broker bbuy = new Broker(sb);
Broker bsell = new Broker(ss);
// call invoker method
bbuy.placeOrder();
bsell.placeOrder();
}

}

is Invoker Optional In Command Pattern ?
As we know, java.lang.Runnable is one of the examples of command pattern where Thread class works as an invoker. We pass object of a Runnable class to Thread class and say start/run.

But we never create a client class which can invoke main thread.

So an invoker is not optional but it is not tightly coupled to client.