커맨드 디자인 패턴

Question

커맨드 디자인 패턴을 읽은 후 질문이 있습니다. -

클라이언트에서 구체적인 명령과 수신자 객체를 만드는 이유는 무엇입니까? 호출자 클래스에서 초기화 할 수 없습니까?

클라이언트가 호출자를 만들어 호출자에게 전달해야한다고 생각합니다. 호출자는 모든 것을 처리해야합니다. 이렇게함으로써

,

1. 우리는 클라이언트에 덜 의존이있다.
2. 클래스 다이어그램의 디자인은 실제 디자인과 완전히 다릅니다.

예 - 클라이언트가 주식 매매에 대한 일부 주문을 생성합니다. 그런 다음 주문이 상담원에게 전송됩니다. 상담원이 주문을 받아 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

사실 얼마나 많은 명령을 가지고 있으며 호출자로부터 노출시키고 싶은 인터페이스의 수에 따라 달라집니다. 각 명령에 대해 하나의 인터페이스를 노출하게되면 결국 명령 개체를 생성하는 것이 어렵습니다. 명령 패턴의 전체 아이디어는 에이전트 클래스가 변경하지 말아야 할 명령의 수를 늘릴 때 호출자 논리를 명령 수에서 분리하는 것입니다.