9、责任链模式（Chain of Responsibility Pattern）

1. 责任链模式

1.1 简介

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

责任链模式屏蔽了请求的处理过程，你发起一个请求到底是谁处理的，这个你不用关心，只要你把请求抛给责任链的第一个处理者，最终会返回一个处理结果（当然也可以不做任何处理），作为请求者可以不用知道到底是需要谁来处理的，这是责任链模式的核心。

责任链就是从一个起点发起请求，然后沿着任务链依次传递给每一个节点上的对象，直到有一个节点处理这个请求为止。使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

1.2 Chain of Responsibility Pattern的uml

Chain的uml图如下：

image.png

Chain的角色：

Handler：执行者接口，setNext()并非必须，取决于整个流程的调度方式。使用setNext()可以进行链表式调度，或者不用转而采用数组循环调度。
BaseHandler：可选，可用来处理通用逻辑。
ConcreteHandlers：具体执行者，判断是否处理当前请求，无需处理或完成处理则传递给下一个执行者执行。分三种情况：处理完成结束本次请求直接返回结果，跳过本handler传递到下一个，执行完毕后传递给下一个执行者。

2. 实现示例

设计一个登陆网站，实现以下功能：

用户通过用户名密码登陆
密码错误三次则禁止登陆
访问页面前查询权限，未通过则直接返回
权限通过后访问页面

image.png

Handler：

public interface Handler {

    void handle(int level);

    void setNext(Handler handler);

    int getLevel();
}

AbstractHandler：

public abstract class AbstractHandler implements Handler {

    public Handler nexthandler;

    public void handle(int level) {
        if (getLevel() == level) {
            doAction();
        }
        if (this.nexthandler != null) {
            this.nexthandler.handle(getLevel() + 1);
        } else {
            System.out.println("处理结束");
            return;
        }
    }

    public abstract void doAction();

    @Override
    public void setNext(Handler handler) {
        this.nexthandler = handler;
    }
}

FailedHandler：

public class FailedHandler extends AbstractHandler {

    private int failTimes = 0;

    @Override
    public void doAction() {
        if (isLoginFailThree()) {
            System.out.println("密码错误超过3次禁止登陆！");
            this.nexthandler = null;
            return;
        }
    }

    private boolean isLoginFailThree() {
        if (failTimes < 3) {
            return false;
        }
        return true;
    }

    @Override
    public int getLevel() {
        return 1;
    }
}

LoginHandler：

public class LoginHandler extends AbstractHandler {

    private String password;

    @Override
    public void doAction() {
        if (!isValid()){
            System.out.println("登陆成功！");
            return;
        }
        System.out.println("密码错误，登陆失败！");
        this.nexthandler = null;
    }

    private boolean isValid() {
        if (password.equals("correct")) {
            return true;
        }
        return false;
    }

    @Override
    public int getLevel() {
        return 2;
    }
}

PermissionHandler：

public class PermissionHandler extends AbstractHandler {

    private int pemission;

    @Override
    public void doAction() {
        if (hasPermission()){
            System.out.println("权限校验通过，可以查看页面！");
            return;
        }
        System.out.println("权限校验未通过，禁止查看！");
        this.nexthandler = null;
    }

    private boolean hasPermission() {
        if (this.pemission > 2) {
            return true;
        }
        return false;
    }

    @Override
    public int getLevel() {
        return 3;
    }
}

ViewHandler：

public class ViewHandler extends AbstractHandler {

    @Override
    public void doAction() {
        System.out.println("view pages1");
        this.nexthandler = null;
    }

    @Override
    public int getLevel() {
        return 4;
    }
}

客户端调用：

   public static void main(String[] args) {
       Handler failHandler = new FailedHandler();
       Handler loginHandler = new LoginHandler();
       Handler permissionHandler = new PermissionHandler();
       Handler viewHandler = new ViewHandler();
       failHandler.setNext(loginHandler);
       loginHandler.setNext(permissionHandler);
       permissionHandler.setNext(viewHandler);
       failHandler.handle(1);
   }

3. 总结

优点：

低耦合，各个处理类间无依赖，每一个类可单独测试
可做到动态添加/删除处理类

缺点：

可能增加调试难度
对新接触项目代码的人，可能不太直观

适用性：

有多个对象可以处理一个请求，具体哪个对象处理该请求在运行时刻自动确定。
在请求的处理者不明确的情况下，向多个对象的一个提交请求。
需要动态指定一组对象处理请求。

通过把请求从一个对象传递到链条中下一个对象的方式，直到请求被处理完毕，以实现对象间的解耦。但责任链的缺点是，链条比较长，环节比较多的时候，由于采用了类似递归的方式，调试的时候逻辑可能比较复杂。

JDK中应用：
类加载的双亲委派模型，ClassLoader的委托模型