设计模式解密（11）- 命令模式

◆ 前言：命令模式内容比较多，这里做了拆分

命令模式基础篇 ：http://www.cnblogs.com/JsonShare/p/7202133.html

命令模式扩展篇 - 宏命令：http://www.cnblogs.com/JsonShare/p/7206395.html

命令模式扩展篇 - 撤销命令：http://www.cnblogs.com/JsonShare/p/7206513.html

命令模式扩展篇 - 命令队列：http://www.cnblogs.com/JsonShare/p/7206607.html

命令模式扩展篇 - 请求日志：http://www.cnblogs.com/JsonShare/p/7206665.html

1、简介

定义：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作；

主要解决：在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系，但某些场合，比如需要对行为进行记录、撤销或重做、事务等处理时，这种紧耦合的设计就不太合适；

英文：Command

类型：行为型模式

2、类图及组成

（引）类图：



组成：
　　● Command（抽象命令类）：抽象命令类一般是一个抽象类或接口，在其中声明了用于执行请求的execute()等方法，通过这些方法可以调用请求接收者的相关操作。

　　● ConcreteCommand（具体命令类）：具体命令类是抽象命令类的子类，实现了在抽象命令类中声明的方法，它对应具体的接收者对象，将接收者对象的动作绑定其中。在实现execute()方法时，将调用接收者对象的相关操作(Action)。

　　● Invoker（调用者）：调用者即请求发送者，它通过命令对象来执行请求。一个调用者并不需要在设计时确定其接收者，因此它只与抽象命令类之间存在关联关系。在程序运行时可以将一个具体命令对象注入其中，再调用具体命令对象的execute()方法，从而实现间接调用请求接收者的相关操作。

　　● Receiver（接收者）：接收者请求与执行相关的操作，它具体实现对请求的业务处理。

　　● Client（客户端角色类）：最终的客户端调用类。

代码结构：

抽象命令角色类
public interface Command {
/**
* 执行方法
*/
void execute();
}

具体命令角色类
public class ConcreteCommand implements Command {
//持有相应的接收者对象
private Receiver receiver = null;
/**
* 构造方法
*/
public ConcreteCommand(Receiver receiver){
this.receiver = receiver;
}
@Override
public void execute() {
//通常会转调接收者对象的相应方法，让接收者来真正执行功能
receiver.action();
}
}

接收者角色类
public class Receiver {
/**
* 真正执行命令相应的操作
*/
public void action(){
System.out.println("执行操作");
}
}

请求者角色类
public class Invoker {
/**
* 持有命令对象
*/
private Command command = null;
/**
* 构造方法
*/
public Invoker(Command command){
this.command = command;
}
/**
* 行动方法
*/
public void action(){
command.execute();
}
}

客户端角色类
public class Client {
public static void main(String[] args) {
//创建接收者
Receiver receiver = new Receiver();
//创建命令对象，设定它的接收者
Command command = new ConcreteCommand(receiver);
//创建请求者，把命令对象设置进去
Invoker invoker = new Invoker(command);
//执行方法
invoker.action();
}
}

3、实例引入

下面以电视机的开、关命令为例，进行讲解：

package com.designpattern.Command;
/**
* 抽象命令角色类
* @author Json
*/
public interface Command {
/**
* 执行方法
*/
void execute();
}

package com.designpattern.Command;
/**
* 接收者角色类  -- 电视
* @author Json
*/
public class TV {
/**
* 打开方法
*/
public void on(){
System.out.println("电视打开");
}
/**
* 关闭方法
*/
public void off(){
System.out.println("电视关闭");
}
}

package com.designpattern.Command;
/**
* 具体命令角色类  -- 电视打开命令
* @author Json
*/
public class TVOnCommand implements Command {
private TV tv;
public TVOnCommand(TV tv){
this.tv = tv;
}

@Override
public void execute() {
tv.on();
}
}

package com.designpattern.Command;
/**
* 具体命令角色类  -- 电视关闭命令
* @author Json
*/
public class TVOffCommand implements Command {
private TV tv;
public TVOffCommand(TV tv){
this.tv = tv;
}

@Override
public void execute() {
tv.off();
}
}

