案例展示——Command怎么用?
现在有这样一个业务场景:外包公司接了一个大单——做一个汽车销售网站,这可把公司高兴坏了,近年来外包公司崛起,行业内竞争压力巨大,好不容易有一个大订单一定要把它做好。于是公司专门成立了一个项目小组去负责这件事,该项目小组主要由:需求组,美工组,代码组三个组组成,汽车公司那边外派了一个干员过来常驻公司,主要是和项目小组中的每个组进行沟通交流,以期能够提高效率,尽快交付使用。下面是类图设计:
代码实现如下:
//抽象组
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 class RequirementGroup extends Group {
//客户找到需求组进行讨论
public void find() {
System.out.println("找到需求组。。。");
}
//客户要求增加一项需求
public void add() {
System.out.println("客户要求增加一项需求。。。");
}
//客户要求删除一项需求
public void delete() {
System.out.println("客户要求删除一项需求。。。");
}
//客户要求修改一项需求
public void change() {
System.out.println("客户要求修改一项需求。。。");
}
//客户要求给出变更计划
public void plan() {
System.out.println("客户要求给出变更计划。。。");
}
}
//美工组
public class PageGroup extends Group {
//客户找到美工组进行讨论
public void find() {
System.out.println("找到美工组。。。");
}
//客户要求增加一个页面
public void add() {
System.out.println("客户要求增加一个页面。。。");
}
//客户要求删除一个页面
public void delete() {
System.out.println("客户要求删除一个页面。。。");
}
//客户要求修改一个页面
public void change() {
System.out.println("客户要求修改一个页面。。。");
}
//客户要求给出变更计划
public void plan() {
System.out.println("客户要求给出变更计划。。。");
}
}
//代码组
public class CodeGroup extends Group {
//客户找到代码组进行讨论
public void find() {
System.out.println("找到代码组。。。");
}
//客户要求增加一个功能
public void add() {
System.out.println("客户要求增加一个功能。。。");
}
//客户要求删除一个功能
public void delete() {
System.out.println("客户要求删除一个功能。。。");
}
//客户要求修改一个功能
public void change() {
System.out.println("客户要求修改一个功能。。。");
}
//客户要求给出变更计划
public void plan() {
System.out.println("客户要求给出变更计划。。。");
}
}
//在一个场景中实现
public class Client {
public static void main(String[] args) {
System.out.println("=======找到需求组谈需求=======");
Group group = new RequirementGroup();
group.find();
group.add();
group.plan();
System.out.println("=======找到美工组谈页面=======");
Group group2 = new RequirementGroup();
group2.find();
group2.add();
group2.plan();
System.out.println("=======找到代码组谈功能=======");
Group group3 = new RequirementGroup();
group3.find();
group3.add();
group3.plan();
}
}
//结果如下:
=======找到需求组谈需求=======
找到需求组。。。
客户要求增加一项需求。。。
客户要求给出变更计划。。。
=======找到美工组谈页面=======
找到需求组。。。
客户要求增加一项需求。。。
客户要求给出变更计划。。。
=======找到代码组谈功能=======
找到需求组。。。
客户要求增加一项需求。。。
客户要求给出变更计划。。。。
结果很令人满意,但是其过程却是很曲折,过了不久,干员找到公司领导反映情况:什么事情都需要他去操心,需求需要去找需求组,美工要找美工组,功能要找代码组,这样跑来跑去他受不了了,希望公司高层拿出一个方案来,他只负责下命令,其他的由一个代理的负责人去找各个组协商去。没办法,谁让顾客是上帝呢?于是公司高层经过几个昼夜的深思熟虑,一种新的设计方案诞生了——使用命令模式,设计类图如下:
-
Command抽象类:包装客户发送的命令,定义三个工作组的成员变量供子类使用,定义一个抽象方法 execute() 供子类实现使用
-
DeletePageCommand类和AddRequirementCommand类:继承了Command类,对客户发出的命令进行了封装,每个命令就是一个对象,避免客户,负责人,组员之间出现交流误差
-
Invoker类:项目负责人,接收客户发送的命令,将命令给Command类进行封装,使用 action() 方法执行客户的命令。
代码实现如下(给出和上面示例不同的代码):
//抽象命令类
public abstract class Command {
//定义三个组,子类直接使用
protected RequirementGroup rg = new RequirementGroup();
protected PageGroup pg = new PageGroup();
protected CodeGroup cg = new CodeGroup();
//执行命令的方法
public abstract void execute();
}
//增加需求的命令
public class AddRequirementCommand extends Command {
//执行增加一个需求的命令
public void execute() {
//找到需求组
super.rg.find();
//增加需求
super.rg.add();
//给出计划
super.rg.plan();
}
}
//删除页面的命令
public class DeletePageCommand extends Command {
//执行删除一个页面的命令
public void execute() {
//找到页面组
super.pg.find();
//删除一个页面
super.pg.delete();
//给出计划
super.pg.plan();
}
}
//负责人
public class Invoker {
//命令
private Command command;
//客户发出命令
public void setCommand(Command command) {
this.command = command;
}
//执行客户的命令
public void action() {
this.command.execute();
}
}
//在一个场景中实现
public class Client {
public static void main(String[] args) {
//定义一个负责人
Invoker tom = new Invoker();
System.out.println("=======客户要求增加一项需求=======");
//客户下命令
Command command = new AddRequirementCommand();
//负责人接收到命令
tom.setCommand(command);
//负责人执行命令
tom.action();
//定义一个负责人
Invoker jerry = new Invoker();
System.out.println("=======客户要求删除一个页面=======");
//客户下命令
Command command2 = new DeletePageCommand();
//负责人接收到命令
jerry.setCommand(command2);
//负责人执行命令
jerry.action();
}
}
//结果如下:
=======客户要求增加一项需求=======
找到需求组。。。
客户要求增加一项需求。。。
客户要求给出变更计划。。。
=======客户要求删除一个页面=======
找到美工组。。。
客户要求删除一个页面。。。
客户要求给出变更计划。。。
上面的示例使用的就是命令模式,我们发现使用了命令模式之后,职责更加清晰:客户就只管发命令,负责人负责执行命令,各个小组负责执行相应的业务逻辑;低耦合:客户端不必亲自和各小组成员直接交谈,只需要联络负责人就行;扩展性增强:如果客户端下达了新的命令,只需要新建一个类然后继承于Command类就行。
深入分析——Command是什么?
Command定义
定义: 将一个请求封装成一个对象,从而使用不同的请求把客户端参数化,对请求排队或者记录请求日志,可以提供命令的撤销和恢复功能。其通用类图如下:
通用代码实现如下:
//通用的Receiver类:接收命令
public abstract class Receiver {
//抽象接收者,定义每个接收者都必须完成的业务
public abstract void doSomething();
}
//具体的Receiver类,可以有多个:执行业务逻辑
public class ConcreteReceiver extends Receiver {
public void doSomething() {
//业务逻辑
}
}
//抽象的Command类:封装命令
public abstract class Command {
//对具体的Receiver类进行命令处理
protected ConcreteReceiver receiver = new ConcreteReceiver();
//每个命令类都必须有一个执行命令的方法
public abstract void execute();
}
//具体的Command类,可以有多个
public class ConcreteCommand extends Command {
//执行命令
public void execute() {
//业务处理
super.receiver.doSomething();
}
}
//负责人
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 = new Invoker();
//具体命令
Command command = new ConcreteCommand();
//负责人接收命令
invoker.setCommand(command);
//执行命令
invoker.action();
}
}
Command的优点
-
类间解耦: 调用角色与接收角色之间没有任何依赖关系,调用者实现功能时只需要调用Command抽象类的execute方法,不需要了解到底是哪个接收者执行
-
可扩展性: Command的子类可以非常容易的扩展,而调用者Invoker和高层次的模块Client不产生严重的代码耦合
Command的缺点
- 命令太多会导致类膨胀问题,增加了系统复杂度
参考
《设计模式之禅》