命令模式如何使发送者与接收者脱钩？

Question

Command模式具有一个IReceiver接口，该接口带有很少的方法，并且与每个方法相对应的都是具体的Command对象（ICommand使用execute（）方法实现接口）。

我了解到，客户端了解具体的接收方和具体命令，通常是客户在具体的命令对象中设置接收方对象。那么为什么说它使发送者和接收者分离呢？

当客户端已经知道具体的接收方时，我认为这并不是松散的耦合，并且在这种情况下，客户端也可以直接在接收方对象上调用API（方法）。

Answer 1

您可以想到以下命令模式工作流程。

1. Command 声明所有命令的接口，并提供一个简单的execute（）方法，该方法要求命令Receiver进行操作。

2. 该Receiver有怎样做才能执行请求的知识。

3. 该Invoker持有命令可以得到Command通过调用execute方法来执行请求。

4. 在Client创建ConcreteCommands并设置Receiver该命令。

5. 的ConcreteCommand限定的动作和所述接收器之间的结合。

6. 当Invoker调用执行ConcreteCommand将运行在接收一个或多个动作。

查看示例代码以更好地理解事物。

public class CommandDemoEx{
    public static void main(String args[]){

        // On command for TV with same invoker 
        Receiver r = new TV();
        Command onCommand = new OnCommand(r);
        Invoker invoker = new Invoker(onCommand);
        invoker.execute();

        // On command for DVDPlayer with same invoker 
        r = new DVDPlayer();
        onCommand = new OnCommand(r);
        invoker = new Invoker(onCommand);
        invoker.execute();

    }
}
interface Command {
    public void execute();
}

class Receiver {
    public void switchOn(){
        System.out.println("Switch on from:"+this.getClass().getSimpleName());
    }
}

class OnCommand implements Command{

    private Receiver receiver;

    public OnCommand(Receiver receiver){
        this.receiver = receiver;
    }
    public void execute(){
        receiver.switchOn();
    }
}

class Invoker {
    public Command command;

    public Invoker(Command c){
        this.command=c;
    }
    public void execute(){
        this.command.execute();
    }
}

class TV extends Receiver{
    public TV(){

    }
    public String toString(){
        return this.getClass().getSimpleName();
    }
}
class DVDPlayer extends Receiver{
    public DVDPlayer(){

    }
    public String toString(){
        return this.getClass().getSimpleName();
    }
}

输出：

java CommandDemoEx
Switch on from:TV
Switch on from:DVDPlayer

要回答您的问题：

我已经阅读了客户对具体接收方和具体命令的了解，通常是客户在具体命令对象中设置接收方对象。那为什么说它使发送者和接收者分离

为了使单词标准化，请用“ invoker”替换“ sender”。现在查看代码。

1. Invoker simply executes the ConcreteCommand （在这种情况下为OnCommand）通过传递ConcreteReceiver。
2. ConcreteCommand executes Command 通过ConcreteReceiver即 ConcreteCommand defines binding between Action and Receiver.
3. 如果看到工作流程，Invoker不会更改其他命令，并且可以在execute()Invoker方法中添加业务逻辑，例如java.lang.Thread，如下所述。
4. 就这样 Client (sender) and Receiver are loosely couple through Invoker, which has knowledge of what command to be executed 。

__此
链接中的


线程示例

您可以通过实现Runnable对象来创建线程。

Thread t = new Thread (new MyRunnable()).start();

=>

 Invoker invoker = new Invoker(new ConcreteCommand());
 invoker.start()

并且在start（）中有逻辑可以调用上述情况下的run（）的ConcreteCommand.execute（）。

start（）方法将在Thread中调用run（）方法。 如果直接直接调用run（）方法会怎样？它不会被视为线程。

像该线程的start（）方法一样，您可以在Invoker中添加一些业务逻辑。

public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();
        group.add(this);
        start0();
        if (stopBeforeStart) {
            stop0(throwableFromStop);
        }
    }

private native void start0(); // Native code is not here but this method will call run() method

public void run() {
    if (target != null) {
        target.run();
    }
}

编辑：

关于您的最后一个查询

在这里我们创建命令对象，接收者对象和调用者对象，然后在命令对象中传递接收者对象，然后在调用者对象中传递命令对象。就像我们在这里为电视和DVDPlayer所做的那样，我们为每个接收器执行此操作。同样在方法“主要”中，TV和DVDPlayer的对象是已知的，实际上是创建的。我们可以简单地执行tvObject.switchOn（）和dvdPlayer.switchOn（）。命令模式有何帮助

客户不必担心Receiver班级变化。Invoker直接在ConcreteCommand具有Receiver对象的上工作。Receiver对象将来可能会从siwtchOn（）更改为switchOnDevice（）。但是客户端交互不会改变。

如果您有两个不同的命令，例如switchOn（）和switchOff（），则仍然可以使用相同的命令Invoker。