命令设计模式

Question

在阅读了命令设计模式之后，我有一个问题-

为什么我们要在客户端上创建具体的命令和接收对象。这个名字不能写在调用者类上吗？

我认为客户应该创建调用程序并将其请求传递给调用方。应召客应该处理好所有的事情。

通过这样做，

1. 我们对客户端的依赖程度较低，
2. 类图的设计与实际设计完全不同。

例子-客户创建一些买卖股票的订单。然后将订单发送给agent.The代理，接收订单并将其发送到StockTrade系统。

这里，代理人是被叫者，股票交易系统是接受者。

根据命令设计模式：

public interface IOrder 
{
public abstract void execute ( );
}

class StockTrade {
    public void buy() {
        System.out.println("You want to buy stocks");
    }
    public void sell() {
        System.out.println("You want to sell stocks ");
    }
}

class Agent {
    public Agent() 
    {
    }

    void placeOrder(IOrder order) {
        order.execute();
    }    
}

//ConcreteCommand Class.
class BuyStockOrder implements Order {
    private StockTrade stock;
    public BuyStockOrder ( StockTrade st) {
        stock = st;
    }
    public void execute( ) {
        stock . buy( );
    }
}

//ConcreteCommand Class.
class SellStockOrder implements IOrder { 
    private StockTrade stock;
    public SellStockOrder ( StockTrade st) {
        stock = st;
    }
    public void execute( ) {
        stock . sell( );
    }
}

// Client
public class Client {
    public static void main(String[] args) {
        StockTrade stock = new StockTrade();
        BuyStockOrder bsc = new BuyStockOrder (stock);
        SellStockOrder ssc = new SellStockOrder (stock);
        Agent agent = new Agent();

        agent.placeOrder(bsc); // Buy Shares
        agent.placeOrder(ssc); // Sell Shares
    }
}

现在，该类依赖于接收方、具体命令和代理。

我们不能从客户端移动接收器和具体的命令依赖吗？

Agent Class
class Agent {
    public Agent() 
    {
    }

    void BuyStock(BuyStockRequest request) 
    {
        IOrder order = new BuyStockOrder();
    order.execute(request);
    } 

    void SellStock(SellStockRequest request) 
    {
        IOrder order = new SellStockOrder();
    order.execute(request);
    }   
}

//ConcreteCommand Class.
class BuyStockOrder implements IOrder {
    private StockTrade stock;
    public BuyStockOrder () {
        stock = new StockTrade;
    }
    public void execute(BuyStockRequest request) {
        stock.Name = request.Name;
    stock.Price = request.Price;
        stock.buy( );
    }
}

//ConcreteCommand Class.
class SellStockOrder implements IOrder {
    private StockTrade stock;
    public SellStockOrder () {
        stock = new StockTrade;
    }
    public void execute(SellStockRequest request) {
        stock.Name = request.Name;
    stock.Price = request.Price;
        stock.sell( );
    }
}


//Request Class
class BuyStockRequest
{
  public string Name {get; set;}
  public decimal price {get; set;}
}

class SellStockRequest
{
  public string Name {get; set;}
  public decimal price {get; set;}
}

Client
public class Client {
    public static void main(String[] args) {
        BuyStockRequest request = new BuyStockRequest();
        request.Name = "XYZ";
    request.Price = 100;
        Agent agent = new Agent();
        agent.BuyStock(request); // Buy Shares
    }
}

Answer 1

实际上，它可以归结为您有多少命令，以及您希望从调用方公开多少接口。如果您最终公开了每个命令的一个接口，那么为什么要首先创建命令对象。命令模式的整个思想是将调用逻辑与命令数量分离开来，因为您增加了Agent类不应在go下进行任何更改的命令数量。