JAVA设计模式(17) —<行为型>责任链模式(Chain of Responsibility)

1 定义：

责任链模式(Chain of Responsibility)

Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.(使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。)

职责链将请求的发送者和请求的处理者解耦，这就是职责链的设计动机。

Web应用开发中创建一个过滤器(Filter)链来对请求数据进行过滤，在工作流系统中实现公文的分级审批等等，使用职责链模式可以较好地解决此类问题。

1.1 通用类图：

 在职责链模式结构图中包含如下几个角色：

      ● 抽象处理者(Handler)：它定义了一个处理请求的接口，一般设计为抽象类，由于不同的具体处理者处理请求的方式不同，因此在其中定义了抽象请求处理方法。因为每一个处理者的下家还是一个处理者，因此在抽象处理者中定义了一个抽象处理者类型的对象（如结构图中的successor），作为其对下家的引用。通过该引用，处理者可以连成一条链。

      ● 具体处理者(ConcreteHandler)：它是抽象处理者的子类，可以处理用户请求，在具体处理者类中实现了抽象处理者中定义的抽象请求处理方法，在处理请求之前需要进行判断，看是否有相应的处理权限，如果可以处理请求就处理它，否则将请求转发给后继者；在具体处理者中可以访问链中下一个对象，以便请求的转发。

      在职责链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织链和分配责任。

      需要注意的是，职责链模式并不创建职责链，职责链的创建工作必须由系统的其他部分来完成，一般是在使用该职责链的客户端中创建职责链。职责链模式降低了请求的发送端和接收端之间的耦合，使多个对象都有机会处理这个请求。 

1.2 通用代码：

[java]  view plain copy

1.      * @author cbf4Life cbf4life@126.com I'm glad to share my knowledge with you 
2.      *         all. 
3.      */  
4.     public abstract class Handler {  
5.         private Handler nextHandler;  
6.   
7.         // 每个处理者都必须对请求做出处理  
8.         public final Response handlerMessage(Request request) {  
9.             Response response = null;  
10.             // 判断是否是自己的处理级别  
11.             if (this.getHandlerLevel().equals(request.getRequestLevel())) {  
12.                 response = this.echo(request);  
13.             } else { // 不属于自己的处理级别  
14.                 // 判断是否有下一个处理者  
15.                 if (this.nextHandler != null) {  
16.                     response = this.nextHandler.handlerMessage(request);  
17.                 } else {  
18.                     // 没有适当的处理者，业务自行处理  
19.                 }  
20.             }  
21.             return response;  
22.         }  
23.   
24.         // 设置下一个处理者是谁  
25.         public void setNext(Handler _handler) {  
26.             this.nextHandler = _handler;  
27.         }  
28.   
29.         // 每个处理者都有一个处理级别  
30.         protected abstract Level getHandlerLevel();  
31.   
32.         // 每个处理者都必须实现处理任务  
33.         protected abstract Response echo(Request request);  
34.     }  
35.   
36.     // 抽象的处理者实现三个职责：一是定义一个请求的处理方法handleMessage,唯一对外开放的方法；二是定义一个链的编排方法setNext，设置下一个处理者；三是定                                     义了具体的请求者必须实现的两个方法：定义自己能够处理的级别与具体的处理任务。  
37.     public class ConcreteHandler1 extends Handler {  
38.         // 定义自己的处理逻辑  
39.         protected Response echo(Request request) {  
40.             // 完成处理逻辑  
41.             return null;  
42.         }  
43.   
44.         // 设置自己的处理级别  
45.         protected Level getHandlerLevel() {  
46.             // 设置自己的处理级别  
47.             return null;  
48.         }  
49.     }  
50.   
51.     public class ConcreteHandler2 extends Handler {  
52.         // 定义自己的处理逻辑  
53.         protected Response echo(Request request) {  
54.             // 完成处理逻辑  
55.             return null;  
56.         }  
57.   
58.         // 设置自己的处理级别  
59.         protected Level getHandlerLevel() {  
60.             // 设置自己的处理级别  
61.             return null;  
62.         }  
63.     }  
64.   
65.     public class ConcreteHandler3 extends Handler {  
66.         // 定义自己的处理逻辑  
67.         protected Response echo(Request request) {  
68.             // 完成处理逻辑  
69.             return null;  
70.         }  
71.   
72.         // 设置自己的处理级别  
73.         protected Level getHandlerLevel() {  
74.             // 设置自己的处理级别  
75.             return null;  
76.         }  
77.     }  
78.   
79.     public class Level {  
80.         // 定义一个请求和处理等级  
81.     }  
82.   
83.     public class Request {  
84.         // 请求的等级  
85.         public Level getRequestLevel() {  
86.             return null;  
87.         }  
88.     }  
89.   
90.     public class Response {  
91.         // 处理者返回的数据  
92.     }  
93.   
94.     public class Client {  
95.         public static void main(String[] args) {  
96.             // 声明出所有的处理节点  
97.             Handler handler1 = new ConcreteHandler1();  
98.             Handler handler2 = new ConcreteHandler2();  
99.             Handler handler3 = new ConcreteHandler3();  
100.             // 设置链中的阶段顺序,1-->2-->3  
101.             handler1.setNext(handler2);  
102.             handler2.setNext(handler3);  
103.             // 提交请求，返回结果  
104.             Response response = handler1.handlerMessage(new Request());  
105.         }  
106.     }  

