设计模式 学习 5：

标签：

11个行为模式之5(责任链模式，命令模式，解释器模式，迭代器模式，中介者模式)

责任链模式

问题： 

 Sunny软件公司承接了某企业SCM(Supply Chain Management，供应链管理)系统的开发任务，其中包含一个采购审批子系统。该企业的采购审批是分级进行的，即根据采购金额的不同由不同层次的主管人员来审批，主任可以审批5万元以下（不包括5万元）的采购单，副董事长可以审批5万元至10万元（不包括10万元）的采购单，董事长可以审批10万元至50万元（不包括50万元）的采购单，50万元及以上的采购单就需要开董事会讨论决定。如图16-1所示：

1. /采购单：请求类  
2. class PurchaseRequest {  
3.     private double amount;  //采购金额  
4.     private int number;  //采购单编号  
5.     private String purpose;  //采购目的  
6.       
7.     public PurchaseRequest(double amount, int number, String purpose) {  
8.         this.amount = amount;  
9.         this.number = number;  
10.         this.purpose = purpose;  
11.     }  
12.       
13.     public void setAmount(double amount) {  
14.         this.amount = amount;  
15.     }  
16.       
17.     public double getAmount() {  
18.         return this.amount;  
19.     }  
20.       
21.     public void setNumber(int number) {  
22.         this.number = number;  
23.     }  
24.       
25.     public int getNumber() {  
26.         return this.number;  
27.     }  
28.       
29.     public void setPurpose(String purpose) {  
30.         this.purpose = purpose;  
31.     }  
32.       
33.     public String getPurpose() {  
34.         return this.purpose;  
35.     }  
36. }  
37.   
38. //审批者类：抽象处理者  
39. abstract class Approver {  
40.     protected Approver successor; //定义后继对象  
41.     protected String name; //审批者姓名  
42.       
43.     public Approver(String name) {  
44.         this.name = name;  
45.     }  
46.   
47.     //设置后继者  
48.     public void setSuccessor(Approver successor) {   
49.         this.successor = successor;  
50.     }  
51.   
52.     //抽象请求处理方法  
53.     public abstract void processRequest(PurchaseRequest request);  
54. }  
55.   
56. //主任类：具体处理者  
57. class Director extends Approver {  
58.     public Director(String name) {  
59.         super(name);  
60.     }  
61.       
62.     //具体请求处理方法  
63.     public void processRequest(PurchaseRequest request) {  
64.         if (request.getAmount() < 50000) {  
65.             System.out.println("主任" + this.name + "审批采购单：" + request.getNumber() + "，金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。");  //处理请求  
66.         }  
67.         else {  
68.             this.successor.processRequest(request);  //转发请求  
69.         }     
70.     }  
71. }  
72.   
73. //副董事长类：具体处理者  
74. class VicePresident extends Approver {  
75.     public VicePresident(String name) {  
76.         super(name);  
77.     }  
78.       
79.     //具体请求处理方法  
80.     public void processRequest(PurchaseRequest request) {  
81.         if (request.getAmount() < 100000) {  
82.             System.out.println("副董事长" + this.name + "审批采购单：" + request.getNumber() + "，金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。");  //处理请求  
83.         }  
84.         else {  
85.             this.successor.processRequest(request);  //转发请求  
86.         }     
87.     }  
88. }  
89.   
90. //董事长类：具体处理者  
91. class President extends Approver {  
92.     public President(String name) {  
93.         super(name);  
94.     }  
95.       
96.     //具体请求处理方法  
97.     public void processRequest(PurchaseRequest request) {  
98.         if (request.getAmount() < 500000) {  
99.             System.out.println("董事长" + this.name + "审批采购单：" + request.getNumber() + "，金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。");  //处理请求  
100.         }  
101.         else {  
102.             this.successor.processRequest(request);  //转发请求  
103.         }  
104.     }  
105. }  
106.   
107. //董事会类：具体处理者  
108. class Congress extends Approver {  
109.     public Congress(String name) {  
110.         super(name);  
111.     }  
112.       
113.     //具体请求处理方法  
114.     public void processRequest(PurchaseRequest request) {  
115.         System.out.println("召开董事会审批采购单：" + request.getNumber() + "，金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。");        //处理请求  
116.     }      
117. }  

      编写如下客户端测试代码： 

