In this post, We will talk and learn about the Command Design Pattern in Java
Key Points About Command Design Pattern :
- Command pattern is a data-driven design pattern and falls under behavioral patterns.
- In this Design Pattern, a request is wrapped under an object as command and passed to an invoker object. Here the invoker object looks for the appropriate object which can handle this command Object and passes the command object to the corresponding object which executes the command.
Command Design Pattern in JDK:
- All implementations of java.lang.Runnable
- All implementations of javax.swing.Action
Now Let’s move towards the implementation of the Command Design Pattern.
Here Below Use Case implementation is done for Command Patten:
We have an interface is called Order which is acting as a command. We have created a class is called Stock class which acts as a request. We have two concrete command classes BuyStock and SellStock implementing Order interface which will be doing actual command processing. A class is called a Broker is created which acts as an invoker object. It can take and place orders.
Here Broker object uses command pattern to identify which object will execute which command based on the type of command. Finally, We have class is called ClientTest, our demo class will use Broker class to demonstrate command pattern.
Below is the complete source code:
StockBroker.java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
package com.kkjavatutorials.broker; import java.util.ArrayList; import java.util.List; import com.kkjavatutorials.order.Order; /** * @author KK JavaTutorials *Provides fuctionalities to add *buy or sell Oders and also excutes Orders */ public class StockBroker { //List of Orders to buy or sell private List<Order> orderList = new ArrayList<Order>(); //Adding buy or sell Order public void placeOrder(Order order) { orderList.add(order); } //Executing buy or sell orders public void executeOrders() { for (Order order : orderList) { order.execute(); } orderList.clear(); } } |
Order.java
1 2 3 4 5 6 7 8 |
package com.kkjavatutorials.order; /** * @author KK JavaTutorials * Contract to execute Order */ public interface Order { public abstract void execute(); } |
BuyOrder.java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
package com.kkjavatutorials.order.impl; import com.kkjavatutorials.order.Order; import com.kkjavatutorials.stock.Stock; /** * @author KK JavaTutorials * An Implementation to execute buy Stock */ public class BuyOrder implements Order { private Stock stock; public BuyOrder(Stock stock) { this.stock = stock; } //Execute buy stock public void execute() { stock.buyStock(); } } |
SellOrder.java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package com.kkjavatutorials.order.impl; import com.kkjavatutorials.order.Order; import com.kkjavatutorials.stock.Stock; /** * @author KK JavaTutorials *An Implementation to execute Sell Stock */ public class SellOrder implements Order { private Stock stock; public SellOrder(Stock stock) { this.stock = stock; } //Execute sell Stock public void execute() { stock.sellStock(); } } |
Stock.java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
package com.kkjavatutorials.stock; /** * @author KK JavaTutorials *This class Provides methods *to buy and sell Stock for given Quantity */ public class Stock { private String stockName = "Google Share"; private int stockQuantity = 20; //Method to buy Order public void buyStock() { System.out.println("Stock Name:" + stockName + " and Quantity: " + stockQuantity +" bought"); } //Method to sell Order public void sellStock() { System.out.println("Stock Name: " + stockName + ", and Quantity: " + stockQuantity + " sold"); } } |
ClientTest.java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
package com.kkjavatutorials.client; import com.kkjavatutorials.broker.StockBroker; import com.kkjavatutorials.order.impl.BuyOrder; import com.kkjavatutorials.order.impl.SellOrder; import com.kkjavatutorials.stock.Stock; /** * @author KK JavaTutorials * Client progaram to execute buyOrder & sellOrder * of given Stock */ public class ClientTest { public static void main(String args[]) { //Create Stock Instance Stock stock = new Stock(); //Create Instance of BuyOrder & SellOrder BuyOrder buyOrder = new BuyOrder(stock); SellOrder sellOrder = new SellOrder(stock); //Adding buyOrder & sellOrder in stockBroker StockBroker stockBroker = new StockBroker(); stockBroker.placeOrder(buyOrder); stockBroker.placeOrder(sellOrder); //Now Execute buyOrder & sellOrder stockBroker.executeOrders(); } } |
Output of client Program:
Stock Name:Google Share and Quantity: 20 bought
Stock Name: Google Share, and Quantity: 20 sold
You May Also Like:
Singleton Design Pattern in java
Prototype Pattern in Java
Factory Pattern in Java
Abstract Factory Pattern in Java
Builder Pattern in Java
Adapter Design Pattern in Java
Decorator Design Pattern in Java
Facade Design Pattern in Java
Bridge Design Pattern in Java.
Observer Design Pattern in Java
That’s all about the Command Design Pattern in Java.
If you have any feedback or suggestion please feel free to drop in below comment box.