责任链模式

责任链模式介绍
责任论模式，是行为型设计模式之一。什么是链，我们将多个节点首尾相连所构成的模型称为锁链，对于链式结构，每个节点都可以被拆开在连接，因此，链式结构也可以具有很好的灵活性。
责任链模式的定义
使多个对象都有处理请求，从而避免了请求的发送者和接收者之间的耦合关系，将这些对象连成一条链，并沿着这条链传递请求，直到有对象处理它为止。
责任链模式的使用场景
多个对象可以处理同一请求，但具体那个对象处理则在运行时动态决定。
责任链模式的UML类图

代码示例：

抽象处理者角色类

public abstract class Handle {

    protected Handle successor = null;

    public Handle getSuccessor() {
        return successor;
    }

    public void setSuccessor(Handle successor){
        this.successor = successor;
    }

    public abstract String handleFeeRequest(String user, double fee);

}

具体出来角色类

public class ProjectManager extends Handle {

    @Override
    public String handleFeeRequest(String user, double fee) {
        String str = null;
        //经理权限比较小，只能在500内
        if (fee < 500) {
            //只同意张三的请求
            if ("张三".equals(user)) {
                str = "成功:项目经理同意【" + user +"】的聚餐费用，金额为" +fee +"元";

            }else{
                str = "失败: 项目经理不同意【" + user + "】的聚餐费用，金额为" + fee + "元";

            }

        }else{
            //超过500，继续传递给级别高的人处理
            if (getSuccessor() != null) {
                return getSuccessor().handleFeeRequest(user, fee);

            }
        }
        return str;
    }

}

public class DeptManager extends Handle {

    @Override
    public String handleFeeRequest(String user, double fee) {
        String str = null;
        //部门经理权限只能在1000内
        if (fee < 1000) {
            //只同意张三的请求
            if ("张三".equals(user)) {
                str = "成功:部门经理同意【" + user +"】的聚餐费用，金额为" +fee +"元";

            }else{
                str = "失败: 部门经理不同意【" + user + "】的聚餐费用，金额为" + fee + "元";

            }

        }else{
            //超过1000，继续传递给级别高的人处理
            if (getSuccessor() != null) {
                return getSuccessor().handleFeeRequest(user, fee);

            }
        }
        return str;
    }

}

public class GeneralManager extends Handle {

    @Override
    public String handleFeeRequest(String user, double fee) {
        String str = null;
        //经理权限比较小，只能在500内
        if (fee >= 1000) {
            //只同意张三的请求
            if ("张三".equals(user)) {
                str = "成功:总经理同意【" + user +"】的聚餐费用，金额为" +fee +"元";

            }else{
                str = "失败: 总经理不同意【" + user + "】的聚餐费用，金额为" + fee + "元";

            }

        }else{
            //如果还有传递，继续传递给级别高的人处理
            if (getSuccessor() != null) {
                return getSuccessor().handleFeeRequest(user, fee);

            }
        }
        return str;
    }

}

测试运行类

public class Client {

    public static void main(String[] args) {
        //先要组装责任链
        Handle h1 = new GeneralManager();
        Handle h2 = new DeptManager();
        Handle h3 = new ProjectManager();

        h3.setSuccessor(h2);
        h2.setSuccessor(h1);

        //开始测试
        String test1 = h3.handleFeeRequest("张三", 300);
        System.out.println("test1 : " + test1);
        String test2 = h3.handleFeeRequest("李四", 300);
        System.out.println("test2 : " + test2);
        System.out.println("------------------------------");

        String test3 = h3.handleFeeRequest("张三", 700);
        System.out.println("test3 : " + test3);
        String test4 = h3.handleFeeRequest("李四", 700);
        System.out.println("test4 : " + test4);
        System.out.println("------------------------------");

        String test5 = h3.handleFeeRequest("张三", 1500);
        System.out.println("test5 : " + test5);
        String test6 = h3.handleFeeRequest("李四", 1500);
        System.out.println("test6 : " + test6);
    }
}

运行结果

test1 : 成功:项目经理同意【张三】的聚餐费用，金额为300.0元
test2 : 失败: 项目经理不同意【李四】的聚餐费用，金额为300.0元

test3 : 成功:部门经理同意【张三】的聚餐费用，金额为700.0元
test4 : 失败: 部门经理不同意【李四】的聚餐费用，金额为700.0元

test5 : 成功:总经理同意【张三】的聚餐费用，金额为1500.0元
test6 : 失败:总经理不同意【李四】的聚餐费用，金额为1500.0元

模式优缺点
优点：
1.降低耦合度，职责链模式将请求处理细节跟客户端代码隔离开来，这些细节对客户端是透明的，客户端只需要将相应的职责添加到链中即可，具体的处理过程交给责任链，降低了系统的耦合度。
2，增强了给对象指派责任的灵活性。
缺点：
1.不保证请求被接受；
2.由于责任链模式请求处理的不确定性，所以加大了程序的调试的难度
3.责任链模式对链中请求处理者的遍历，如果处理者太多遍历必定会影响性能，特别是在一些递归调用中，要谨慎。