重温设计模式之责任链

简介

责任链模式:

责任链模式(Chain of Responsibility Pattern) 是将链中每一个节点看作是一个对象， 每个节点处理的请求均不同，且内部自动维护一个下一节点对象。当一个请求从链式的首端发出时，会沿着链的路径依次传递给每一个节点对象，直至有对象处理这个请求为止。属于行为型模式。

使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

责任链模式的应用场景:

在日常生活中责任链模式还是比较常见的，我们平时工作处理一些事务，往往是各部门协同合作的完成某一个任务。而每个部门都有各自的职责，因此，很多时候事情完成一半，便会转交给下一个部门，直到所有部门都过一遍之后事情才能完成。

责任链模式主要是解耦了请求与处理，客户只需将请求发送到链上即可，无需关心请求的具体内容和处理细节，请求会自动进行传递直至有节点对象进行处理。适用于以下应用场景：

多个对象可以处理同一请求，但具体由哪个对象处理则在运行时动态决定；
在不明确指定接收者的情况下，向多个对象中的一个提交一个请求；
可动态指定一组对象处理请求。
责任链模式主要包含两种角色：
抽象处理者(Handler) ：定义一个请求处理的方法， 并维护一个下一个处理节点Handler对象的引用；
具体处理者(Concrete Handler) ：对请求进行处理， 如果不感兴趣， 则进行转发。
　　责任链模式的本质是解耦请求与处理，让请求在处理链中能进行传递与被处理；理解责任链模式应当理解的是其模式(道)而不是其具体实现(术)，责任链模式的独到之处是其将节点处理者组合成了链式结构，并允许节点自身决定是否进行请求处理或转发，相当于让请求流动了起来。

实例

首先， 创建一个实体类User

public class User {

    private String name;

    private String password;

    private String roleName;

    public User(String name, String password, String roleName) {
        this.name = name;
        this.password = password;
        this.roleName = roleName;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }
}

然后定义UserService，模拟一个最简单的登录逻辑

public class UserService {

    public void login(String loginName, String loginPass) {
        if (StringUtils.isEmpty(loginName) ||
                StringUtils.isEmpty(loginPass)) {
            System.out.println("用户名和密码为空");
            return;
        }
        System.out.println("用户名和密码不为空，可以往下执行");

        User user = checkExists(loginName, loginPass);
        if (null == user) {
            System.out.println("用户不存在");
            return;
        }
        System.out.println("登录成功！");

        if (!"管理员".equals(user.getRoleName())) {
            System.out.println("您不是管理员，没有操作权限");
            return;
        }
        System.out.println("允许操作");
    }

    private User checkExists(String loginName, String loginPass) {
        User user = new User(loginName,loginPass,"管理员");
        return user;
    }
}

在这边我们可以看到，分成三块逻辑，校验用户密码是否为空，校验用户是否存在，校验用户是否有权限。其中都是需要用到user这个对象的，这个就很适合改造成责任链模式。

首先我们定义Handler

public abstract class Handler {

    //下一个调用链
    protected Handler next;

    public void next(Handler next) {
        this.next = next;
    }

    public abstract void doHandler(User user);
}

然后分别定义三个具体的handler处理类

public class ValidateHandler extends Handler {
    @Override
    public void doHandler(User user) {
        if (StringUtils.isEmpty(user.getName()) ||
                StringUtils.isEmpty(user.getPassword())) {
            System.out.println("用户名和密码为空");
            return;
        }
        System.out.println("用户名和密码不为空，可以往下执行");
        next.doHandler(user);
    }
}

public class LoginHandler extends Handler{
    @Override
    public void doHandler(User user) {
        System.out.println("登录成功！");
        user.setRoleName("管理员");
        next.doHandler(user);
    }
}

public class AuthHandler extends Handler {
    @Override
    public void doHandler(User user) {
        if (!"管理员".equals(user.getRoleName())) {
            System.out.println("您不是管理员，没有操作权限");
            return;
        }
        System.out.println("允许操作");
    }
}

然后将三个handler串在一起定义service

public class NewUserService {

    public void login(String loginName,String loginPass){
        Handler validateHandler = new ValidateHandler();
        Handler loginHandler = new LoginHandler();
        Handler authHandler = new AuthHandler();
        validateHandler.next(loginHandler);
        loginHandler.next(authHandler);
        validateHandler.doHandler(new User(loginName,loginPass,"管理员"));
    }

    public static void main(String[] args) {
        NewUserService userService = new NewUserService();
        userService.login("lulf","999");
    }
}

其实我们平时使用的很多权限校验框架都是运用这样一个原理，将各个维度的权限处理解耦之后再串联起来， 各自只处理各自相关的职责。如果职责与自己不相关则抛给链上的下一个Handler， 俗称踢皮球。

责任链模式和建造者模式结合使用

因为责任链模式具备链式结构，而上面代码中，我们看到，负责组装链式结构的角色是 UserService， 当链式结构较长时， UserService的工作会非常繁琐， 并且UserService代码相对臃肿， 且后续更改处理者或消息类型时， 都必须在UserService中进行修改， 不符合开闭原则。产生这些问题的原因就是因为链式结构的组装过于复杂，而对于复杂结构的创建，很自然我们就会想到建造者模式， 使用建造者模式， 我们完全可以对UserService指定的处理节点对象进行自动链式组装，客户只需指定处理节点对象，其他任何事情都无需关心，并且客户指定的处理节点对象顺序不同， 构造出来的链式结构也随之不同。我们来改造一下Handler

public abstract class Handler<T> {

    //下一个调用链
    protected Handler next;

    public void next(Handler next) {
        this.next = next;
    }

    public abstract void doHandler(User user);

    public static class Builder<T> {
        private Handler<T> head;
        private Handler<T> tail;

        public Builder<T> addHandler(Handler handler) {
//            do {
            if (this.head == null) {
                this.head = this.tail = handler;
                return this;
            }
            this.tail.next(handler);
            this.tail = handler;
//            }while (false);//真正框架中，如果是双向链表，会判断是否已经到了尾部
            return this;
        }

        public Handler<T> build() {
            return this.head;
        }
    }
}

因为建造者模式要构建的是节点处理者， 因此我们把Builder作为Handler的静态内部类， 并且因为客户端无需进行链式组装， 因此我们还可以把链式组装方法next() 方法设置为private， 使Handler更加高内聚。
然后改造UserService

public class NewUserService {

    public void login(String loginName,String loginPass){
        Handler.Builder builder = new Handler.Builder();

        builder.addHandler(new ValidateHandler())
                .addHandler(new LoginHandler())
                .addHandler(new AuthHandler());

        builder.build().doHandler(new User(loginName,loginPass,"管理员"));

    }

    public static void main(String[] args) {
        NewUserService userService = new NewUserService();
        userService.login("lulf","999");
    }
}

优点：

将请求与处理解耦；
请求处理者(节点对象)只需关注自己感兴趣的请求进行处理即可，对于不感兴趣的请求，直接转发给下一级节点对象；
具备链式传递处理请求功能，请求发送者无需知晓链路结构，只需等待请求处理结果；
链路结构灵活，可以通过改变链路结构动态地新增或删减责任；
易于扩展新的请求处理类(节点)，符合开闭原则。

缺点：
责任链太长或者处理时间过长，会影响整体性能
如果节点对象存在循环引用时，会造成死循环，导致系统崩溃；