कमांड पैटर्न व्यवहार पैटर्न में से एक है, जहां एक अनुरोध को एक ऑब्जेक्ट के अंदर कमांड के रूप में लपेटा जाता है और वह ऑब्जेक्ट एक इनवॉकर को पास कर दिया जाता है, फिर इनवॉकर एक उपयुक्त ऑब्जेक्ट की तलाश करता है जो इस कमांड को संभाल सके और संबंधित ऑब्जेक्ट को कमांड भेजता है, ऑब्जेक्ट फिर कमांड निष्पादित करता है।

यह OCP ठोस सिद्धांत का भी पालन करता है

आइए शेयर बाजार का एक उदाहरण लेते हैं, जहां स्टॉक एक अनुरोध है जिसे खरीदा या बेचा जाना चाहिए (कमांड), यह स्टॉक ऑर्डर के तहत लपेटा जाता है, यह ऑर्डर फिर ब्रोकर (इनवोकर) को भेजा जाता है ), ब्रोकर तब यह तय करने के लिए ऑर्डर का विश्लेषण करता है कि यह बायऑर्डर है या सेलऑर्डर और अंत में खरीदें या बेचने का ऑर्डर निष्पादित किया जाता है(कमांड/अनुरोध का निष्पादन)

स्टॉक (अनुरोध)

public class Stock {
    private String name ;
    private int quantity;
    public Stock(String n, int q){
        this.name = n;
        this.quantity = q;
    }
    public void sell(){
        System.out.println("[Sell order of quantity "  quantity  " for stock " name  " has been performed]");
    }
    public void buy(){
        System.out.println("[Buy order of quantity "  quantity  " for stock " name  " has been performed]");
    }
}

ऑर्डर (किसी ऑब्जेक्ट के अंदर कमांड के रूप में लपेटा गया अनुरोध)

public interface Order {
    public void execute();
}

ठोस आदेश

public class BuyOrder implements Order {
    private Stock stock;
    public BuyOrder(Stock s){
        this.stock = s;
    }
    @Override
    public void execute(){
        stock.buy();
    }
}

public class SellOrder implements Order {
    private Stock stock;
    public SellOrder(Stock s){
        this.stock = s;
    }
    @Override
    public void execute(){
        stock.sell();
    }
}

ब्रोकर (इनवोकर जो उचित ऑब्जेक्ट चुनता है जो कमांड/ऑर्डर को संभाल सकता है)

import java.util.ArrayList;
import java.util.List;

public class Broker {
    List orders;
    public Broker(){
        orders = new ArrayList();
    }

    public void addOrder(Order e){
        orders.add(e);
    }

    public void placeOrder(){
        for(Order e : orders){
            e.execute();
        }
        orders.clear();// once all the orders are placed by the broker then, the list should be emptied
    }
}

मुख्य

public class Main {
    public static void main(String args[]){
        //requests
        Stock stock = new Stock("TCS",20);
        Stock stock2 = new Stock("Infy",10);
        //requests wrapped inside object(order) as commands
        Order order1 = new BuyOrder(stock);
        Order order2 = new SellOrder(stock2);

        //order is sent to the broker 
        Broker broker = new Broker();
        broker.addOrder(order1);
        broker.addOrder(order2);

        //broker at runtime decides the appropriate Object for the reference Order
        //in other words the invokers decide which object is appropriate and can handle this command/Order
        broker.placeOrder();
    }
}

आउटपुट:

[Buy order of quantity 20 for stock TCS has been performed]
[Sell order of quantity 10 for stock Infy has been performed]

इस पैटर्न के लिए मुख्य बिंदु

• ओसीपी और एसआईपी के ठोस सिद्धांतों का पालन करता है।
• ऑर्डर का प्रकार रनटाइम पर ज्ञात होता है