定義：使多個對象都有機會處理請求，從而避免了請求的發送者和接收者之間的耦合關系。将這些對象連成一(yī)條鏈，并沿着這條鏈傳遞該請求，直到有對象處理它爲止。
類型：行爲類模式
類圖：
首先來看一(yī)段代碼：
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和一(yī)個請求request，根據i的值來決定由誰來處理request，如果i==1，由Handler1來處理，如果i==2，由Handler2來處理，以此類推。在編程中(zhōng)，這種處理業務的方法非常常見，所有處理請求的類有if…else…條件判斷語句連成一(yī)條責任鏈來對請求進行處理，相信大(dà)家都經常用到。這種方法的優點是非常直觀，簡單明了，并且比較容易維護，但是這種方法也存在着幾個比較令人頭疼的問題：
代碼臃腫：實際應用中(zhōng)的判定條件通常不是這麽簡單地判斷是否爲1或者是否爲2，也許需要複雜(zá)的計算，也許需要查詢數據庫等等，這就會有很多額外(wài)的代碼，如果判斷條件再比較多，那麽這個if…else…語句基本上就沒法看了。
耦合度高：如果我(wǒ)們想繼續添加處理請求的類，那麽就要繼續添加else if判定條件；另外(wài)，這個條件判定的順序也是寫死的，如果想改變順序，那麽也隻能修改這個條件語句。
既然缺點我(wǒ)們已經清楚了，就要想辦法來解決。這個場景的業務邏輯很簡單：如果滿足條件1，則由Handler1來處理，不滿足則向下(xià)傳遞；如果滿足條件2，則由Handler2來處理，不滿足則繼續向下(xià)傳遞，以此類推，直到條件結束。其實改進的方法也很簡單，就是把判定條件的部分(fēn)放(fàng)到處理類中(zhōng)，這就是責任連模式的原理。
責任連模式的結構
責任連模式的類圖非常簡單，它由一(yī)個抽象地處理類和它的一(yī)組實現類組成：
抽象處理類：抽象處理類中(zhōng)主要包含一(yī)個指向下(xià)一(yī)處理類的成員(yuán)變量nextHandler和一(yī)個處理請求的方法handRequest，handRequest方法的主要主要思想是，如果滿足處理的條件，則有本處理類來進行處理，否則由nextHandler來處理。
具體(tǐ)處理類：具體(tǐ)處理類主要是對具體(tǐ)的處理邏輯和處理的适用條件進行實現。
了解了責任連模式的大(dà)體(tǐ)思想之後，再看代碼就比較好理解了：
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)));
}
}代碼中(zhōng)Level類是模拟判定條件；Request，Response分(fēn)别對應請求和響應；抽象類Handler中(zhōng)主要進行條件的判斷，這裏模拟一(yī)個處理等級，隻有處理類的處理等級高于Request的等級才能處理，否則交給下(xià)一(yī)個處理者處理。在Client類中(zhōng)設置好鏈的前後執行關系，執行時将請求交給第一(yī)個處理類，這就是責任連模式，它完成的功能與前文中(zhōng)的if…else…語句是一(yī)樣的。
責任鏈模式的優缺點
責任鏈模式與if…else…相比，他的耦合性要低一(yī)些，因爲它把條件判定都分(fēn)散到了各個處理類中(zhōng)，并且這些處理類的優先處理順序可以随意設定。責任鏈模式也有缺點，這與if…else…語句的缺點是一(yī)樣的，那就是在找到正确的處理類之前，所有的判定條件都要被執行一(yī)遍，當責任鏈比較長時，性能問題比較嚴重。
責任鏈模式的适用場景
就像開(kāi)始的例子那樣，假如使用if…else…語句來組織一(yī)個責任鏈時感到力不從心，代碼看上去(qù)很糟糕時，就可以使用責任鏈模式來進行重構。
總結
責任鏈模式其實就是一(yī)個靈活版的if…else…語句，它就是将這些判定條件的語句放(fàng)到了各個處理類中(zhōng)，這樣做的優點是比較靈活了，但同樣也帶來了風險，比如設置處理類前後關系時，一(yī)定要特别仔細，搞對處理類前後邏輯的條件判斷關系，并且注意不要在鏈中(zhōng)出現循環引用的問題。
