模式小故事

相信大家出差的都有过报销的经历吧！
小明负责一个异地的项目，去出差花费五万元，回来报销需要审批。
组长审批最大：500 元
主管审批最大：1000元
经理审批最大：5000元
老板审批最大：xxxx元
由于花费太高，所以要一层一层的向上报请求，就像链条一样，环环相扣，有首有尾，所以这就是责任链模式基本场景。

模式小案例UML：

模式小案例实现：

//领导
public abstract class Leader {
    Leader nextHandler;// 上级领导
    // 处理报账

    public final void handlerReq(int money) {
        if (money <= limit()) {
            handler(money);
        } else if (nextHandler != null) {
            nextHandler.handlerReq(money);
        } else {
            System.out.println("无法报销");
        }
    }

    abstract void handler(int money) ;

    abstract int limit();
}

//组长
public class GroupLeader extends Leader {

    @Override
    int limit() {
        return 500;
    }

    @Override
     void handler(int money) {
        System.out.println("组长报销了： " + money + " 元");
    }

}
//主管
public class Director extends Leader {

    @Override
    int limit() {
        return 1000;
    }

    @Override
    void handler(int money) {
        System.out.println("主管报销了： " + money + " 元");       
    }

}
//经理
public class Manager extends Leader {

    @Override
    int limit() {
        return 5000;
    }

    @Override
    void handler(int money) {
        System.out.println("经理报销了： " + money + " 元");       
    }

}
//老板
public class Boss extends Leader {

    @Override
    int limit() {
        return Integer.MAX_VALUE;
    }

    @Override
    void handler(int money) {
        System.out.println("老板报销了： " + money + " 元");       
    }

}
//小明报销：
public class Client {
    public static void main(String[] args) {
        GroupLeader groupLeader = new GroupLeader();
        Director director = new Director();
        Manager manager = new Manager();
        Boss boss = new Boss();
        
        groupLeader.nextHandler = director;
        director.nextHandler = manager;
        manager.nextHandler = boss;
        
        groupLeader.handlerReq(Integer.MAX_VALUE);
    }
}

模式最精简案例UML

模式最精简案例

public abstract class Handler {
    Handler successor;// 下一个节点处理者

    public abstract void handler(String req);
}
public class ConcreteAHandler extends Handler {

    @Override
    public void handler(String req) {
        if (req.equals("req1")) {
            System.out.println("命令：req1  执行完成");
            return;
        } else {
            this.successor.handler(req);
        }
    }

}
public class ConcreteBHandler extends Handler {

    @Override
    public void handler(String req) {
        if (req.equals("req2")) {
            System.out.println("命令：req2  执行完成");
            return;
        } else {
            if (this.successor == null) {
                System.out.println("无法处理请求！");
                return;
            }
            this.successor.handler(req);
        }
    }

}
public class Client {
    public static void main(String[] args) {
        // 构造节点
        ConcreteAHandler aReq = new ConcreteAHandler();
        ConcreteBHandler bReq = new ConcreteBHandler();

        // 设置节点
        aReq.successor = bReq;

        // 处理请求;
        aReq.handler("req1");

    }
}

模式优缺点

优点：
1、降低耦合度。它将请求的发送者和接收者解耦。
2、简化了对象。使得对象不需要知道链的结构。
3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。
4、增加新的请求处理类很方便。
缺点：
1、不能保证请求一定被接收。
2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。
3、可能不容易观察运行时的特征，有碍于除错。