行为型模式11:职责链模式（Chain Of Responsibility）

  职责链模式（Chain Of Responsibility），使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

       这里发出这个请求的客户端并不知道这当中的哪一个对象最终处理该请求，这样系统的更改可以在不影响客户端的情况下动态的重新组织和分配责任。

职责链模式UML类图：

       如上图所示：Handler类，定义一个处理请示的接口；ConcreteHandler 类，具体处理者类，处理它所负责的请求，可访问它的后继者，如果可处理该请求就处理之，否则就将该请求转发给它的后继者；客户端代码，向链上的具体处理者对象提交请求。

职责链模式代码实现：

[csharp]  view plain copy print ?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.   
6. namespace ChainOfResponsibility  
7. {  
8.     /*Handler类，定义一个处理请示的接口*/  
9.     abstract class Handler  
10.     {  
11.         protected Handler successor;  
12.         /*设置继任务*/  
13.         public void setSuccessor(Handler successor)  
14.         {  
15.             this.successor = successor;  
16.         }  
17.   
18.         /*处理请求的抽象方法*/  
19.         public abstract void HandleRequest(int Request);  
20.   
21.     }  
22.   
23.     /*ConcreteHandler 类，具体处理者类，处理它所负责的请求，可访问它的后继者，如果可处理该请求就 
24.      处理之，否则就将该请求转发给它的后继者。*/  
25.     /*ConcreteHandler1 当请求在0-10之间时，有权处理，否则转到下一位。*/  
26.     class ConcreteHandler1 : Handler  
27.     {  
28.         public override void HandleRequest(int Request)  
29.         {  
30.             if (Request >= 0 && Request < 10)  
31.             {  
32.                 Console.WriteLine("{0}处理请求{1}", this.GetType().Name, Request);  
33.             }  
34.             else if(successor != null)  
35.             {  
36.                 successor.HandleRequest(Request);  
37.             }  
38.             else  
39.             {  
40.                 Console.WriteLine("{0}拒绝处理{1}", this.GetType().Name, Request);              
41.             }  
42.         }  
43.     }  
44.   
45.     /*ConcreteHandler2 当请求在10-20之间时，有权处理，否则转到下一位。*/  
46.     class ConcreteHandler2 : Handler  
47.     {  
48.         public override void HandleRequest(int Request)  
49.         {  
50.             if (Request >= 10 && Request < 20)  
51.             {  
52.                 Console.WriteLine("{0}处理请求{1}", this.GetType().Name, Request);  
53.             }  
54.             else if (successor != null)  
55.             {  
56.                 successor.HandleRequest(Request);  
57.             }  
58.             else  
59.             {  
60.                 Console.WriteLine("{0}拒绝处理{1}", this.GetType().Name, Request);    
61.             }  
62.         }  
63.     }  
64.   
65.     /*ConcreteHandler3 当请求在20-30之间时，有权处理，否则转到下一位。*/  
66.     class ConcreteHandler3 : Handler  
67.     {  
68.         public override void HandleRequest(int Request)  
69.         {  
70.             if (Request >= 20 && Request < 30)  
71.             {  
72.                 Console.WriteLine("{0}处理请求{1}", this.GetType().Name, Request);  
73.             }  
74.             else if (successor != null)  
75.             {  
76.                 successor.HandleRequest(Request);  
77.             }  
78.             else  
79.             {  
80.                 Console.WriteLine("{0}拒绝处理{1}", this.GetType().Name, Request);    
81.             }  
82.         }  
83.     }  
84.   
85.     /*ConcreteHandler 当请求在<100之间时，有权处理，否则转到下一位。*/  
86.     class ConcreteHandler : Handler  
87.     {  
88.         public override void HandleRequest(int Request)  
89.         {  
90.             if (Request < 100)  
91.             {  
92.                 Console.WriteLine("{0}处理请求{1}", this.GetType().Name, Request);  
93.             }  
94.             else if (successor != null)  
95.             {  
96.                 successor.HandleRequest(Request);  
97.             }  
98.             else  
99.             {  
100.                 Console.WriteLine("{0}拒绝处理{1}", this.GetType().Name, Request);    
101.             }  
102.         }  
103.     }  
104. }  

客户端：

[csharp]  view plain copy print ?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.   
6. namespace ChainOfResponsibility  
7. {  
8.     class Program  
9.     {  
10.         /*客户端代码，向链上的具体处理者对象提交请求*/  
11.         static void Main(string[] args)  
12.         {  
13.             Handler h1 = new ConcreteHandler1();  
14.             Handler h2 = new ConcreteHandler2();  
15.             Handler h3 = new ConcreteHandler3();  
16.             Handler h = new ConcreteHandler();  
17.   
18.             h1.setSuccessor(h2);  
19.             h2.setSuccessor(h3);  
20.             h3.setSuccessor(h);  
21.   
22.             int[] request = { 2,5,11,19,21,31,99,100};  
23.   
24.             foreach (int r in request)  
25.             {  
26.                 h1.HandleRequest(r);  
27.             }  
28.   
29.             Console.Read();  
30.         }  
31.     }  
32. }  