1. class Client {  
2.     public static void main(String[] args) {  
3.         Approver wjzhang,gyang,jguo,meeting;  
4.         wjzhang = new Director("张无忌");  
5.         gyang = new VicePresident("杨过");  
6.         jguo = new President("郭靖");  
7.         meeting = new Congress("董事会");  
8.       
9.         //创建职责链  
10.         wjzhang.setSuccessor(gyang);  
11.         gyang.setSuccessor(jguo);  
12.         jguo.setSuccessor(meeting);  
13.           
14.         //创建采购单  
15.         PurchaseRequest pr1 = new PurchaseRequest(45000,10001,"购买倚天剑");  
16.         wjzhang.processRequest(pr1);  
17.           
18.         PurchaseRequest pr2 = new PurchaseRequest(60000,10002,"购买《葵花宝典》");  
19.         wjzhang.processRequest(pr2);  
20.       
21.         PurchaseRequest pr3 = new PurchaseRequest(160000,10003,"购买《金刚经》");  
22.         wjzhang.processRequest(pr3);  
23.   
24.         PurchaseRequest pr4 = new PurchaseRequest(800000,10004,"购买桃花岛");  
25.         wjzhang.processRequest(pr4);  
26.     }  
27. }   

命令模式

Sunny软件公司开发人员为公司内部OA系统开发了一个桌面版应用程序，该应用程序为用户提供了一系列自定义功能键，用户可以通过这些功能键来实现一些快捷操作。Sunny软件公司开发人员通过分析，发现不同的用户可能会有不同的使用习惯，在设置功能键的时候每个人都有自己的喜好，例如有的人喜欢将第一个功能键设置为“打开帮助文档”，有的人则喜欢将该功能键设置为“最小化至托盘”，为了让用户能够灵活地进行功能键的设置，开发人员提供了一个“功能键设置”窗口，该窗口界面如图2所示：

通过如图2所示界面，用户可以将功能键和相应功能绑定在一起，还可以根据需要来修改功能键的设置，而且系统在未来可能还会增加一些新的功能或功能键。

1. import java.util.*;  
2.   
3. //功能键设置窗口类  
4. class FBSettingWindow {  
5.     private String title; //窗口标题  
6.     //定义一个ArrayList来存储所有功能键  
7.     private ArrayList<FunctionButton> functionButtons = new ArrayList<FunctionButton>();  
8.       
9.     public FBSettingWindow(String title) {  
10.         this.title = title;  
11.     }  
12.       
13.     public void setTitle(String title) {  
14.         this.title = title;  
15.     }  
16.       
17.     public String getTitle() {  
18.         return this.title;  
19.     }  
20.       
21.     public void addFunctionButton(FunctionButton fb) {  
22.         functionButtons.add(fb);  
23.     }  
24.       
25.     public void removeFunctionButton(FunctionButton fb) {  
26.         functionButtons.remove(fb);  
27.     }  
28.       
29.     //显示窗口及功能键  
30.     public void display() {  
31.         System.out.println("显示窗口：" + this.title);  
32.         System.out.println("显示功能键：");  
33.         for (Object obj : functionButtons) {  
34.             System.out.println(((FunctionButton)obj).getName());  
35.         }  
36.         System.out.println("------------------------------");  
37.     }     
38. }  
39.   
40. //功能键类：请求发送者  
41. class FunctionButton {  
42.     private String name; //功能键名称  
43.     private Command command; //维持一个抽象命令对象的引用  
44.       
45.     public FunctionButton(String name) {  
46.         this.name = name;  
47.     }  
48.       
49.     public String getName() {  
50.         return this.name;  
51.     }  
52.       
53.     //为功能键注入命令  
54.     public void setCommand(Command command) {  
55.         this.command = command;  
56.     }  
57.       
58.     //发送请求的方法  
59.     public void onClick() {  
60.         System.out.print("点击功能键：");  
61.         command.execute();  
62.     }  
63. }  
64.   
65. //抽象命令类  
66. abstract class Command {  
67.     public abstract void execute();  
68. }  
69.   
70. //帮助命令类：具体命令类  
71. class HelpCommand extends Command {  
72.     private HelpHandler hhObj; //维持对请求接收者的引用  
73.       
74.     public HelpCommand() {  
75.         hhObj = new HelpHandler();  
76.     }  
77.       
78.     //命令执行方法，将调用请求接收者的业务方法  
79.     public void execute() {  
80.         hhObj.display();  
81.     }  
82. }  
83.   
84. //最小化命令类：具体命令类  
85. class MinimizeCommand extends Command {  
86.     private WindowHanlder whObj; //维持对请求接收者的引用  
87.       
88.     public MinimizeCommand() {  
89.         whObj = new WindowHanlder();  
90.     }  
91.       
92. //命令执行方法，将调用请求接收者的业务方法  
93.     public void execute() {  
94.         whObj.minimize();  
95.     }  
96. }  
97.   
98. //窗口处理类：请求接收者  
99. class WindowHanlder {  
100.     public void minimize() {  
101.         System.out.println("将窗口最小化至托盘！");  
102.     }  
103. }  
104.   
105. //帮助文档处理类：请求接收者  
106. class HelpHandler {  
107.     public void display() {  
108.         System.out.println("显示帮助文档！");  
109.     }  
110. }  

       为了提高系统的灵活性和可扩展性，我们将具体命令类的类名存储在配置文件中，并通过工具类XMLUtil来读取配置文件并反射生成对象，XMLUtil类的代码如下所示：

