好长时间没有学习设计模式了,主要是最近一直在忙德国的一个需求,现在终于可以休息下了,不过下周又要开始新的需求了。唉,不断的项目,不停的工作。
现在闲下来 回头看看设计模式,发现我们的工作模式,其实可以用Command的模式实现的,我们都是按boss的Command办事的,呵呵。 [@more@]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
来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/9879276/viewspace-993567/,如需转载,请注明出处,否则将追究法律责任。
转载于:http://blog.itpub.net/9879276/viewspace-993567/