设计模式之责任链模式

设计模式系列文章：

　　1、设计模式之工厂模式
　　2、设计模式之单例模式
　　3、设计模式之代理模式
　　4、设计模式之外观模式（即门面模式）
　　5、设计模式之策略模式
　　6、设计模式之责任链模式
　　7、设计模式之观察者模式
　　8、设计模式之建造者模式

　　本文目录：
　　一、责任链模式原理
　　二、责任链模式举例
　　三、总结
　　　
　

一、责任链模式原理

　　责任链模式是一种对象的行为模式。在该责任链模式中，创建了一条引用链，每一个对象中都包含下一个对象的引用。当处理客户端请求时，请求会在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。
　　对请求发送者与请求接收者解耦。
　　责任链模式涉及到的角色如下所示：
　　●　　抽象处理者(Handler)角色：定义出一个处理请求的接口。如果需要，接口可以定义 出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。上图中Handler类的聚合关系给出了具体子类对下家的引用，抽象方法handleRequest()规范了子类处理请求的操作。
　　●　　具体处理者(ConcreteHandler)角色：所有具体处理者都实现了抽象处理者接口。具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。
　　责任链模式实例UML
　　
　　责任链模式执行UML，应该是各个实例从前往后传递。
　　

一、责任链模式举例

　　在某一公司中，一线员工策划一团建项目，但是团建经费问题还需要上级审批，每一级领导的权限不同。
　　 - 组长（Leader）：审批金额为0~100000元的项目；
　　 - 部门主管(DepartmentLeader)：审批金额为10000~20000元的项目；
　　 - 经理(Manager)：审批金额为20000~30000的项目；
　　 - 董事长(Chairman)：审批金额为30000以上的项目；
执行UML图

/*
*抽象处理者角色类
*/
public abstract class Handler {
    /**
     * 持有下一个处理请求的对象
     */
    protected Handler successor = null;
    /**
     * 设置下一个处理请求的对象
     */
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }
    /**
     * 取值方法
     */
    public Handler getSuccessor() {
        return successor;
    }
    /**
     * 处理聚餐费用的申请
     * @param plan   团建计划内容
     * @param fee    申请的钱数
     * @return       成功或失败的具体通知
     */
    public abstract String handleRequest(String plan,int fee);
}

/*
*具体处理者角色类 组长
*/
public class Leader extends Handler {

    @Override
    public String handleRequest(String plan,int fee) {

        if(fee < 10000){
             if("good plan".equals(plan)){
                return "approve"; 
            }else {
                return "reject";  
            }
        }else{
            //超过10000，继续传递给级别更高的人处理
            if(getSuccessor() != null）{
                return getSuccessor().handleFeeRequest(plan, fee);
            }
        }
    }
}

/*
*具体处理者角色类 部门主管
*/
public class DepartmentLeader extends Handler {

    @Override
    public String handleRequest(String plan,int fee) {

        if(fee < 20000){
            if("good plan".equals(plan)){
                return "approve"; 
            }else {
                return "reject";  
            }
        }else{
            //超过20000，继续传递给级别更高的人处理
            if(getSuccessor() != null）{
                return getSuccessor().handleFeeRequest(plan, fee);
            }
        }
    }
}

/*
*具体处理者角色类 经理
*/
public class Manager extends Handler {

    @Override
    public String handleRequest(String plan,int fee) {

        if(fee < 30000){
            if("good plan".equals(plan)){
                return "approve"; 
            }else {
                return "reject";  
            }
        }else{
            //超过30000，继续传递给级别更高的人处理
            if(getSuccessor() != null）{
                return getSuccessor().handleFeeRequest(plan, fee);
            }
        }
    }
}

/*
*具体处理者角色类 董事长
*/
public class Chairman extends Handler {

    @Override
    public String handleRequest(String plan,int fee) {
            if("good plan".equals(plan)){
                return "approve"; 
            }else {
                return "reject";  
            }
    }
}

/**
 *客户端
 */
public class Client {

    public static void main(String[] args) {
        //先要组装责任链
        Handler leader = new Leader();
        Handler departmentLeader = new DepartmentLeader();
        Handler manager = new Manager();
        Handler chairman = new Chairman();

        leader.setSuccessor(departmentLeader);
        departmentLeader.setSuccessor(manager);
        manager..setSuccessor(chairman);

        //开始测试
        String plan = "good plan";
        String test1 = leader.handleRequest(plan, 20000);
        System.out.println("test1 = " + test1);
        String plan = "pool plan";
        String test2 = leader.handleRequest(plan, 30000);
        System.out.println("test2 = " + test2);
    }

}

运行结果：

test1 = agree
test2 = reject

三、总结

意图：避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。
主要解决：职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。
何时使用：在处理消息的时候以过滤很多道。

使用场景： 1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。 2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。 3、可动态指定一组对象处理请求。