定義：使多個對象都有機會處理請求，從而避免了請求的發送者和接收者之間的耦合關系。將這些對象連成一條鏈，并沿著這條鏈傳遞該請求，直到有對象處理它為止。
類型：行為類模式
類圖：
首先來看一段代碼：
|
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來處理。
具體處理類：具體處理類主要是對具體的處理邏輯和處理的適用條件進行實現。
實例
責任鏈模式有兩個角色：
抽象處理者（Handler）角色 ：定義一個請求的接口。如果需要可以定義個一個方法用來設定和返回下家對象的引用。
具體處理者（ConcreteHandler）角色 ：如果可以處理就處理請求，如果不能處理，就把請求傳給下家，讓下家處理。也就是說它處理自己能處理的請求且可以訪問它的下家。
上述模式的測試代碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
package chainOfResp;/** *描述：抽象處理角色 */public abstract class Handler { protected Handler successor; /** *描述：處理方法 */ public abstract void handlerRequest(String condition); public Handler getSuccessor() { return successor; } public void setSuccessor(Handler successor) { this.successor = successor; } } |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package chainOfResp;/** *描述：具體處理角色 */public class ConcreteHandler1 extends Handler { @Override public void handlerRequest(String condition) { // 如果是自己的責任，就自己處理，負責傳給下家處理 if(condition.equals("ConcreteHandler1")){ System.out.println( "ConcreteHandler1 handled "); return ; }else{ System.out.println( "ConcreteHandler1 passed "); getSuccessor().handlerRequest(condition); } }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package chainOfResp;/** *描述：具體處理角色 */public class ConcreteHandler2 extends Handler { @Override public void handlerRequest(String condition) { // 如果是自己的責任，就自己處理，負責傳給下家處理 if(condition.equals("ConcreteHandler2")){ System.out.println( "ConcreteHandler2 handled "); return ; }else{ System.out.println( "ConcreteHandler2 passed "); getSuccessor().handlerRequest(condition); } }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package chainOfResp;/** *描述：具體處理角色 */public class ConcreteHandlerN extends Handler { /** * 這里假設n是鏈的最后一個節點必須處理掉 * 在實際情況下，可能出現環，或者是樹形， * 這里并不一定是最后一個節點。 * */ @Override public void handlerRequest(String condition) { System.out.println( "ConcreteHandlerN handled"); }} |
|
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
|
package chainOfResp;/** *描述：測試類 */public class Client { /** *描述： */ public static void main(String[] args) { Handler handler1 = new ConcreteHandler1(); Handler handler2 = new ConcreteHandler2(); Handler handlern = new ConcreteHandlerN(); //鏈起來 handler1.setSuccessor(handler2); handler2.setSuccessor(handlern); //假設這個請求是ConcreteHandler2的責任 handler1.handlerRequest("ConcreteHandler2"); }} |
舉這樣一個例子，在玩具工廠的生產車間，流水線就是一條責任鏈，假如一個玩具飛機有外殼裝配員，引擎裝配員，螺旋槳裝配員，模型包裝員組成。當這個物件飛機流到誰那里，誰就負責安裝他負責的這一部分，這部分安裝完成后流到下一個環節，知道所有環境完成。這個是一生成的責任鏈。還有一個質量檢測鏈，質量檢測也分多部，外殼檢測，引擎檢測，螺旋槳檢測，包裝檢測。當產品留到檢測員那里檢測自己負責的那一塊，如果有問題直接拎出來，如果沒問題則傳給下一個檢測員，直到所有檢測完成。這兩個都是責任鏈，但是區別是，生成責任鏈每個人都會處理，并處理一部分；而質量檢測責任鏈經過判斷，要么處理掉，要么不處理流下去。這就是責任鏈的兩種分類，后一種叫做純的責任鏈，前一種叫做不純的責任鏈，純的責任鏈在實際應用中很少存在，常見的為不純的責任鏈，上面的模型是模擬純的責任鏈來處理的。
責任鏈模式的優缺點
責任鏈模式與if…else…相比，他的耦合性要低一些，因為它把條件判定都分散到了各個處理類中，并且這些處理類的優先處理順序可以隨意設定。責任鏈模式也有缺點，這與if…else…語句的缺點是一樣的，那就是在找到正確的處理類之前，所有的判定條件都要被執行一遍，當責任鏈比較長時，性能問題比較嚴重。
責任鏈模式的適用場景
就像開始的例子那樣，假如使用if…else…語句來組織一個責任鏈時感到力不從心，代碼看上去很糟糕時，就可以使用責任鏈模式來進行重構。
總結
責任鏈模式其實就是一個靈活版的if…else…語句，它就是將這些判定條件的語句放到了各個處理類中，這樣做的優點是比較靈活了，但同樣也帶來了風險，比如設置處理類前后關系時，一定要特別仔細，搞對處理類前后邏輯的條件判斷關系，并且注意不要在鏈中出現循環引用的問題。