职责链模式总结：

       职责链模式中最关键的就是当客户提交一个请求时，请求时沿链传递直至有一个ConcreteHandler对象负责处理它为止。

       这就使得接收者和发送者都没有对方的明确信息，且链中的对象自己也不知道链的结构。

       职责链可简化对象的相互链接，它们仅需保持一个指向其后继者的引用，而不需保持它所有的候选接受者的引用。

       职责链模式使得可以随时的增加或修改处理一个请求的结构增强了给对象指派职责的灵活性。

职责链模式应用案例—小菜加薪：

[csharp]  view plain copy print ?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.   
6. namespace ChainOfResponsibilityExample  
7. {  
8.     //管理者  
9.     abstract class Manager  
10.     {  
11.         protected string name;  
12.         protected Manager superior;  
13.   
14.         public Manager(string name)  
15.         {  
16.             this.name = name;  
17.         }  
18.         public void setSuperior(Manager superior)  
19.         {  
20.             this.superior = superior;  
21.         }  
22.   
23.         public abstract void RequestApplication(Request request);  
24.   
25.     }  
26.   
27.   
28.     //请求  
29.     class Request  
30.     {  
31.         private string requestType;  
32.   
33.         public string RequestType  
34.         {  
35.             get { return requestType; }  
36.             set { requestType = value; }  
37.         }  
38.   
39.         private string requestContent;  
40.           
41.         public string RequestContent  
42.         {  
43.             get { return requestContent; }  
44.             set { requestContent = value; }  
45.         }  
46.   
47.         private int number;  
48.   
49.         public int Number  
50.         {  
51.             get { return number; }  
52.             set { number = value; }  
53.         }  
54.     }  
55.   
56.     class CommonManager : Manager  
57.     {  
58.         public CommonManager(string name)  
59.             : base(name)  
60.         { }  
61.   
62.         public override void RequestApplication(Request request)  
63.         {  
64.             if (request.RequestType == "请假" && request.Number <= 2)  
65.             {  
66.                 Console.WriteLine("{0}:{1},数量:{2}被批准。", name, request.RequestContent, request.Number);  
67.             }  
68.             else if(superior != null)  
69.             {  
70.                 superior.RequestApplication(request);  
71.             }  
72.         }  
73.     }  
74.   
75.     class MajorDomo : Manager  
76.     {  
77.         public MajorDomo(string name)  
78.             : base(name)  
79.         { }  
80.   
81.         public override void RequestApplication(Request request)  
82.         {  
83.             if (request.RequestType == "请假" && request.Number <= 5)  
84.             {  
85.                 Console.WriteLine("{0}:{1},数量:{2}被批准。", name, request.RequestContent, request.Number);  
86.             }  
87.             else if (superior != null)  
88.             {  
89.                 superior.RequestApplication(request);  
90.             }  
91.         }  
92.     }  
93.   
94.     class GeneralManager : Manager  
95.     {  
96.         public GeneralManager(string name)  
97.             : base(name)  
98.         { }  
99.   
100.         public override void RequestApplication(Request request)  
101.         {  
102.             if (request.RequestType == "请假")  
103.             {  
104.                 Console.WriteLine("{0}:{1},数量:{2}被批准。", name, request.RequestContent, request.Number);  
105.             }  
106.             else if (request.RequestType == "加薪" && request.Number <= 500)  
107.             {  
108.                 Console.WriteLine("{0}:{1},数量:{2}被批准。", name, request.RequestContent, request.Number);    
109.             }  
110.             else if (request.RequestType == "加薪" && request.Number > 500)  
111.             {  
112.                 Console.WriteLine("{0}:{1},数量:{2}再说吧。", name, request.RequestContent, request.Number);  
113.             }  
114.         }  
115.     }  
116.       
117. }  

客户端：

[csharp]  view plain copy print ?

1. using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.   
6. namespace ChainOfResponsibilityExample  
7. {  
8.     class Program  
9.     {  
10.         static void Main(string[] args)  
11.         {  
12.             CommonManager commonManager = new CommonManager("金利");  
13.             MajorDomo majorDomo = new MajorDomo("宗剑");  
14.             GeneralManager generalManager = new GeneralManager("总经理");  
15.   
16.             commonManager.setSuperior(majorDomo);  
17.             majorDomo.setSuperior(generalManager);  
18.   
19.             Request request1 = new Request();  
20.             request1.RequestType = "请假";  
21.             request1.RequestContent = "小菜请假";  
22.             request1.Number = 1;  
23.   
24.             commonManager.RequestApplication(request1);  
25.   
26.             Request request2 = new Request();  
27.             request2.RequestType = "请假";  
28.             request2.RequestContent = "小菜请假";  
29.             request2.Number = 3;  
30.   
31.             commonManager.RequestApplication(request2);  
32.   
33.             Request request3 = new Request();  
34.             request3.RequestType = "请假";  
35.             request3.RequestContent = "小菜请假";  
36.             request3.Number = 6;  
37.   
38.             commonManager.RequestApplication(request3);  
39.   
40.             Request request4 = new Request();  
41.             request4.RequestType = "加薪";  
42.             request4.RequestContent = "小菜请求加薪";  
43.             request4.Number = 300;  
44.   
45.             commonManager.RequestApplication(request4);  
46.   
47.             Request request5 = new Request();  
48.             request5.RequestType = "加薪";  
49.             request5.RequestContent = "小菜请求加薪";  
50.             request5.Number = 1000;  
51.   
52.             commonManager.RequestApplication(request5);  
53.   
54.             Console.Read();  
55.         }  
56.     }  
57. }  

运行结果：