设计模式——命令模式

最新推荐文章于 2024-08-23 09:16:25 发布

肥羊汤

最新推荐文章于 2024-08-23 09:16:25 发布

阅读量249

点赞数

分类专栏：设计模式文章标签：命令模式回滚

本文链接：https://blog.csdn.net/u012839256/article/details/105957620

版权

设计模式专栏收录该内容

37 篇文章 5 订阅

订阅专栏

命令模式

命令模式：将一个请求封装成一个对象，从而让你使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。

三个角色：

Receive接收者角色：该角色就是干活的角色，命令传递到这里是应该被执行的。
Command命令角色：需要执行的所有命令都在这里声明。
Invoker调用者角色：接收到命令，并执行命令。

通用Receiver类：

public abstract class Receiver { 
    //抽象接收者，定义每个接收者都必须完成的业务 
    public abstract void doSomething(); 
}

具体的Receiver类ConcreteReciver1、ConcreteReciver2：

public class ConcreteReciver1 extends Receiver{ 
    //每个接收者都必须处理一定的业务逻辑 
    public void doSomething(){ 
    } 
}

public class ConcreteReciver2 extends Receiver{ 
    //每个接收者都必须处理一定的业务逻辑 
    public void doSomething(){ 
    } 
}

抽象的Command类：

public abstract class Command { 
    //每个命令类都必须有一个执行命令的方法
    public abstract void execute(); 
}

具体的Command类ConcreteCommand1、ConcreteCommand2：

public class ConcreteCommand1 extends Command { 
    //对哪个Receiver类进行命令处理 
    private Receiver receiver; 
    //构造函数传递接收者 
    public ConcreteCommand1(Receiver _receiver){ 
        this.receiver = _receiver; 
    }
    //必须实现一个命令 
    public void execute() { 
        //业务处理 
        this.receiver.doSomething(); 
    } 
}

public class ConcreteCommand2 extends Command { 
    //哪个Receiver类进行命令处理 
    private Receiver receiver; 
    //构造函数传递接收者 
    public ConcreteCommand2(Receiver _receiver){ 
        this.receiver = _receiver; 
    }
    //必须实现一个命令 
    public void execute() { 
        //业务处理 
        this.receiver.doSomething(); 
    } 
}

调用者Invoker类：

public class Invoker { 
    private Command command; 
    //受气包，接受命令 
    public void setCommand(Command _command){ 
        this.command = _command; 
    }
    //执行命令 
    public void action(){ 
        this.command.execute(); 
    }
}

场景类Client：

public class Client { 
    public static void main(String[] args) { 
        //首先声明调用者Invoker 
        Invoker invoker = new Invoker(); 
        //定义接收者 
        Receiver receiver = new ConcreteReciver1(); 
        //定义一个发送给接收者的命令 
        Command command = new ConcreteCommand1(receiver); 
        //把命令交给调用者去执行 
        invoker.setCommand(command); 
        invoker.action(); 
    } 
}

每一个模式到实际应用的时候都有一些变形，命令模式的Receiver在实际应用中一般都会被封装掉（除非非常必要，例如撤销处理），那是因为在项目中：约定的优先级最高，每一个命令是对一个或多个Receiver的封装，我们可以在项目中通过有意义的类名或命令名处理命令角色和接收者角色的耦合关系（这就是约定），减少高层模块（Client类）对低层模块（Receiver角色类）的依赖关系，提高系统整体的稳定性。因此，建议大家在实际的项目开发时采用封闭Receiver的方式（当然了，仁者见仁，智者见智），减少Client对Reciver的依赖。

public abstract class Command { 
    //定义一个子类的全局共享变量 
    protected final Receiver receiver; 
    //实现类必须定义一个接收者 
    public Command(Receiver _receiver){ 
        this.receiver = _receiver; 
    }    
    //每个命令类都必须有一个执行命令的方法
    public abstract void execute(); 
}

public class ConcreteCommand1 extends Command {//声明自己的默认接收者 
    public ConcreteCommand1(){ 
        super(new ConcreteReciver1()); 
    }
    //设置新的接收者 
    public ConcreteCommand1(Receiver _receiver){ 
        super(_receiver); 
    }
    //每个具体的命令都必须实现一个命令 
    public void execute() { 
        //业务处理 
        super.receiver.doSomething(); 
    } 
}

public class ConcreteCommand2 extends Command { 
    //声明自己的默认接收者 
    public ConcreteCommand2(){ 
        super(new ConcreteReciver2()); 
    }
    //设置新的接收者 
    public ConcreteCommand2(Receiver _receiver){ 
        super(_receiver); 
    }
    //每个具体的命令都必须实现一个命令 
    public void execute() { 
        //业务处理 
        super.receiver.doSomething(); 
    } 
}

