Java设计模式-责任链(九)

责任链定义

责任链模式是一种对象的行为模式。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任

责任链涉及到对象

抽象处理者:一个方法控制当前节点需要处理或执行的任务，是否需要提交给下一个节点处理；另一个抽象的执行当前节点的任务方法

具体处理者:实现处理当前节点自己的任务

比如我们平时项目组团建需要申请经费，申请人------>项目经理----->部门经理----->大boss 审批流程。

不同的领导职位 审批经费额度是不同的。比如项目经理范围 小于等于500，部门经理的审批范围是小于等于1000，大boss 随意。规则:如果不在自己的范围就提交给上级。

抽象的处理者

public abstract class AbstractApprovaHandler {
    public AbstractApprovaHandler(AbstractApprovaHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public AbstractApprovaHandler() {
    }

    /**
     * 下一个处理节点
     * */
    protected AbstractApprovaHandler nextHandler;

    public Boolean submit(Integer fees){
        //审批结果
        Boolean approvaResult = doHandler(fees);
        if(approvaResult){
            //下一个处理节点不为空,交给下一个人处理
            if(nextHandler!=null){
                return nextHandler.submit(fees);
            }
        }
        return approvaResult;
    }
	/** 抽象的处理方法，子类实现具体处理*/
    protected abstract Boolean doHandler(Integer fees);
}
           

项目经理处理节点

public class ProjectManagerApprovaHandler extends AbstractApprovaHandler{
    public ProjectManagerApprovaHandler() {
    }

    public ProjectManagerApprovaHandler(AbstractApprovaHandler nextHandler) {
        super(nextHandler);
    }

    @Override
    protected Boolean doHandler(Integer fees) {
        //小于等于500在自己的审批范围下
        if(fees<=500){
            //TODO 是否同意
            System.out.println("项目经理:同意");
            return true;
        }else{
            //不在自己的范围内，直接过
            System.out.println("项目经理:不在自己的审批范围内,提交至上级领导");
            return true;
        }
    }
}
           

部门经理处理节点

public class DeptManagerApprovaHandler extends AbstractApprovaHandler{
    public DeptManagerApprovaHandler() {
    }

    public DeptManagerApprovaHandler(AbstractApprovaHandler nextHandler) {
        super(nextHandler);
    }

    @Override
    protected Boolean doHandler(Integer fees) {
        //小于等于1000在自己的审批范围下
        if(fees<=1000){
            //TODO 是否同意
            System.out.println("部门经理:同意");
            return true;
        }else{
            //不在自己的范围内，直接过
            System.out.println("部门经理:不在自己的审批范围内,提交至上级领导");
            return true;
        }
    }
}
           

大boss处理节点

public class BossManagerApprovaHandler extends AbstractApprovaHandler{
    public BossManagerApprovaHandler() {
    }

    public BossManagerApprovaHandler(AbstractApprovaHandler nextHandler) {
        super(nextHandler);
    }

    @Override
    protected Boolean doHandler(Integer fees) {
        //TODO 是否同意
        System.out.println("大boss:同意");
        return true;
    }
}
           

客户端调用类

public class ApprovalClient {
    public static void main(String[] args) {
        /*//部门经理
        AbstractApprovaHandler dept = new DeptManagerApprovaHandler();
        //项目经理
        AbstractApprovaHandler project = new ProjectManagerApprovaHandler(dept);
        System.out.println(project.submit(600));*/

        //大boss
        AbstractApprovaHandler boss = new BossManagerApprovaHandler();
        //部门经理
        AbstractApprovaHandler dept = new DeptManagerApprovaHandler(boss);
        //项目经理
        AbstractApprovaHandler project = new ProjectManagerApprovaHandler(dept);
        System.out.println(project.submit(1200));
    }
}
           

其实这种责任链是不纯洁的，纯洁的责任链是当前节点要么处理要么不处理提交给下一个节点，不允许出现某一个具体处理者对象在承担了一部分责任后又把责任向下传的情况。而我们在实际开发中纯洁的责任链很少，反而是非纯洁的用的很多，就是当前节点处理自己的任务后提交给下一节点。

责任链设计优点

实现了请求发送者与请求处理者之间的松耦合

可动态添加责任对象、删除责任对象、改变责任对象顺序，非常灵活

每个责任对象专注于做自己的事情，职责明确