好长时间没有学习设计模式了,主要是最近一直在忙德国的一个需求,现在终于可以休息下了,不过下周又要开始新的需求了。唉,不断的项目,不停的工作。 现在闲下来 回头看看设计模式,发现我们的工作模式,其实可以用 Command 的模式实现的,我们都是按 boss 的 Command 办事的,呵呵。 1. 下面先讲讲我们的工作模式吧: 首先,德国那边 boss 提出要求,然后发给德国的经理,经理按照 boss 的意思,形成具体的需求样式,然后将这些样式发给我们,我们按照需求完成任务。
Boss---------->manager------- > developer
2. 看看设计模式中对 Command 的定义吧:
书上对 Command 的定义过于复杂,个人的理解是这样的:就是将一些操作封装成 command 命令,每个命令中含有 (execute) ,然后发给接受者,接受者不管 command 的类型或者内容,只要打开 command 命令,然后安装它的意图执行 (execute) 就可以了。
安装以上的理解,一个 Command 模式应该包括以下部分:
1. Command:
2. Client: 创建一个命令,并且设定它的接受者
3. invoker :要求执行这个命令
4. Receiver :接到命令,并且按照执行。
他们之间的静态图如下:
[Command 模式类图出自: wikimedia.org]
3. 对照这个模式,就很容易将我的工作模式用这个模式实现了,下面看看整个过程吧:
很明显,我工作中的几个角色如下:
1.Command:
Requirement: 这里就是各种需求了。
2.Client: 创建一个命令,并且设定它的接受者
Boss:Boss 的作用
3.invoker :
Manager: 根据老板的意思形成命令,并交给 developer 开发
4.Receiver :接到命令,并且按照执行。
Developer: 得到需求后,找到需求的入口,然后按照这个要求一步步完成。
1. Boss 类:
public class Boss {
String order;// 用于产生命令
Manager manager;// 指定命令的接受者
public Manager getReceiver() {
return manager;
}
public void setReceiver(Manager manager) {
this.manager = manager;
}
public String getOrder() {
return order;
}
public void setOrder(String order) {
this.order = order;
}
public void orderCommand() {
manager.setOrder(order);// 给manager下达命令
}
}
2. Manager 类:
public class Manager {
String order;
Developer developer;
Requirement requirement = null;
public String getOrder() {
return order;
}
// 用于接受命令
public void setOrder(String order) {
this.order = order;
}
// 根据boss的命令 产生需求。
public void setRequirement() {
if (order.equals("A")) {
requirement = new RequirementA();
} else if (order.equals("B")) {
requirement = new RequirementB();
}
}
// 通知让developer工作
public void invoker() {
developer.setRequirement(requirement);// 告诉developer具体需求
developer.action();// 唤起developer
}
public Developer getDeveloper() {
return developer;
}
public void setDeveloper(Developer developer) {
this.developer = developer;
}
}
3. Developer 类:
public class Developer {
Requirement requirement = null;
public Requirement getRequirement() {
return requirement;
}
// 得到需求。
public void setRequirement(Requirement requirement) {
this.requirement = requirement;
}
public void action() {
requirement.execute();// 只要按照要求做就可以了。
}
}
4. Requirment 类:
public interface Requirement {
public void execute();
}
public class RequirementA implements Requirement {
private void stepFirst() {
System.out.println("stepFirst runs");
}
private void stepSecond() {
System.out.println("stepSecond runs");
}
public void execute() {
System.out.println("now operate requirementA");
// 先执行第一步,然后再执行第二步。
stepFirst();
stepSecond();
}
}
public class RequirementB implements Requirement {
private void stepFirst() {
System.out.println("stepFirst runs");
}
private void stepSecond() {
System.out.println("stepSecond runs");
}
public void execute() {
System.out.println("now operate requirementB");
// 不同于第一步
stepSecond();
stepFirst();
}
}
5. 看看测试过程吧: 这里我用的是 junit4 具体使用请参考我的另一篇文章 (junit4 快速入门 ) 。
import org.junit.Test;
import org.junit.Before;
import org.junit.After;
public class WorkflowTest {
String order = "";
Boss boss;
Developer developer;
Manager manager;
Requirement requirement;
@Before
public void init(){
boss = new Boss();
developer= new Developer();
manager = new Manager();
}
@Test
public void runRequirmentA(){
requirement = new RequirmentA();
order = "A";
//boss的工作
boss.setOrder(order);
boss.setReceiver(manager);
boss.orderCommand();
//manager的工作
manager.setDeveloper(developer);
manager.setRequirement(requirement);
manager.invoker();
}
@Test
public void runRequirmentB(){
requirement = new RequirmentB();
order = "B";
//boss的工作
boss.setOrder(order);
boss.setReceiver(manager);
boss.orderCommand();
//manager的工作
manager.setDeveloper(developer);
manager.setRequirement(requirement);
manager.invoker();
}
@After
public void destory(){
boss = null;
developer= null;
manager = null;
}
}
6. 输出结果:
now operate requirementA
stepFirst runs
stepSecond runs
now operate requirementB
stepSecond runs
stepFirst runs