在实际应用中，一般会有一个封装类对责任模式进行封装，也就是替代Client类，直接返回链中第一个处理者，具体链的设置不需要高层次模块关系，这样更简化了高层次模块的调用，减少模块间的耦合，提高系统的灵活性。

2 优点

1、降低耦合度。它将请求的发送者和接受者解耦。           

2、简化了对象。使得对象不需要知道链的结构。           

3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。           

4、增加新的请求处理类很方便。

3 缺点

1、不能保证请求一定被接收。          

 2、系统性能将受到一定影响，而且在进行代码调试时不太方便；可能会造成循环调用。           

3、可能不容易观察运行时的特征，有碍于除错。

4 应用场景

• 有多个对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。
• 你想在不明确接收者的情况下，向多个对象中的一个提交一个请求。
• 可处理一个请求的对象集合应被动态指定。

5 注意事项

5.1 链长需要控制，应避免出现超长链的情况；

6 扩展

6.1纯与不纯的职责链模式

职责链模式可分为纯的职责链模式和不纯的职责链模式两种：

 

       (1) 纯的职责链模式

      一个纯的职责链模式要求一个具体处理者对象只能在两个行为中选择一个：要么承担全部责任，要么将责任推给下家，不允许出现某一个具体处理者对象在承担了一部分或全部责任后又将责任向下传递的情况。而且在纯的职责链模式中，要求一个请求必须被某一个处理者对象所接收，不能出现某个请求未被任何一个处理者对象处理的情况。在前面的采购单审批实例中应用的是纯的职责链模式。

 

       (2)不纯的职责链模式

      在一个不纯的职责链模式中允许某个请求被一个具体处理者部分处理后再向下传递，或者一个具体处理者处理完某请求后其后继处理者可以继续处理该请求，而且一个请求可以最终不被任何处理者对象所接收。Java AWT 1.0中的事件处理模型应用的是不纯的职责链模式，其基本原理如下：由于窗口组件（如按钮、文本框等）一般都位于容器组件中，因此当事件发生在某一个组件上时，先通过组件对象的handleEvent()方法将事件传递给相应的事件处理方法，该事件处理方法将处理此事件，然后决定是否将该事件向上一级容器组件传播；上级容器组件在接到事件之后可以继续处理此事件并决定是否继续向上级容器组件传播，如此反复，直到事件到达顶层容器组件为止；如果一直传到最顶层容器仍没有处理方法，则该事件不予处理。每一级组件在接收到事件时，都可以处理此事件，而不论此事件是否在上一级已得到处理，还存在事件未被处理的情况。显然，这就是不纯的职责链模式，早期的Java AWT事件模型(JDK 1.0及更早)中的这种事件处理机制又叫事件浮升(Event Bubbling)机制。从Java.1.1以后，JDK使用观察者模式代替职责链模式来处理事件。目前，在JavaScript中仍然可以使用这种事件浮升机制来进行事件处理。