public class Client { 
    public static void main(String[] args) { 
        //首先声明调用者
        Invoker Invoker invoker = new Invoker(); 
        //定义一个发送给接收者的命令 
        Command command = new ConcreteCommand1(); 
        //把命令交给调用者去执行 
        invoker.setCommand(command); 
        invoker.action(); 
    } 
}

命令模式的优点

类间解耦：调用者角色与接收者角色之间没有任何依赖关系，调用者实现功能时只需调用Command抽象类的execute方法即可，不需要了解到底是哪个接收者执行。
可扩展性：Command的子类可以非常容易地扩展，而调用者Invoker和高层次的模块Client不产生严重的代码耦合。
命令模式结合其他模式会更优秀：命令模式可以结合责任链模式，实现命令族解析任务；结合模板方法模式，则可以减少Command子类的膨胀问题。

命令模式的缺点

Command的子类：如果有N个命令，Command的子类就可不是几个，而是N个，这个类膨胀得非常大。

命令模式的使用场景

只要是命令的地方就可以采用命令模式。例如：

在GUI开发中，一个按钮的点击是一个命令；
模拟DOS命令的时候；
触发－反馈机制的处理等。

命令模式的扩展

反悔问题：Ctl+Z组合键（undo功能），发出一个命令，在没有执行（这时只要重新setCommand就可以了）或执行后撤回（执行后撤回是状态变更）。

有两种方法可以解决：

一是结合备忘录模式还原最后状态，该方法适合接收者为状态的变更情况，而不适合事件处理；
二是通过增加一个新的命令，实现事件的回滚。

命名模式实例

甲方与乙方合作项目，乙方含有需求组、美工组和代码组，期间甲方会要求乙方各种改需求，类图如下：

（1）组别接口Group

public abstract class Group {
	//甲乙双方分开办公，如果想要和某个组讨论，先要找到该组
	public abstract void find();
	//被要求增加功能
	public abstract void add();
	//被要求删除功能
	public abstract void delete();
	//被要求修改功能
	public abstract void change();
	//被要求给出所有的变更计划
	public abstract void plan();
}

（2）需求组、美工组和代码组功能

import com.sfq.impl.Group;
public class RequirementGroup extends Group {
	//客户要求需求组会谈
	@Override
	public void find() {
		System.out.println("找到需求组...");
	}
	@Override
	public void add() {
		System.out.println("客户要求增加一项需求...");
	}
	@Override
	public void delete() {
		System.out.println("客户要求删除一项需求...");
	}
	@Override
	public void change() {
		System.out.println("客户要求修改一项需求...");
	}
	@Override
	public void plan() {
		System.out.println("客户要求需求变更计划...");
	}
}

import com.sfq.impl.Group;
public class PageGroup extends Group {
	//客户要求美工组会谈
	@Override
	public void find() {
		System.out.println("找到美工组...");
	}
	@Override
	public void add() {
		System.out.println("客户要求增加一个页面...");
	}
	@Override
	public void delete() {
		System.out.println("客户要求删除一个页面...");
	}
	@Override
	public void change() {
		System.out.println("客户要求修改一个页面...");
	}
	@Override
	public void plan() {
		System.out.println("客户要求页面变更计划...");
	}
}

import com.sfq.impl.Group;
public class CodeGroup extends Group {
	//客户要求代码组会谈
	@Override
	public void find() {
		System.out.println("找到代码组...");
	}
	@Override
	public void add() {
		System.out.println("客户要求增加一项功能...");
	}
	@Override
	public void delete() {
		System.out.println("客户要求删除一项功能...");
	}
	@Override
	public void change() {
		System.out.println("客户要求修改一项功能...");
	}
	@Override
	public void plan() {
		System.out.println("客户要求代码变更计划...");
	}
}

（3）Command抽象类：客户发给我们的命令，定义三个工作组的成员变量，供子类使用；定义一个抽象方法execute，由子类来实现。

import com.sfq.action.CodeGroup;
import com.sfq.action.PageGroup;
import com.sfq.action.RequirementGroup;
public abstract class Command {
	//把三个组都定义好，子类可以直接使用
	protected RequirementGroup rg = new RequirementGroup(); //需求组
	protected PageGroup pg = new PageGroup();				//美工组
	protected CodeGroup cg = new CodeGroup();				//代码组
	//只有一个方法，你要我做什么我就做什么
	public abstract void execute();
}

（4）DeletePageCommand删除一个页面

import com.sfq.impl.Command;
public class DeletePageCommand extends Command {
	//执行删除一个页面的命令
	@Override
	public void execute() {
		super.pg.find();
		super.pg.delete();
		super.pg.plan();
	}
}

（5）AddRequirementCommand增加一项需求

public class AddRequirementCommand extends Command {
	//执行增加一项需求的命令
	@Override
	public void execute() {
		// 找到需求组
		super.rg.find();
		//增加一份需求
		super.rg.add();
		//给出计划
		super.rg.plan();
	}
}

（6）Invoker实现类：项目接头负责人，项目经理，setComand接收客户发给我们的命令，action方法是执行客户的命令。

