案例展示——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的缺点
- 命令太多会导致类膨胀问题，增加了系统复杂度
参考
《设计模式之禅》
扫一扫
1548
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