7 范例

7.1学生请假

请假：3天以下辅导员签字、3到5天系主任签字、6到10天院长签字、11-15天校长签字、15天以上不允签字。

       首先是请假条：LeaveNode.java

[java]  view plain copy print ?

1. public class LeaveNode {  
2.     /** 请假天数 **/  
3.     private  int number;  
4.       
5.     /** 请假人 **/  
6.     private String person;  
7.       
8.     public LeaveNode(String person,int number){  
9.         this.person = person;  
10.         this.number = number;  
11.     }  
12.   
13.     public int getNumber() {  
14.         return number;  
15.     }  
16.   
17.     public void setNumber(int number) {  
18.         this.number = number;  
19.     }  
20.   
21.     public String getPerson() {  
22.         return person;  
23.     }  
24.   
25.     public void setPerson(String person) {  
26.         this.person = person;  
27.     }  
28. }  

       抽象处理者：Leader.java

[java]  view plain copy print ?

1. public abstract class Leader {  
2.     /** 姓名 **/  
3.     public String name;  
4.       
5.     /** 后继者 **/  
6.     protected Leader successor;  
7.       
8.     public Leader(String name){  
9.         this.name = name;  
10.     }  
11.   
12.     public void setSuccessor(Leader successor) {  
13.         this.successor = successor;  
14.     }  
15.       
16.     public abstract void handleRequest(LeaveNode LeaveNode);  
17. }  

       四个具体处理者：辅导员：Instructor.java

[java]  view plain copy print ?

1. public class Instructor extends Leader{  
2.   
3.     public Instructor(String name){  
4.         super(name);  
5.     }  
6.       
7.     public void handleRequest(LeaveNode LeaveNode) {  
8.         if(LeaveNode.getNumber() <= 3){   //小于3天辅导员审批  
9.             System.out.println("辅导员" + name + "审批" +LeaveNode.getPerson() + "同学的请假条,请假天数为" + LeaveNode.getNumber() + "天。");  
10.         }  
11.         else{     //否则传递给系主任  
12.             if(this.successor != null){  
13.                 this.successor.handleRequest(LeaveNode);  
14.             }  
15.         }  
16.     }  
17.   
18. }  

       系主任： DepartmentHead.java

[java]  view plain copy print ?

1. public class DepartmentHead extends Leader{  
2.   
3.     public DepartmentHead(String name) {  
4.         super(name);  
5.     }  
6.   
7.     public void handleRequest(LeaveNode LeaveNode) {  
8.         if(LeaveNode.getNumber() <= 7){   //小于7天系主任审批  
9.             System.out.println("系主任" + name + "审批" +LeaveNode.getPerson() + "同学的请假条,请假天数为" + LeaveNode.getNumber() + "天。");  
10.         }  
11.         else{     //否则传递给院长  
12.             if(this.successor != null){  
13.                 this.successor.handleRequest(LeaveNode);  
14.             }  
15.         }  
16.     }  
17. }  

       院长：Dean.java

[java]  view plain copy print ?

1. public class Dean extends Leader{  
2.   
3.     public Dean(String name) {  
4.         super(name);  
5.     }  
6.   
7.     public void handleRequest(LeaveNode LeaveNode) {  
8.         if(LeaveNode.getNumber() <= 10){   //小于10天院长审批  
9.             System.out.println("院长" + name + "审批" +LeaveNode.getPerson() + "同学的请假条,请假天数为" + LeaveNode.getNumber() + "天。");  
10.         }  
11.         else{     //否则传递给校长  
12.             if(this.successor != null){  
13.                 this.successor.handleRequest(LeaveNode);  
14.             }  
15.         }  
16.     }  
17.   
18. }  

       校长：President.java