import com.sfq.impl.Command;
public class Invoker {
	//保存命令
	private Command command;
	//客户发出命令
	public void setCommand(Command command) {
		this.command = command;
	}
	//执行客户命令
	public void action() {
		this.command.execute();
	}
}

（7）场景类

import com.sfq.action.AddRequirementCommand;
import com.sfq.action.DeletePageCommand;
import com.sfq.action.Invoker;
import com.sfq.impl.Command;
public class Client {
	public static void main(String[] args) {
		//定义接头人，项目经理
		Invoker xiaoSan = new Invoker();
		System.out.println("-----客户要求增加一项需求-----");
		Command commandAdd = new AddRequirementCommand();
		xiaoSan.setCommand(commandAdd);
		xiaoSan.action();
		
		System.out.println("-----客户要求删除一项需求-----");
		Command commandDel = new DeletePageCommand();
		xiaoSan.setCommand(commandDel);
		xiaoSan.action();
	}
}

结果
-----客户要求增加一项需求-----
找到需求组...
客户要求增加一项需求...
客户要求需求变更计划...
-----客户要求删除一项需求-----
找到美工组...
客户要求删除一个页面...
客户要求页面变更计划...

（8）客户要求增加一项需求，需要三个部门通力合作，只需要修改增加需求的类即可

public class AddRequirementCommand extends Command {
	//执行增加一项需求的命令
	@Override
	public void execute() {
		// 找到需求组
		super.rg.find();
		//增加一份需求
		super.rg.add();
		//页面也要增加 
		super.pg.add(); 
		//功能也要增加 
		super.cg.add();
		//给出计划
		super.rg.plan();
	}
}

import com.sfq.action.AddRequirementCommand;
import com.sfq.action.DeletePageCommand;
import com.sfq.action.Invoker;
import com.sfq.impl.Command;
public class Client {
	public static void main(String[] args) {
		//定义接头人，项目经理
		Invoker xiaoSan = new Invoker();
		System.out.println("-----客户要求增加一项需求-----");
		Command commandAdd = new AddRequirementCommand();
		xiaoSan.setCommand(commandAdd);
		xiaoSan.action();
		
		System.out.println("-----客户要求删除一项需求-----");
		Command commandDel = new DeletePageCommand();
		xiaoSan.setCommand(commandDel);
		xiaoSan.action();
	}
}

结果
-----客户要求增加一项需求-----
找到需求组...
客户要求增加一项需求...
客户要求增加一个页面...
客户要求增加一项功能...
客户要求需求变更计划...
-----客户要求删除一项需求-----
找到美工组...
客户要求删除一个页面...
客户要求页面变更计划...

（9）反悔问题。页面组恢复刚刚删除的页面，也就是日志的回滚机制，指定一个页面，会滚回去。

修改组接口Group添加回滚功能函数：

public abstract class Group {
	//甲乙双方分开办公，如果想要和某个组讨论，先要找到该组
	public abstract void find();
	//被要求增加功能
	public abstract void add();
	//被要求删除功能
	public abstract void delete();
	//被要求修改功能
	public abstract void change();
	//被要求给出所有的变更计划
	public abstract void plan();
	//每个接收者都要对直接执行的任务可以回滚
	public void rollBack() {
		//根据日志进行回滚
		System.out.println("回滚页面");
	}
}

添加一个撤销删除命令类CancelDeletePageCommand：

import com.sfq.impl.Command;
public class CancelDeletePageCommand extends Command {
	//撤销删除一个页面的命令
	@Override
	public void execute() {
		super.pg.rollBack();
	}
}

场景类：

import com.sfq.action.AddRequirementCommand;
import com.sfq.action.CancelDeletePageCommand;
import com.sfq.action.DeletePageCommand;
import com.sfq.action.Invoker;
import com.sfq.impl.Command;
public class Client {
	public static void main(String[] args) {
		//定义接头人，项目经理
		Invoker xiaoSan = new Invoker();
		System.out.println("-----客户要求增加一项需求-----");
		Command commandAdd = new AddRequirementCommand();
		xiaoSan.setCommand(commandAdd);
		xiaoSan.action();
		
		System.out.println("-----客户要求删除一项需求-----");
		Command commandDel = new DeletePageCommand();
		xiaoSan.setCommand(commandDel);
		xiaoSan.action();
		
		System.out.println("-----客户撤销删除页面需求-----");
		Command commandCan = new CancelDeletePageCommand();
		xiaoSan.setCommand(commandCan);
		xiaoSan.action();
	}
}

结果
-----客户要求增加一项需求-----
找到需求组...
客户要求增加一项需求...
客户要求增加一个页面...
客户要求增加一项功能...
客户要求需求变更计划...
-----客户要求删除一项需求-----
找到美工组...
客户要求删除一个页面...
客户要求页面变更计划...
-----客户撤销删除页面需求-----
回滚页面