好长时间没有学习设计模式了，主要是最近一直在忙德国的一个需求，现在终于可以休息下了，不过下周又要开始新的需求了。唉，不断的项目，不停的工作。

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();

}

//需求A

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(){

order = "A";

//boss的工作

boss.setOrder(order);

boss.setReceiver(manager);

boss.orderCommand();

//manager的工作

manager.setDeveloper(developer);

manager.setRequirement();

manager.invoker();

}

@Test

public void runRequirmentB(){

order = "B";

//boss的工作

boss.setOrder(order);

boss.setReceiver(manager);

boss.orderCommand();

//manager的工作

manager.setDeveloper(developer);

manager.setRequirement();

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