[java]  view plain copy print ?

1. public class President extends Leader{  
2.   
3.     public President(String name) {  
4.         super(name);  
5.     }  
6.   
7.     public void handleRequest(LeaveNode LeaveNode) {  
8.         if(LeaveNode.getNumber() <= 15){   //小于15天校长长审批  
9.             System.out.println("校长" + name + "审批" +LeaveNode.getPerson() + "同学的请假条,请假天数为" + LeaveNode.getNumber() + "天。");  
10.         }  
11.         else{     //否则不允批准  
12.             System.out.println("请假天天超过15天,不批准...");  
13.         }  
14.     }  
15.   
16. }  

       客户端：Client.java

[java]  view plain copy print ?

1. public class Client {  
2.     public static void main(String[] args) {  
3.         Leader instructor = new Instructor("陈毅");       //辅导员  
4.         Leader departmentHead = new DepartmentHead("王明");    //系主任  
5.         Leader dean = new Dean("张强");      //院长  
6.         Leader president = new President("王晗");     //校长  
7.           
8.         instructor.setSuccessor(departmentHead);       //辅导员的后续者是系主任  
9.         departmentHead.setSuccessor(dean);             //系主任的后续者是院长  
10.         dean.setSuccessor(president);                  //院长的后续者是校长  
11.           
12.         //请假3天的请假条  
13.         LeaveNode leaveNode1 = new LeaveNode("张三", 3);  
14.         instructor.handleRequest(leaveNode1);       
15.           
16.         //请假9天的请假条  
17.         LeaveNode leaveNode2 = new LeaveNode("李四", 9);  
18.         instructor.handleRequest(leaveNode2);  
19.           
20.         //请假15天的请假条  
21.         LeaveNode leaveNode3 = new LeaveNode("王五", 15);  
22.         instructor.handleRequest(leaveNode3);  
23.           
24.         //请假20天的请假条  
25.         LeaveNode leaveNode4 = new LeaveNode("赵六", 20);  
26.         instructor.handleRequest(leaveNode4);  
27.     }  
28. }  

       运行结果：

7.2采购单的分级审批

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

      如何在软件中实现采购单的分级审批？Sunny软件公司开发人员提出了一个初始解决方案，在系统中提供一个采购单处理类PurchaseRequestHandler用于统一处理采购单，其框架代码如下所示：

[java]  view plain copy

1. //采购单处理类  
2. class PurchaseRequestHandler {  
3.     //递交采购单给主任  
4.     public void sendRequestToDirector(PurchaseRequest request) {  
5.         if (request.getAmount() < 50000) {  
6.             //主任可审批该采购单  
7.             this.handleByDirector(request);  
8.         }  
9.         else if (request.getAmount() < 100000) {  
10.             //副董事长可审批该采购单  
11.             this.handleByVicePresident(request);  
12.         }  
13.         else if (request.getAmount() < 500000) {  
14.             //董事长可审批该采购单  
15.             this.handleByPresident(request);  
16.         }  
17.         else {  
18.             //董事会可审批该采购单  
19.             this.handleByCongress(request);  
20.         }  
21.     }  
22.       
23.     //主任审批采购单  
24.     public void handleByDirector(PurchaseRequest request) {  
25.         //代码省略  
26.     }  
27.       
28.     //副董事长审批采购单  
29.     public void handleByVicePresident(PurchaseRequest request) {  
30.         //代码省略  
31.     }  
32.       
33.     //董事长审批采购单  
34.     public void handleByPresident(PurchaseRequest request) {  
35.         //代码省略  
36.     }  
37.       
38.     //董事会审批采购单  
39.     public void handleByCongress(PurchaseRequest request) {  
40.         //代码省略  
41.     }  
42. }  

        问题貌似很简单，但仔细分析，发现上述方案存在如下几个问题：

       (1)PurchaseRequestHandler类较为庞大，各个级别的审批方法都集中在一个类中，违反了“单一职责原则”，测试和维护难度大。

       (2)如果需要增加一个新的审批级别或调整任何一级的审批金额和审批细节（例如将董事长的审批额度改为60万元）时都必须修改源代码并进行严格测试，此外，如果需要移除某一级别（例如金额为10万元及以上的采购单直接由董事长审批，不再设副董事长一职）时也必须对源代码进行修改，违反了“开闭原则”。

       (3)审批流程的设置缺乏灵活性，现在的审批流程是“主任-->副董事长-->董事长-->董事会”，如果需要改为“主任-->董事长-->董事会”，在此方案中只能通过修改源代码来实现，客户端无法定制审批流程。

       如何针对上述问题对系统进行改进？Sunny公司开发人员迫切需要一种新的设计方案，还好有职责链模式，通过使用职责链模式我们可以最大程度地解决这些问题，下面让我们正式进入职责链模式的学习。

