java設計模式（行爲型）之職責鏈模式

第0章：簡介

職責鏈模式定義：使多個對象都有機會處理請求，從而避免請求的發送者和接收者之間的耦合關係。將這些對象連成一條鏈，並沿着這條鏈傳遞該請求，直到有一個對象處理它爲止

職責鏈模式本質：分離職責，動態組合

參考：研磨設計模式（書籍），大話設計模式（書籍）

模式圖：

待補充

第1章：實踐

第0節：職責鏈模式

（1）職責的接口（Handler.java）

package com.mcc.core.designPattern.behavior.chainOfResponsibility.chainOfResponsibility;

/**
 * 職責的接口，即處理請求的接口
 *
 * 職責鏈模式的定義：使多個對象都有機會處理請求，從而避免請求的發送者和接收者之間的耦合關係。
 * 將這些對象連成一條鏈，並沿着這條鏈傳遞該請求，直到有一個對象處理它爲止
 *
 * 職責鏈模式的本質：分離職責，動態組合
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         DateTime: 14-3-17  下午11:48
 */
public abstract class Handler {

    //持有後繼的職責對象
    protected Handler handler;

    /**
     * 設置後繼的職責對象
     * @param handler
     */
    public void setHandler(Handler handler) {
        this.handler = handler;
    }

    /**
     * 處理請求的方法，參數可有可無
     */
    public abstract void handleRequest(String flag);
}

（2）處理類A（HandlerExtendsA.java）

package com.mcc.core.designPattern.behavior.chainOfResponsibility.chainOfResponsibility;

/**
 * 處理類A
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         DateTime: 14-3-17  下午11:54
 */
public class HandlerExtendsA extends Handler{

    @Override
    public void handleRequest(String flag) {
        if(flag != null && "A".equalsIgnoreCase(flag.trim())){
            System.out.println("處理類A處理了請求，責任傳遞結束");
        }else{
            System.out.println("處理類A不處理請求，交給下一環處理");
            this.handler.handleRequest(flag);
        }
    }
}

（3）處理類B（HandlerExtendsB.java）

package com.mcc.core.designPattern.behavior.chainOfResponsibility.chainOfResponsibility;

/**
 * 處理類B
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         DateTime: 14-3-17  下午11:54
 */
public class HandlerExtendsB extends Handler{

    @Override
    public void handleRequest(String flag) {
        if(flag != null && "B".equalsIgnoreCase(flag.trim())){
            System.out.println("處理類B處理了請求，責任傳遞結束");
        }else{
            System.out.println("處理類B不處理請求，交給下一環處理");
            this.handler.handleRequest(flag);
        }
    }
}

（4）處理類C（HandlerExtendsC.java）

package com.mcc.core.designPattern.behavior.chainOfResponsibility.chainOfResponsibility;

/**
 * 處理類C
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         DateTime: 14-3-17  下午11:54
 */
public class HandlerExtendsC extends Handler{

    @Override
    public void handleRequest(String flag) {
        if(flag != null && "C".equalsIgnoreCase(flag.trim())){
            System.out.println("處理類C處理了請求，責任傳遞結束");
        }else{
            System.out.println("處理類C不處理請求，交給下一環處理");
            this.handler.handleRequest(flag);
        }
    }
}

（5）客戶端測試，職責鏈（Client.java）

package com.mcc.core.designPattern.behavior.chainOfResponsibility.chainOfResponsibility;

/**
 * 客戶端測試，職責鏈
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         DateTime: 14-3-18  上午12:00
 */
public class Client {

    public static void main(String args[]){

        //環對象
        Handler handlerA = new HandlerExtendsA();
        Handler handlerB = new HandlerExtendsB();
        Handler handlerC = new HandlerExtendsC();

        //環組成鏈，可根據實際任意順序組合
        handlerA.setHandler(handlerB);
        handlerB.setHandler(handlerC);

        //測試示例
        handlerA.handleRequest("C");
    }
}

第1節：擴展職責鏈模式（功能鏈模式）

（1）職責的接口（Handler.java）

package com.mcc.core.designPattern.behavior.chainOfResponsibility.chainOfFunction;

/**
 * 職責的接口，即處理請求的接口,這裏每個環處理部分功能，也叫功能鏈
 *
 * 職責鏈模式的定義：使多個對象都有機會處理請求，從而避免請求的發送者和接收者之間的耦合關係。
 * 將這些對象連成一條鏈，並沿着這條鏈傳遞該請求，直到有一個對象處理它爲止
 *
 * 職責鏈模式的本質：分離職責，動態組合
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         DateTime: 14-3-17  下午11:48
 */
public abstract class Handler {

    //持有後繼的職責對象
    protected Handler handler;

    /**
     * 設置後繼的職責對象
     * @param handler
     */
    public void setHandler(Handler handler) {
        this.handler = handler;
    }

    /**
     * 處理請求的方法，參數可有可無
     */
    public abstract void handleRequest();
}

（2）處理類A（HandlerExtendsA.java）

package com.mcc.core.designPattern.behavior.chainOfResponsibility.chainOfFunction;

/**
 * 處理類A
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         DateTime: 14-3-17  下午11:54
 */
public class HandlerExtendsA extends Handler {

    @Override
    public void handleRequest() {
        System.out.println("處理類A處理了部分功能，剩下的功能由後繼環處理");
        this.handler.handleRequest();
    }
}

（3）處理類B（HandlerExtendsB.java）

package com.mcc.core.designPattern.behavior.chainOfResponsibility.chainOfFunction;

/**
 * 處理類B
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         DateTime: 14-3-17  下午11:54
 */
public class HandlerExtendsB extends Handler {

    @Override
    public void handleRequest() {
        System.out.println("處理類B處理了部分功能，剩下的功能由後繼環處理");
        this.handler.handleRequest();
    }
}

（4）處理類C（HandlerExtendsC.java）

package com.mcc.core.designPattern.behavior.chainOfResponsibility.chainOfFunction;

/**
 * 處理類C
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         DateTime: 14-3-17  下午11:54
 */
public class HandlerExtendsC extends Handler {

    @Override
    public void handleRequest() {
        System.out.println("處理類C處理了剩下功能，傳遞結束，無後繼環");
    }
}

（5）客戶端測試，功能鏈（Client.java）

package com.mcc.core.designPattern.behavior.chainOfResponsibility.chainOfFunction;

/**
 * 客戶端測試，功能鏈
 *
 * @author <a href="mailto:[email protected]">menergy</a>
 *         DateTime: 14-3-18  上午12:00
 */
public class Client {

    public static void main(String args[]){

        //環對象
        Handler handlerA = new HandlerExtendsA();
        Handler handlerB = new HandlerExtendsB();
        Handler handlerC = new HandlerExtendsC();

        //環組成鏈，可根據實際任意順序組合
        handlerA.setHandler(handlerB);
        handlerB.setHandler(handlerC);

        //測試示例
        handlerA.handleRequest();
    }
}