[java] view plain copy

1. import javax.xml.parsers.*;  
2. import org.w3c.dom.*;  
3. import org.xml.sax.SAXException;  
4. import java.io.*;  
5.   
6. public class XMLUtil {  
7. //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象，可以通过参数的不同返回不同类名节点所对应的实例  
8.     public static Object getBean(int i) {  
9.         try {  
10.             //创建文档对象  
11.             DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();  
12.             DocumentBuilder builder = dFactory.newDocumentBuilder();  
13.             Document doc;                             
14.             doc = builder.parse(new File("config.xml"));   
15.           
16.             //获取包含类名的文本节点  
17.             NodeList nl = doc.getElementsByTagName("className");  
18.             Node classNode = null;  
19.             if (0 == i) {  
20.                 classNode = nl.item(0).getFirstChild();  
21.             }  
22.             else {  
23.                 classNode = nl.item(1).getFirstChild();  
24.             }   
25.   
26.             String cName = classNode.getNodeValue();  
27.               
28.             //通过类名生成实例对象并将其返回  
29.             Class c = Class.forName(cName);  
30.             Object obj = c.newInstance();  
31.             return obj;  
32.         }     
33.         catch(Exception e){  
34.             e.printStackTrace();  
35.             return null;  
36.         }  
37.     }  
38. }  

       配置文件config.xml中存储了具体建造者类的类名，代码如下所示：

[java] view plain copy

1. <?xml version="1.0"?>  
2. <config>  
3.     <className>HelpCommand</className>  
4.     <className>MinimizeCommand</className>  
5. </config>  

       编写如下客户端测试代码：

1. class Client {  
2.     public static void main(String args[]) {  
3.         FBSettingWindow fbsw = new FBSettingWindow("功能键设置");  
4.               
5.         FunctionButton fb1,fb2;  
6.         fb1 = new FunctionButton("功能键1");  
7.         fb2 = new FunctionButton("功能键1");  
8.           
9.         Command command1,command2;  
10.         //通过读取配置文件和反射生成具体命令对象  
11.         command1 = (Command)XMLUtil.getBean(0);  
12.         command2 = (Command)XMLUtil.getBean(1);  
13.           
14.         //将命令对象注入功能键  
15.         fb1.setCommand(command1);  
16.         fb2.setCommand(command2);  
17.           
18.         fbsw.addFunctionButton(fb1);  
19.         fbsw.addFunctionButton(fb2);  
20.         fbsw.display();  
21.           
22.         //调用功能键的业务方法  
23.         fb1.onClick();  
24.         fb2.onClick();  
25.     }  
26. }  

解释器模式

  Sunny软件公司欲为某玩具公司开发一套机器人控制程序，在该机器人控制程序中包含一些简单的英文控制指令，每一个指令对应一个表达式(expression)，该表达式可以是简单表达式也可以是复合表达式，每一个简单表达式由移动方向(direction)，移动方式(action)和移动距离(distance)三部分组成，其中移动方向包括上(up)、下(down)、左(left)、右(right)；移动方式包括移动(move)和快速移动(run)；移动距离为一个正整数。两个表达式之间可以通过与(and)连接，形成复合(composite)表达式。

       用户通过对图形化的设置界面进行操作可以创建一个机器人控制指令，机器人在收到指令后将按照指令的设置进行移动，例如输入控制指令：up move 5，则“向上移动5个单位”；输入控制指令：down  run 10 and left move 20，则“向下快速移动10个单位再向左移动20个单位”。

