定义 Encapsulate a request as an object ,thereby letting you parameterize clients with different requests,queue or log requests,and support undoable operations.(将一个请求封装成一个对象,从而让你使用不同的请求把客户端参数化,对请求排队或者记录请求日志,可以提供命令的撤销和恢复功能)
不认识的单词 Encapsulate 封装
thereby 从而
parameterize 用参数表示,参数化
undoable 可撤销
类图
接受者Recevier:定义每个接受者要完成的任务(类似于一个工具类) Command抽象类,有一个execute方法 (类似于一个组装机器图) ConcreteCommand子类,成员为一个抽象类,execute方法时就调用接受者的方法 (类似于一个组装机器) Invoker 有一个Command成员,action方法就是执行execute方法(在我看来,这个有点多余了) 总之就是这样的,Command封装Receiver,Invoker封装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 abstract class Command {
protected RequirementGroup rg=new RequirementGroup();
protected PageGroup pg=new PageGroup();
protected CodeGroup cg=new CodeGroup();
public abstract void execute();
}
public class Invoker {
private Command command;
public void setCommand(Command command){
this.command=command;
}
public void action(){
this.command.execute();
}
}
三个子类
public class CodeGroup extends Group {
@Override
public void add() {
System.out.println("add code");
}
@Override
public void change() {
System.out.println("change code");
}
@Override
public void delete() {
System.out.println("delete code");
}
@Override
public void find() {
System.out.println("find code");
}
@Override
public void plan() {
System.out.println("plan code");
}
}
public class PageGroup extends Group {
@Override
public void add() {
System.out.println("add page");
}
@Override
public void change() {
System.out.println("change page");
}
@Override
public void delete() {
System.out.println("delete page");
}
@Override
public void find() {
System.out.println("find page");
}
@Override
public void plan() {
System.out.println("plan page");
}
}
public class RequirementGroup extends Group {
@Override
public void add() {
System.out.println("add requirement");
}
@Override
public void change() {
System.out.println("change requirement");
}
@Override
public void delete() {
System.out.println("delete requirement");
}
@Override
public void find() {
System.out.println("find requirement");
}
@Override
public void plan() {
System.out.println("plan requirement");
}
}
现在根据需要来一个一个的写命令,非常好扩展
public class AddRequirementCommand extends Command {
/**
* 执行增加一项需求的命令
*/
@Override
public void execute() {
super.rg.find();
super.rg.add();
super.rg.plan();
}
}
public class DeletePageCommand extends Command {
/**
* 删除页面的命令
*/
@Override
public void execute() {
super.pg.find();
super.rg.delete();
super.rg.plan();
}
}
好了,命令已经写好了。
如何调用呢? 直接调用这个类的execute方法不就行了吗? 为了更加体现依赖关系和系统设计特点(无论接受了什么命令,都要接受和执行),调用者和接受者没有任何依赖关系。调用者只需要调用Command抽象类的execute方法即可,不需要了解谁执行了。
public class Client {
public static void main(String[] args) {
Invoker invoker=new Invoker();
System.out.println("--------客户要求增加一项需求-------------");
Command command = new AddRequirementCommand(); //使用早就写好的东西
command.execute();
invoker.setCommand(command);
invoker.action();
}
}
/*高内聚
*调用者Invoker和接受者Group没有依赖,Command容易扩展
*缺点就是如果Command子类多的话,需要N多个的子类去一个一个实现
*/
悟: 在我看来,这个扩展性是好的,但是写的没有技术含量,因为每多一项,就需要写一个组合命令来供客户调用,同样Invoker的存在也是为了好看而已,本质是组装,加工。 和中介者不同的是这里的业务各个子类是相同的,而中介者是不同的。
优点 类间解耦 可扩展性好 缺点 类容易膨胀
我是菜鸟,我在路上。