完整解决方案

      为了让采购单的审批流程更加灵活，并实现采购单的链式传递和处理，Sunny公司开发人员使用职责链模式来实现采购单的分级审批，其基本结构如图16-3所示：

        在图16-3中，抽象类Approver充当抽象处理者（抽象传递者），Director、VicePresident、President和Congress充当具体处理者（具体传递者），PurchaseRequest充当请求类。完整代码如下所示：

[java]  view plain copy

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. }  

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

[java]  view plain copy

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. }   

       编译并运行程序，输出结果如下：

主任张无忌审批采购单：10001，金额：45000.0元，采购目的：购买倚天剑。 副董事长杨过审批采购单：10002，金额：60000.0元，采购目的：购买《葵花宝典》。 董事长郭靖审批采购单：10003，金额：160000.0元，采购目的：购买《金刚经》。 召开董事会审批采购单：10004，金额：800000.0元，采购目的：购买桃花岛。

      如果需要在系统增加一个新的具体处理者，如增加一个经理(Manager)角色可以审批5万元至8万元（不包括8万元）的采购单，需要编写一个新的具体处理者类Manager，作为抽象处理者类Approver的子类，实现在Approver类中定义的抽象处理方法，如果采购金额大于等于8万元，则将请求转发给下家，代码如下所示：

[java]  view plain copy

1. //经理类：具体处理者  
2. class Manager extends Approver {  
3.     public Manager(String name) {  
4.         super(name);  
5.     }  
6.       
7.     //具体请求处理方法  
8.     public void processRequest(PurchaseRequest request) {  
9.         if (request.getAmount() < 80000) {  
10.             System.out.println("经理" + this.name + "审批采购单：" + request.getNumber() + "，金额：" + request.getAmount() + "元，采购目的：" + request.getPurpose() + "。");  //处理请求  
11.         }  
12.         else {  
13.             this.successor.processRequest(request);  //转发请求  
14.         }     
15.     }  
16. }  

       由于链的创建过程由客户端负责，因此增加新的具体处理者类对原有类库无任何影响，无须修改已有类的源代码，符合“开闭原则”。

      在客户端代码中，如果要将新的具体请求处理者应用在系统中，需要创建新的具体处理者对象，然后将该对象加入职责链中。如在客户端测试代码中增加如下代码：

[java]  view plain copy

1. Approver rhuang;  
2. rhuang = new Manager("黄蓉");  

        将建链代码改为：

[java]  view plain copy

1. //创建职责链  
2. wjzhang.setSuccessor(rhuang); //将“黄蓉”作为“张无忌”的下家  
3. rhuang.setSuccessor(gyang); //将“杨过”作为“黄蓉”的下家  
4. gyang.setSuccessor(jguo);  
5. jguo.setSuccessor(meeting);  

       重新编译并运行程序，输出结果如下：

主任张无忌审批采购单：10001，金额：45000.0元，采购目的：购买倚天剑。 经理黄蓉审批采购单：10002，金额：60000.0元，采购目的：购买《葵花宝典》。 董事长郭靖审批采购单：10003，金额：160000.0元，采购目的：购买《金刚经》。 召开董事会审批采购单：10004，金额：800000.0元，采购目的：购买桃花岛。