设计模式[17]-职责链模式-Chain of Responsibility Pattern

1.职责链模式简介

职责链(Chain of Responsibility)模式是是行为型(Behavioral)设计模式，是一种链式处理请求的设计模式，请求在链上传递，直到链上的有对象负责处理请求。Servlet中Filter链、Spring MVC的Interceptor拦截器链，都是职责链的具体应用。

职责链模式一共有二种角色：

(1) Handler（抽象处理者）：它定义了处理请求的接口，还引用了下一个处理者。

(2) ConcreteHandler（具体处理者）：它是抽象处理者的子类，根据请求来判断处理请求还是把请求传递给下一个具体处理者。

2. 职责链模式举例

下面做一个经费申请的例子，假设审批人共有三个，分别是经理、总监、和总经理；经理审批500元以下的申请，总监审批1000元以下的申请，总经理审批1000元以上的申请。

序号	类名	角色	说明
1	Handler	Handler	抽象处理者
2	Manager	ConcreteHandler	具体处理者，经理
3	Director	ConcreteHandler	具体处理者，总监
4	GeneralManager	ConcreteHandler	具体处理者，总经理
5	ChainMain	客户端	演示调用，组装责任链

Chain of Responsibility.png

1. 抽象处理者

/**
 * 抽象处理者
 */
public abstract class Handler {

    // 下一个处理者
    private Handler nextHandler;

    // 抽象的处理请求的方法
    public abstract void handleRequest(int amount);

    // 获取下一个处理者
    public Handler getNextHandler() {
        return nextHandler;
    }

    // 设置下一个处理者
    public void setNextHandler(Handler handler) {
        this.nextHandler = handler;
    }
}

2. 经理

/**
 * 经理，审批500元以内的经费
 */
public class Manager extends Handler {

    @Override
    public void handleRequest(int amount) {
        if (amount < 500) {
            System.out.println("我是经理，批准了经费申请，金额是:" + amount);
        } else {
            Handler next = getNextHandler();
            if (next != null) {
                next.handleRequest(amount);
            }
        }
    }
}

3. 总监

/**
 * 总监，审批1000元以内的经费
 */
public class Director extends Handler{

    @Override
    public void handleRequest(int amount) {
        if (amount < 1000) {
            System.out.println("我是总监，批准了经费申请，金额是:" + amount);
        } else {
            Handler next = getNextHandler();
            if (next != null) {
                next.handleRequest(amount);
            }
        }
    }
}

4. 总经理

/**
 * 总经理，审批大于1000元的经费，如果超过5000元，就不批准。
 */
public class GeneralManager extends Handler {

    @Override
    public void handleRequest(int amount) {
        if (amount >= 1000 && amount < 5000) {
            System.out.println("我是总经理，批准了经费申请，金额是:" + amount);
        } else if (amount >= 5000) {
            System.out.println("我是总经理，驳回了经费申请，金额是:" + amount);
        } else {
            Handler next = getNextHandler();
            if (next != null) {
                next.handleRequest(amount);
            }
        }
    }
}

5. 演示类

/**
 * 客户端演示
 */
public class ChainMain {

    public static void main(String[] args) {
        // 组装责任链
        Handler manager = new Manager();
        Handler director = new Director();
        Handler gm = new GeneralManager();
        manager.setNextHandler(director);
        director.setNextHandler(gm);
        // Case 1
        int fee = 823;
        System.out.println("提交吃饭经费申请，金额：" + fee);
        manager.handleRequest(fee);
        System.out.println("-----------------------");
        // Case 2
        fee = 8230;
        System.out.println("提交团队建设经费申请，金额：" + fee);
        manager.handleRequest(fee);
    }
}

结果输出

提交吃饭经费申请，金额：823
我是总监，批准了经费申请，金额是:823
-----------------------
提交团队建设经费申请，金额：8230
我是总经理，驳回了经费申请，金额是:8230

3. 总结

职责链分为纯的和不纯的两种。纯的职责链中只有一个处理者会承担起处理请求的责任，其余的处理者都只是转发；不纯的职责链中，允许0到n个具体处理者处理请求。

职责链模式的优点在于，请求方不需要知道是哪个Handler处理了请求，而且链中的Handler也不需要知道链的结构，带来了系统的灵活性。

职责链的缺点在于，由于没有明确的Handler处理，可能导致请求无人处理；如果链很长，对于调试来说是不利的；如果建链不当，可能会出现死循环。

（完）