命令模式基础篇 :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
定义:将一个请求封装为一个对象,从而使你可以用不同的请求对客户进行参数化,对请求排队和记录请求日志,以及支持可撤销的操作;
主要解决:在软件系统中,行为请求者与行为实现者通常是一种紧耦合的关系,但某些场合,比如需要对行为进行记录、撤销或重做、事务等处理时,这种紧耦合的设计就不太合适;
英文:Command
类型:行为型模式
(引)类图:
组成:
● 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();
- }
- }
下面以电视机的开、关命令为例,进行讲解:
- 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();
- }
- }
结果:
- 电视打开电视关闭
关于例子的补充说明:
虽然代码看似挺多,但其实命令模式的结构还是比较清晰的,总的来说命令模式的使用流程就是首先创建一个抽象命令,然后创建多个具体命令实现抽象命令接口,然后创建一个命令接受者角色,它包含各种的行为的具体实现,然后再有一个命令调用者角色,提供给客户端,用于接收客户端的参数;
由于篇幅太长,这里单独拆分出去了;
传送门:
命令模式扩展篇 - 宏命令: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、命令模式将行为调用者和各种行为分隔开,降低程序的耦合,便于程序扩展;
2、命令模式将行为的具体实现封装起来,客户端无需关心行为的具体实现;
3、命令模式可为多种行为提供统一的调用入口,便于程序对行为的管理和控制;
使用命令模式的话,不用管命令多简单,都需要写一个命令类来封装,使用命令模式可能会导致系统有过多的具体命令类;
(上面的例子就可以看出,每个命令都要有一个具体的命令类);
1、希望将行为请求者和行为实现者解耦,不直接打交道;
2、希望分离掉行为请求者一部分的责任,行为请求者只需要将命令发给调用者,不再主动的去让行为实现者产生行为,符合单一职责原则;
3、希望可以控制执行的命令列表,方便记录,撤销 / 重做以及事务等功能;
4、期待可以将请求排队,有序执行;
5、希望可以将请求组合使用,即支持宏命令;
命令模式最大的好处就是实现了行为请求者与行为实现者的解耦;
在实际场景中的使用:
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
来源: http://www.cnblogs.com/JsonShare/p/7202133.html