定義：使多個對象都有機會處理請求，從而避免了請求的發送者和接收者之間的耦合關系。將這些對象連成一條鏈，并沿著這條鏈傳遞該請求，直到有對象處理它為止。
類型：行為類模式
類圖：
首先來看一段代碼：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public void test(int i, request request){ if(i==1){ handler1.response(request); }else if(i == 2){ handler2.response(request); }else if(i == 3){ handler3.response(request); }else if(i == 4){ handler4.response(request); }else{ handler5.response(request); } } |
代碼的業務邏輯是這樣的，方法有兩個參數：整數i和一個請求request，根據i的值來決定由誰來處理request，如果i==1，由handler1來處理，如果i==2，由handler2來處理，以此類推。
在編程中，這種處理業務的方法非常常見，所有處理請求的類有if…else…條件判斷語句連成一條責任鏈來對請求進行處理，相信大家都經常用到。這種方法的優點是非常直觀，簡單明了，并且比較容易維護，但是這種方法也存在著幾個比較令人頭疼的問題：
代碼臃腫：實際應用中的判定條件通常不是這么簡單地判斷是否為1或者是否為2，也許需要復雜的計算，也許需要查詢數據庫等等，這就會有很多額外的代碼，如果判斷條件再比較多，那么這個if…else…語句基本上就沒法看了。
耦合度高：如果我們想繼續添加處理請求的類，那么就要繼續添加else if判定條件；另外，這個條件判定的順序也是寫死的，如果想改變順序，那么也只能修改這個條件語句。
既然缺點我們已經清楚了，就要想辦法來解決。這個場景的業務邏輯很簡單：如果滿足條件1，則由handler1來處理，不滿足則向下傳遞；如果滿足條件2，則由handler2來處理，不滿足則繼續向下傳遞，以此類推，直到條件結束。其實改進的方法也很簡單，就是把判定條件的部分放到處理類中，這就是責任連模式的原理。
責任鏈模式的結構
責任鏈模式的類圖非常簡單，它由一個抽象地處理類和它的一組實現類組成：
抽象處理類：抽象處理類中主要包含一個指向下一處理類的成員變量nexthandler和一個處理請求的方法handrequest，handrequest方法的主要主要思想是，如果滿足處理的條件，則有本處理類來進行處理，否則由nexthandler來處理。
具體處理類：具體處理類主要是對具體的處理邏輯和處理的適用條件進行實現。
了解了責任鏈模式的大體思想之后，再看代碼就比較好理解了：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
class level { private int level = 0; public level(int level){ this.level = level; }; public boolean above(level level){ if(this.level >= level.level){ return true; } return false; } } class request { level level; public request(level level){ this.level = level; } public level getlevel(){ return level; } } class response { } abstract class handler { private handler nexthandler; public final response handlerequest(request request){ response response = null; if(this.gethandlerlevel().above(request.getlevel())){ response = this.response(request); }else{ if(this.nexthandler != null){ this.nexthandler.handlerequest(request); }else{ system.out.println("-----沒有合適的處理器-----"); } } return response; } public void setnexthandler(handler handler){ this.nexthandler = handler; } protected abstract level gethandlerlevel(); public abstract response response(request request); } class concretehandler1 extends handler { protected level gethandlerlevel() { return new level(1); } public response response(request request) { system.out.println("-----請求由處理器1進行處理-----"); return null; } } class concretehandler2 extends handler { protected level gethandlerlevel() { return new level(3); } public response response(request request) { system.out.println("-----請求由處理器2進行處理-----"); return null; } } class concretehandler3 extends handler { protected level gethandlerlevel() { return new level(5); } public response response(request request) { system.out.println("-----請求由處理器3進行處理-----"); return null; } } public class client { public static void main(string[] args){ handler handler1 = new concretehandler1(); handler handler2 = new concretehandler2(); handler handler3 = new concretehandler3(); handler1.setnexthandler(handler2); handler2.setnexthandler(handler3); response response = handler1.handlerequest(new request(new level(4))); } } |
代碼中level類是模擬判定條件；request，response分別對應請求和響應；抽象類handler中主要進行條件的判斷，這里模擬一個處理等級，只有處理類的處理等級高于request的等級才能處理，否則交給下一個處理者處理。
在client類中設置好鏈的前后執行關系，執行時將請求交給第一個處理類，這就是責任鏈模式，它完成的功能與前文中的if…else…語句是一樣的。
責任鏈模式的優缺點
責任鏈模式與if…else…相比，他的耦合性要低一些，因為它把條件判定都分散到了各個處理類中，并且這些處理類的優先處理順序可以隨意設定。責任鏈模式也有缺點，這與if…else…語句的缺點是一樣的，那就是在找到正確的處理類之前，所有的判定條件都要被執行一遍，當責任鏈比較長時，性能問題比較嚴重。
責任鏈模式的適用場景
就像開始的例子那樣，假如使用if…else…語句來組織一個責任鏈時感到力不從心，代碼看上去很糟糕時，就可以使用責任鏈模式來進行重構。
總結
責任鏈模式其實就是一個靈活版的if…else…語句，它就是將這些判定條件的語句放到了各個處理類中，這樣做的優點是比較靈活了，但同樣也帶來了風險，比如設置處理類前后關系時，一定要特別仔細，搞對處理類前后邏輯的條件判斷關系，并且注意不要在鏈中出現循環引用的問題。
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持服務器之家。