package com.designpattern.Command;
/**
* 请求者角色类  -- 遥控器Invoker
* @author Json
*/
public class RemoteControl {
private Command onCommand,offCommand;

public RemoteControl(Command _on,Command _off){
this.onCommand = _on;
this.offCommand = _off;
}

public void turnOn(){
onCommand.execute();
}

public void turnOff(){
offCommand.execute();
}
}

测试：

package com.designpattern.Command;
/**
* 客户端角色类
* @author Json
*/
public class Client {
public static void main(String[] args) {
//创建接收者
TV receiver = new TV();
//创建命令对象，设定它的接收者
Command on_command = new TVOnCommand(receiver);
//创建命令对象，设定它的接收者
Command off_command = new TVOffCommand(receiver);
//命令控制对象Invoker，把命令对象通过构造方法设置进去 或者 增加set方法set进去是一样的（setCommand方法未写）
RemoteControl invoker = new RemoteControl(on_command,off_command);
//执行方法  -- 打开电视
invoker.turnOn();
//执行方法 -- 关闭电视
invoker.turnOff();
}
}

结果：

电视打开
电视关闭

关于例子的补充说明：

虽然代码看似挺多，但其实命令模式的结构还是比较清晰的，总的来说命令模式的使用流程就是首先创建一个抽象命令，然后创建多个具体命令实现抽象命令接口，然后创建一个命令接受者角色，它包含各种的行为的具体实现，然后再有一个命令调用者角色，提供给客户端，用于接收客户端的参数；

4、命令模式的扩展

由于篇幅太长，这里单独拆分出去了；

传送门：

　　命令模式扩展篇 - 宏命令：http://www.cnblogs.com/JsonShare/p/7206395.html

　　命令模式扩展篇 - 撤销命令：http://www.cnblogs.com/JsonShare/p/7206513.html

　　命令模式扩展篇 - 命令队列：http://www.cnblogs.com/JsonShare/p/7206607.html

　　命令模式扩展篇 - 请求日志：http://www.cnblogs.com/JsonShare/p/7206665.html

5、优缺点

优点：

　　1、命令模式将行为调用者和各种行为分隔开，降低程序的耦合，便于程序扩展；

　　2、命令模式将行为的具体实现封装起来，客户端无需关心行为的具体实现；

　　3、命令模式可为多种行为提供统一的调用入口，便于程序对行为的管理和控制；

缺点：

　　使用命令模式的话，不用管命令多简单，都需要写一个命令类来封装，使用命令模式可能会导致系统有过多的具体命令类；

（上面的例子就可以看出，每个命令都要有一个具体的命令类）；

6、应用场景

　　1、希望将行为请求者和行为实现者解耦，不直接打交道；

　　2、希望分离掉行为请求者一部分的责任，行为请求者只需要将命令发给调用者，不再主动的去让行为实现者产生行为，符合单一职责原则；

　　3、希望可以控制执行的命令列表，方便记录，撤销/重做以及事务等功能；

　　4、期待可以将请求排队，有序执行；

　　5、希望可以将请求组合使用，即支持宏命令；

7、总结

　　命令模式最大的好处就是实现了行为请求者与行为实现者的解耦；

　　在实际场景中的使用：

　　　　　　Struts2中action中的调用过程中存在命令模式；

　　　　　　数据库中的事务机制的底层实现；

　　　　　　命令的撤销和恢复：增加相应的撤销和恢复命令的方法（比如数据库中的事务回滚）；

　　例如：Java的Runnable就是命令模式的变形应用：

public class Test {
public static void main(String[] args) {
//范例
Runnable runnable = () -> System.out.println("具体命令"); // Command cmd = ConcreteCommand
Thread thread1 = new Thread(runnable); // 将 cmd 交给 Thread (Invoker)
thread1.start(); // Invoker 调用 cmd 的执行方法
}
}

PS：源码地址 https://github.com/JsonShare/DesignPattern/tree/master

PS：原文地址 http://www.cnblogs.com/JsonShare/p/7202133.html