1. //在本实例中，为了详细说明自定义迭代器的实现过程，我们没有使用JDK中内置的迭代器，事实上，JDK内置迭代器已经实现了对一个List对象的正向遍历  
2. import java.util.*;  
3.   
4. //抽象聚合类  
5. abstract class AbstractObjectList {  
6.     protected List<Object> objects = new ArrayList<Object>();  
7.   
8.     public AbstractObjectList(List objects) {  
9.         this.objects = objects;  
10.     }  
11.       
12.     public void addObject(Object obj) {  
13.         this.objects.add(obj);  
14.     }  
15.       
16.     public void removeObject(Object obj) {  
17.         this.objects.remove(obj);  
18.     }  
19.       
20.     public List getObjects() {  
21.         return this.objects;  
22.     }  
23.       
24.     //声明创建迭代器对象的抽象工厂方法  
25.     public abstract AbstractIterator createIterator();  
26. }  
27.   
28. //商品数据类：具体聚合类  
29. class ProductList extends AbstractObjectList {  
30.     public ProductList(List products) {  
31.         super(products);  
32.     }  
33.       
34.     //实现创建迭代器对象的具体工厂方法  
35.     public AbstractIterator createIterator() {  
36.         return new ProductIterator(this);  
37.     }  
38. }   
39.   
40. //抽象迭代器  
41. interface AbstractIterator {  
42.     public void next(); //移至下一个元素  
43.     public boolean isLast(); //判断是否为最后一个元素  
44.     public void previous(); //移至上一个元素  
45.     public boolean isFirst(); //判断是否为第一个元素  
46.     public Object getNextItem(); //获取下一个元素  
47.     public Object getPreviousItem(); //获取上一个元素  
48. }  
49.   
50. //商品迭代器：具体迭代器  
51. class ProductIterator implements AbstractIterator {  
52.     private ProductList productList;  
53.     private List products;  
54.     private int cursor1; //定义一个游标，用于记录正向遍历的位置  
55.     private int cursor2; //定义一个游标，用于记录逆向遍历的位置  
56.       
57.     public ProductIterator(ProductList list) {  
58.         this.productList = list;  
59.         this.products = list.getObjects(); //获取集合对象  
60.         cursor1 = 0; //设置正向遍历游标的初始值  
61.         cursor2 = products.size() -1; //设置逆向遍历游标的初始值  
62.     }  
63.       
64.     public void next() {  
65.         if(cursor1 < products.size()) {  
66.             cursor1++;  
67.         }  
68.     }  
69.       
70.     public boolean isLast() {  
71.         return (cursor1 == products.size());  
72.     }  
73.       
74.     public void previous() {  
75.         if (cursor2 > -1) {  
76.             cursor2--;  
77.         }  
78.     }  
79.       
80.     public boolean isFirst() {  
81.         return (cursor2 == -1);  
82.     }  
83.       
84.     public Object getNextItem() {  
85.         return products.get(cursor1);  
86.     }   
87.           
88.     public Object getPreviousItem() {  
89.         return products.get(cursor2);  
90.     }     
91. }  

       编写如下客户端测试代码：

