鍍金池/ 教程/ Java/ 責任連模式
訪(fǎng)問(wèn)者模式
訪(fǎng)問(wèn)者模式討論篇:java的動(dòng)態(tài)綁定與雙分派
責任連模式
迭代器模式
策略模式
命令模式
單例模式
建造者模式
解釋器模式
工廠(chǎng)方法模式
備忘錄模式
原型模式
單例模式討論篇:?jiǎn)卫J脚c垃圾回收
觀(guān)察者模式
模版方法模式
創(chuàng )建類(lèi)模式總結篇
抽象工廠(chǎng)模式
中介者模式

責任連模式

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

類(lèi)型:行為類(lèi)模式

類(lèi)圖:

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

首先來(lái)看一段代碼:

    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ù)邏輯是這樣的,方法有兩個(gè)參數:整數i和一個(gè)請求request,根據i的值來(lái)決定由誰(shuí)來(lái)處理request,如果i==1,由Handler1來(lái)處理,如果i==2,由Handler2來(lái)處理,以此類(lèi)推。在編程中,這種處理業(yè)務(wù)的方法非常常見(jiàn),所有處理請求的類(lèi)有if…else…條件判斷語(yǔ)句連成一條責任鏈來(lái)對請求進(jìn)行處理,相信大家都經(jīng)常用到。這種方法的優(yōu)點(diǎn)是非常直觀(guān),簡(jiǎn)單明了,并且比較容易維護,但是這種方法也存在著(zhù)幾個(gè)比較令人頭疼的問(wèn)題:

  • 代碼臃腫:實(shí)際應用中的判定條件通常不是這么簡(jiǎn)單地判斷是否為1或者是否為2,也許需要復雜的計算,也許需要查詢(xún)數據庫等等,這就會(huì )有很多額外的代碼,如果判斷條件再比較多,那么這個(gè)if…else…語(yǔ)句基本上就沒(méi)法看了。
  • 耦合度高:如果我們想繼續添加處理請求的類(lèi),那么就要繼續添加else if判定條件;另外,這個(gè)條件判定的順序也是寫(xiě)死的,如果想改變順序,那么也只能修改這個(gè)條件語(yǔ)句。

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

責任連模式的結構

責任連模式的類(lèi)圖非常簡(jiǎn)單,它由一個(gè)抽象地處理類(lèi)和它的一組實(shí)現類(lèi)組成:

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

了解了責任連模式的大體思想之后,再看代碼就比較好理解了:

    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("-----沒(méi)有合適的處理器-----");
                }
            }
            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類(lèi)是模擬判定條件;Request,Response分別對應請求和響應;抽象類(lèi)Handler中主要進(jìn)行條件的判斷,這里模擬一個(gè)處理等級,只有處理類(lèi)的處理等級高于Request的等級才能處理,否則交給下一個(gè)處理者處理。在Client類(lèi)中設置好鏈的前后執行關(guān)系,執行時(shí)將請求交給第一個(gè)處理類(lèi),這就是責任連模式,它完成的功能與前文中的if…else…語(yǔ)句是一樣的。


責任鏈模式的優(yōu)缺點(diǎn)

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

責任鏈模式的適用場(chǎng)景

就像開(kāi)始的例子那樣,假如使用if…else…語(yǔ)句來(lái)組織一個(gè)責任鏈時(shí)感到力不從心,代碼看上去很糟糕時(shí),就可以使用責任鏈模式來(lái)進(jìn)行重構。

總結

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