我工作的那点事--设计模式实例应用(Command模式)

   好长时间没有学习设计模式了，主要是最近一直在忙德国的一个需求，现在终于可以休息下了，不过下周又要开始新的需求了。唉，不断的项目，不停的工作。现在闲下来 回头看看设计模式，发现我们的工作模式，其实可以用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(){
		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

 

 

 

层次挺清晰的！Boss------>manager----àdeveloper

这个排版太无敌了

Command模式里的concreteCommand封装的是具体的命令，是最终要执行的行为，应该只有developer才能够建立（根据需求建立具体的计划），然后由Manager调用（安排时间，人力执行，而不管具体要怎么做）

能不能把版排一下！

ls 你为什么要把这个挖出来...

command模式，除了自身依赖外，可以隔离所有的其他依赖。

模式也是方法论，感觉很多东西都是相通的

前段时间比较忙，没有时间修改。
现特重新排版，谢谢大家的关注。

不知道怎么在文章中插入图片，希望大家指点下，谢谢。