1. class Client {  
2.     public static void main(String args[]) {  
3.         List products = new ArrayList();  
4.         products.add("倚天剑");  
5.         products.add("屠龙刀");  
6.         products.add("断肠草");  
7.         products.add("葵花宝典");  
8.         products.add("四十二章经");  
9.               
10.         AbstractObjectList list;  
11.         AbstractIterator iterator;  
12.           
13.         list = new ProductList(products); //创建聚合对象  
14.         iterator = list.createIterator();   //创建迭代器对象  
15.           
16.         System.out.println("正向遍历：");      
17.         while(!iterator.isLast()) {  
18.             System.out.print(iterator.getNextItem() + "，");  
19.             iterator.next();  
20.         }  
21.         System.out.println();  
22.         System.out.println("-----------------------------");  
23.         System.out.println("逆向遍历：");  
24.         while(!iterator.isFirst()) {  
25.             System.out.print(iterator.getPreviousItem() + "，");  
26.             iterator.previous();  
27.         }  
28.     }  
29. ｝

使用内部类实现迭代器

1. //商品数据类：具体聚合类  
2. class ProductList extends AbstractObjectList {  
3.     public ProductList(List products) {  
4.         super(products);  
5.     }  
6.       
7.     public AbstractIterator createIterator() {  
8.         return new ProductIterator();  
9.     }  
10.       
11.     //商品迭代器：具体迭代器，内部类实现  
12.     private class ProductIterator implements AbstractIterator {  
13.         private int cursor1;  
14.         private int cursor2;  
15.           
16.         public ProductIterator() {  
17.             cursor1 = 0;  
18.             cursor2 = objects.size() -1;  
19.         }  
20.           
21.         public void next() {  
22.             if(cursor1 < objects.size()) {  
23.                 cursor1++;  
24.             }  
25.         }  
26.           
27.         public boolean isLast() {  
28.             return (cursor1 == objects.size());  
29.         }  
30.           
31.         public void previous() {  
32.             if(cursor2 > -1) {  
33.                 cursor2--;  
34.             }  
35.         }  
36.           
37.         public boolean isFirst() {  
38.             return (cursor2 == -1);  
39.         }  
40.           
41.         public Object getNextItem() {  
42.             return objects.get(cursor1);  
43.         }   
44.               
45.         public Object getPreviousItem() {  
46.             return objects.get(cursor2);  
47.         }     
48.     }  
49. }  

中介者模式

  Sunny软件公司欲开发一套CRM系统，其中包含一个客户信息管理模块，所设计的“客户信息管理窗口”界面效果图如图20-2所示：   Sunny公司开发人员通过分析发现，在图20-2中，界面组件之间存在较为复杂的交互关系：如果删除一个客户，要在客户列表(List)中删掉对应的项，客户选择组合框(ComboBox)中客户名称也将减少一个；如果增加一个客户信息，客户列表中需增加一个客户，且组合框中也将增加一项。如果实现界面组件之间的交互是Sunny公司开发人员必须面对的一个问题？

解决：

1. abstract class Mediator {  
2.     public abstract void componentChanged(Component c);  
3. }  
4.   
5. //具体中介者  
6. class ConcreteMediator extends Mediator {  
7.     //维持对各个同事对象的引用  
8.     public Button addButton;  
9.     public List list;  
10.     public TextBox userNameTextBox;  
11.     public ComboBox cb;  
12.   
13.     //封装同事对象之间的交互  
14.     public void componentChanged(Component c) {  
15.         //单击按钮  
16. if(c == addButton) {  
17.             System.out.println("--单击增加按钮--");  
18.             list.update();  
19.             cb.update();  
20.             userNameTextBox.update();  
21.         }  
22.         //从列表框选择客户  
23.         else if(c == list) {  
24.             System.out.println("--从列表框选择客户--");  
25.             cb.select();  
26.             userNameTextBox.setText();  
27.         }  
28.         //从组合框选择客户  
29.         else if(c == cb) {  
30.             System.out.println("--从组合框选择客户--");  
31.             cb.select();  
32.             userNameTextBox.setText();  
33.         }  
34.     }  
35. }  
36.   
37. //抽象组件类：抽象同事类  
38. abstract class Component {  
39.     protected Mediator mediator;  
40.       
41.     public void setMediator(Mediator mediator) {  
42.         this.mediator = mediator;  
43.     }  
44.   
45.     //转发调用  
46.     public void changed() {  
47.         mediator.componentChanged(this);  
48.     }  
49.       
50.     public abstract void update();    
51. }  
52.   
53. //按钮类：具体同事类  
54. class Button extends Component {  
55.     public void update() {  
56.         //按钮不产生交互  
57.     }  
58. }  
59.   
60. //列表框类：具体同事类  
61. class List extends Component {  
62.     public void update() {  
63.         System.out.println("列表框增加一项：张无忌。");  
64.     }  
65.       
66.     public void select() {  
67.         System.out.println("列表框选中项：小龙女。");  
68.     }  
69. }  
70.   
71. //组合框类：具体同事类  
72. class ComboBox extends Component {  
73.     public void update() {  
74.         System.out.println("组合框增加一项：张无忌。");  
75.     }  
76.       
77.     public void select() {  
78.         System.out.println("组合框选中项：小龙女。");  
79.     }  
80. }  
81.   
82. //文本框类：具体同事类  
83. class TextBox extends Component {  
84.     public void update() {  
85.         System.out.println("客户信息增加成功后文本框清空。");  
86.     }  
87.       
88.     public void setText() {  
89.         System.out.println("文本框显示：小龙女。");  
90.     }  
91. }  

      编写如下客户端测试代码：

1. class Client {  
2.     public static void main(String args[]) {  
3.         //定义中介者对象  
4.         ConcreteMediator mediator;  
5.         mediator = new ConcreteMediator();  
6.           
7.         //定义同事对象  
8.         Button addBT = new Button();  
9.         List list = new List();  
10.         ComboBox cb = new ComboBox();  
11.         TextBox userNameTB = new TextBox();  
12.   
13.         addBT.setMediator(mediator);  
14.         list.setMediator(mediator);  
15.         cb.setMediator(mediator);  
16.         userNameTB.setMediator(mediator);  
17.   
18.         mediator.addButton = addBT;  
19.         mediator.list = list;  
20.         mediator.cb = cb;  
21.         mediator.userNameTextBox = userNameTB;  
22.           
23.         addBT.changed();  
24.         System.out.println("-----------------------------");  
25.         list.changed();  
26.     }  
27. }  

设计模式 学习 5：

标签：

原文地址：http://blog.csdn.net/xiaoliuliu2050/article/details/51226110