Java设计模式之责任链模式（二）

在上一篇文章中详细的介绍了什么是责任链模式，或许Demo做的有一些些深，创建的类也比较多，为了让刚入门Java的同学能更容易理解，小生重写一个更为清晰的Demo（大神绕道）

还是上一篇文章的逻辑，此处强调一点就是，链接上的请求可以是一条链，可以是一个树，还可以是一个环，模式本身不约束这个，需要我们自己去实现，同时，在一个时刻，命令只允许由一个对象传给另一个对象，而不允许传给多个对象。

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

在以下条件下可考虑使用Chain of Responsibility：

1. 有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。
2. 你想在不明确指定接受者的情况下，想过个对象中的一个提交一个请求。
3. 可处理一个请求的对象集合应该被动态指定。

介绍到这里，详细可以看上一篇文章Java设计模式之责任链模式

我们来模拟一下场景，一个公司的报销流程：

项目经理<部门经理<总经理

其中项目经理报销额度不能大于500，则部门经理的报销额度是不大于1000，超过1000则需要总经理审核

有权处理类

public abstract class ConsumeHandler {
    private ConsumeHandler nextHandler;

    public ConsumeHandler getNextHandler() {
        return nextHandler;
    }

    public void setNextHandler(ConsumeHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    /** user申请人 free报销费用 */
    public abstract void doHandler(String user, double free);
}

项目经理类

public class ProjectHandler extends ConsumeHandler {
    @Override
    public void doHandler(String user, double free) {
        if (free < 500){
            if (user.equals("lwx")){
                System.out.println("给予报销:" + free);
            }else {
                System.out.println("报销不通过");
            }
        }else {
            if (getNextHandler() != null){
                getNextHandler().doHandler(user, free);
            }
        }
    }
}

部门经理类

public class DeptHandler extends ConsumeHandler{
    @Override
    public void doHandler(String user, double free) {
        if (free < 1000){
            if (user.equals("zy")){
                System.out.println("给予报销:" + free);
            }else {
                System.out.println("报销不通过");
            }
        }else {
            if (getNextHandler() != null){
                getNextHandler().doHandler(user, free);
            }
        }
    }
}

总经理类

public class GeneralHandler extends ConsumeHandler{
    @Override
    public void doHandler(String user, double free) {
        if (free >= 1000){
            if (user.equals("lwxzy")){
                System.out.println("给予报销:" + free);
            }else {
                System.out.println("报销不通过");
            }
        }else {
            if (getNextHandler() != null){
                getNextHandler().doHandler(user, free);
            }
        }
    }
}

场景类

public class main {
    public static void main(String[] args) {
        ProjectHandler projectHandler =new ProjectHandler();
        DeptHandler deptHandler =new DeptHandler();
        GeneralHandler generalHandler =new GeneralHandler();


        projectHandler.setNextHandler(deptHandler);
        deptHandler.setNextHandler(generalHandler);

        projectHandler.doHandler("lwx", 450);
        projectHandler.doHandler("lwx", 600);
        projectHandler.doHandler("zy", 600);
        projectHandler.doHandler("zy", 1500);
        projectHandler.doHandler("lwxzy", 1500);
    }
}

打印结果

给予报销:450.0
报销不通过
给予报销:600.0
报销不通过
给予报销:1500.0

比上一篇文章简单易懂，既然为设计模式，必然有其鲜明代码的主体框架，我们来分析下：

• 首先定义一个抽象的处理角色ConsumeHandler ，其次是具体实现类 ProjectHandler、DeptHandler、GeneralHandler，在每个实现类我们通过getNextHandler()来判断是否还有下一个责任链，如果有，则继续传递下去，调用getNextHandler().doHandler()来实现。