責(zé)任連模式

定義：使多個對象都有機會處理請求，從而避免了請求的發(fā)送者和接收者之間的耦合關(guān)系。將這些對象連成一條鏈，并沿著這條鏈傳遞該請求，直到有對象處理它為止。

類型：行為類模式

類圖：

http://wiki.jikexueyuan.com/project/java-design-pattern/images/chain-responsibility-pattern-1.jpg" alt="command-pattern" />

首先來看一段代碼：

    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);
        }
    }

代碼的業(yè)務(wù)邏輯是這樣的，方法有兩個參數(shù)：整數(shù)i和一個請求request，根據(jù)i的值來決定由誰來處理request，如果i==1，由Handler1來處理，如果i==2，由Handler2來處理，以此類推。在編程中，這種處理業(yè)務(wù)的方法非常常見，所有處理請求的類有if…else…條件判斷語句連成一條責(zé)任鏈來對請求進(jìn)行處理，相信大家都經(jīng)常用到。這種方法的優(yōu)點是非常直觀，簡單明了，并且比較容易維護(hù)，但是這種方法也存在著幾個比較令人頭疼的問題：

• 代碼臃腫：實際應(yīng)用中的判定條件通常不是這么簡單地判斷是否為1或者是否為2，也許需要復(fù)雜的計算，也許需要查詢數(shù)據(jù)庫等等，這就會有很多額外的代碼，如果判斷條件再比較多，那么這個if…else…語句基本上就沒法看了。
• 耦合度高：如果我們想繼續(xù)添加處理請求的類，那么就要繼續(xù)添加else if判定條件；另外，這個條件判定的順序也是寫死的，如果想改變順序，那么也只能修改這個條件語句。

既然缺點我們已經(jīng)清楚了，就要想辦法來解決。這個場景的業(yè)務(wù)邏輯很簡單：如果滿足條件1，則由Handler1來處理，不滿足則向下傳遞；如果滿足條件2，則由Handler2來處理，不滿足則繼續(xù)向下傳遞，以此類推，直到條件結(jié)束。其實改進(jìn)的方法也很簡單，就是把判定條件的部分放到處理類中，這就是責(zé)任連模式的原理。

責(zé)任連模式的結(jié)構(gòu)

責(zé)任連模式的類圖非常簡單，它由一個抽象地處理類和它的一組實現(xiàn)類組成：

• 抽象處理類：抽象處理類中主要包含一個指向下一處理類的成員變量nextHandler和一個處理請求的方法handRequest，handRequest方法的主要主要思想是，如果滿足處理的條件，則有本處理類來進(jìn)行處理，否則由nextHandler來處理。
• 具體處理類：具體處理類主要是對具體的處理邏輯和處理的適用條件進(jìn)行實現(xiàn)。

了解了責(zé)任連模式的大體思想之后，再看代碼就比較好理解了：

    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進(jìn)行處理-----");
            return null;
        }
    }

    class ConcreteHandler2 extends Handler {
        protected Level getHandlerLevel() {
            return new Level(3);
        }
        public Response response(Request request) {
            System.out.println("-----請求由處理器2進(jìn)行處理-----");
            return null;
        }
    }

    class ConcreteHandler3 extends Handler {
        protected Level getHandlerLevel() {
            return new Level(5);
        }
        public Response response(Request request) {
            System.out.println("-----請求由處理器3進(jìn)行處理-----");
            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分別對應(yīng)請求和響應(yīng)；抽象類Handler中主要進(jìn)行條件的判斷，這里模擬一個處理等級，只有處理類的處理等級高于Request的等級才能處理，否則交給下一個處理者處理。在Client類中設(shè)置好鏈的前后執(zhí)行關(guān)系，執(zhí)行時將請求交給第一個處理類，這就是責(zé)任連模式，它完成的功能與前文中的if…else…語句是一樣的。

責(zé)任鏈模式的優(yōu)缺點

責(zé)任鏈模式與if…else…相比，他的耦合性要低一些，因為它把條件判定都分散到了各個處理類中，并且這些處理類的優(yōu)先處理順序可以隨意設(shè)定。責(zé)任鏈模式也有缺點，這與if…else…語句的缺點是一樣的，那就是在找到正確的處理類之前，所有的判定條件都要被執(zhí)行一遍，當(dāng)責(zé)任鏈比較長時，性能問題比較嚴(yán)重。

責(zé)任鏈模式的適用場景

就像開始的例子那樣，假如使用if…else…語句來組織一個責(zé)任鏈時感到力不從心，代碼看上去很糟糕時，就可以使用責(zé)任鏈模式來進(jìn)行重構(gòu)。

總結(jié)

責(zé)任鏈模式其實就是一個靈活版的if…else…語句，它就是將這些判定條件的語句放到了各個處理類中，這樣做的優(yōu)點是比較靈活了，但同樣也帶來了風(fēng)險，比如設(shè)置處理類前后關(guān)系時，一定要特別仔細(xì)，搞對處理類前后邏輯的條件判斷關(guān)系，并且注意不要在鏈中出現(xiàn)循環(huán)引用的問題。