设计模式学习总结：责任链模式

​ 本文为笔者在阅读一些书籍、博客、专栏等资料后所总结的个人对于责任链模式的笔记，由于笔者才疏学浅，若有不足之处，还望各位加以斧正，您的建议与鼓励都是笔者源源不断的前进动力。感谢！

文章大纲如下：

• 责任链模式的简单认识
• 责任链模式的简单应用
  • 两种责任链的实现方法：基于数组、链表
  • 责任链的一些简单应用
• 责任链模式在源码中的体现
• 责任链模式的优缺点

责任链模式简单认识

Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it. ---- 《设计模式》GoF

中文意思为：

通过给多个对象处理请求的机会，避免请求的发送方与其接收方耦合。将接收对象串起来，并沿着链传递请求，直到有一个对象处理它。

笔者的将其理解为：

现在有一条责任链（其中包含着各种接收对象，也可以理解为处理器，其具有处理请求的方法）。发送方对责任链发送请求，责任链中的对象A接收到请求后，若其能处理该请求，则处理，否则就向下一个对象传递请求，直到有一个对象能对其进行处理。整个过程形成一条链。

此外，责任链模式还有另一种实现方式，即

请求进入责任链，对象A接收到请求后，若需要处理，则处理，处理后传递给下一个对象；若不需要处理，则直接传递给下一个对象。也就是说，其最终都会将该对象传递给链上的下一个对象，以此类推，直到最后一个对象处理后，方结束。此变体中的请求会被责任链中的每个处理器（对象）处理。

责任链模式的简单应用

这两种责任链的实现方法

以下实现代码参考自王争先生在极客时间上的《设计模式之美》所展示的代码片段。我在其中注释部分加入了自己的理解、总结。

第一种责任链（即处理后就返回）

此责任链的实现方法有两种，分别是数组实现和链表实现。

• 数组实现

数组实现的大致模板：

/**
 * 处理者接口，定义了处理者的行为
 */
interface IHandler {
    boolean handle();
}

/**
 * 处理者A
 */
class HandlerA implements IHandler  {
    @Override
    public boolean handle() {
        boolean status = true;
        // 此处省略处理任务的方法……
        // 如果任务被处理了，就令status为true；否则令其为false
        System.out.println("[HandlerA]: status is " + status);
        return status;
    }
}

/**
 * 处理者B
 */
class HandlerB implements IHandler  {
    @Override
    public boolean handle() {
        boolean status = true;
        // 此处省略处理任务的方法……
        // 如果任务被处理了，就令status为true；否则令其为false
        System.out.println("[HandlerB]: status is " + status);
        return status;
    }
}

/**
 * 责任链
 */
class HandlerChain {
    // 责任链的数组存储对象
    private List<IHandler> handlerList = new ArrayList<>();
    
    // 向数组中添加handler的方法，添加成功返回true，反之为false
    public boolean addHandler(IHandler handler) {
        return this.handlerList.add(handler);
    }
    
    // 责任链调用处理者去处理请求
    public void handle() {
        // 遍历责任链上的处理者
        for (IHandler handler : handlerList) {
            boolean status = handler.handle();
            // 如果处理者返回的是true，就说明已经处理请求了，可以退出遍历了
            // 反之，继续遍历，直到被处理
            if (status == true) {
                break;
            }
        }
    }
}

/**
 * 基于数组实现的责任链（处理后就停止的责任链）
 */
public class Demo {
    public static void main(String[] args) {
        HandlerChain handlerChain = new HandlerChain();
        handlerChain.addHandler(new HandlerA());
        handlerChain.addHandler(new HandlerB());
        handlerChain.handle();
    }
}

输出结果为：

可见，HandleA处理了请求后，就不再往后传递请求了。

• 链表实现

链表实现的大致模板：

/**
 * 处理者抽象类，定义了处理者的行为
 */
abstract class IHandler {
    // 下一个处理者
    protected IHandler nextHandler;

    // 子类需要实现的处理方法
    protected abstract boolean doHandle();

    // 设置下一个处理者
    public void setNextHandler(IHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    // 获取下一个处理者
    public IHandler getNextHandler() {
        return this.nextHandler;
    }

    // 父类调用子类的处理方法判断是否向后传递请求
    public final void handle() {
        boolean status = doHandle();
        if ((!status) && (this.nextHandler != null)) {
            this.nextHandler.handle();
        }
    }
}

/**
 * 处理者A
 */
class HandlerA extends IHandler  {
    @Override
    public boolean doHandle() {
        boolean status = false;
        // 此处省略处理任务的方法……
        // 如果任务被处理了，就令status为true；否则令其为false
        System.out.println("[HandlerA]: status is " + status);
        return status;
    }
}

/**
 * 处理者B
 */
class HandlerB extends IHandler  {
    @Override
    public boolean doHandle() {
        boolean status = true;
        // 此处省略处理任务的方法……
        // 如果任务被处理了，就令status为true；否则令其为false
        System.out.println("[HandlerB]: status is " + status);
        return status;
    }
}

/**
 * 责任链
 */
class HandlerChain {
    // 责任链的头结点
    private IHandler headHandler;
    // 责任链的尾结点
    private IHandler tailHandler;

    // 向责任链中添加处理者
    public void addHandler(IHandler handler) {
        // 把处理者的下一个结点设为空
        handler.setNextHandler(null);
        // 如果头结点为空，说明责任链现在没有任何处理者，此时把头结点和尾结点都设置为函数传入的IHandler实例
        if (this.headHandler == null) {
            this.headHandler = handler;
            this.tailHandler = handler;
            return; // 设置好后就返回，因为后面要给head非空时的情况赋值
        }
        // headHandler非空时，把传进来的结点加入到链表尾部
        this.tailHandler.setNextHandler(handler); 
        this.tailHandler = handler;
    }

    // 责任链调用处理者去处理请求
    public void handle() {
        if (this.headHandler != null) {
            this.headHandler.handle();
        }
    }
}

/**
 * 基于链表实现的责任链（处理后就停止的责任链）
 */
public class Demo {
    public static void main(String[] args) {
        HandlerChain handlerChain = new HandlerChain();
        handlerChain.addHandler(new HandlerA());
        handlerChain.addHandler(new HandlerB());
        handlerChain.handle();
    }
}

输出结果：

第二种责任链（一直往后传递）

此责任链的实现方法也是两种，即数组、链表实现。

• 数组实现

数组实现的大致模板：

/**
 * 处理者接口，定义了处理者的行为
 */
interface IHandler {
    // 实现类的处理方法
    void handle();
}

/**
 * 处理者A
 */
class HandlerA implements IHandler {
    @Override
    public void handle() {
        // 此处省略处理任务的方法…
        System.out.println("[HandlerA]: handle()");
    }
}

/**
 * 处理者B
 */
class HandlerB implements IHandler {
    @Override
    public void handle() {
        // 此处省略处理任务的方法……
        System.out.println("[HandlerB]: handle()");
    }
}

/**
 * 责任链
 */
class HandlerChain {
    // 责任链的存储对象
    List<IHandler> handlerList = new ArrayList<>();

    // 向责任链中添加处理者
    public HandlerChain addHandler(IHandler handler) {
        handlerList.add(handler);
        return this;
    }

    // 责任链调用处理者去处理请求
    public void handle() {
        for (IHandler handler : handlerList) {
            handler.handle();
        }
    }
}

/**
 * 基于数组实现的责任链（处理后就停止的责任链）
 */
public class Demo {
    public static void main(String[] args) {
        HandlerChain handlerChain = new HandlerChain();
        IHandler handlerA = new HandlerA();
        IHandler handlerB = new HandlerB();
        handlerChain.addHandler(handlerA).addHandler(handlerB);
        handlerChain.handle();
    }
}

输出结果：

• 链表实现

链表实现的大致模板：

/**
 * 处理者抽象类，定义了处理者的行为
 */
abstract class IHandler {
    // 下一个处理者
    protected IHandler nextHandler;

    // 子类需要实现的处理方法
    protected abstract void doHandle();

    // 设置下一个处理者
    public void setNextHandler(IHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    // 获取下一个处理者
    public IHandler getNextHandler() {
        return this.nextHandler;
    }

    // 父类调用子类的处理方法并向后请求
    public final void handle() {
        doHandle();
        // 与前一种责任链所不同的是，这里不需要通过前面是否处理判断是否传递，而是一直传递
        if (this.nextHandler != null) {
            System.out.println("[IHandler]-nextHandler: " + this.nextHandler.getClass());
            this.nextHandler.handle();
        }
    }
}

/**
 * 处理者A
 */
class HandlerA extends IHandler  {
    @Override
    public void doHandle() {
        // 此处省略处理任务的方法…
        System.out.println("[HandlerA]: doHandler()");
    }
}

/**
 * 处理者B
 */
class HandlerB extends IHandler  {
    @Override
    public void doHandle() {
        // 此处省略处理任务的方法……
        System.out.println("[HandlerB]: doHandler()");
    }
}

/**
 * 责任链
 */
class HandlerChain {
    // 责任链的头结点
    private IHandler headHandler;
    // 责任链的尾结点
    private IHandler tailHandler;

    // 向责任链中添加处理者
    public void addHandler(IHandler handler) {
        // 把处理者的下一个结点设为空
        handler.setNextHandler(null);
        // 如果头结点为空，说明责任链现在没有任何处理者，此时把头结点和尾结点都设置为函数传入的IHandler实例
        if (this.headHandler == null) {
            this.headHandler = handler;
            this.tailHandler = handler;
            return; // 设置好后就返回，因为后面要给head非空时的情况赋值
        }
        // headHandler非空时，把传进来的结点加入到链表尾部
        this.tailHandler.setNextHandler(handler);
        this.tailHandler = handler;
    }

    // 责任链调用处理者去处理请求
    public void handle() {
        if (this.headHandler != null) {
            this.headHandler.handle();
        }
    }
}

/**
 * 基于链表实现的责任链（处理后就停止的责任链）
 */
public class Demo {
    public static void main(String[] args) {
        HandlerChain handlerChain = new HandlerChain();
        handlerChain.addHandler(new HandlerA());
        handlerChain.addHandler(new HandlerB());
        handlerChain.handle();
    }
}

输出结果：

可以看到，HandlerA在处理了请求后，又传递给了HandlerB，HandlerB也对请求进行了处理。

责任链的一些应用

一个小案例

假设有一场景如下：我们需要对用户的登录请求进行登陆前的数据校验、登录表单的数据校验、权限数据的校验。

在这样的场景中，我们通常会这样去实现（模拟实现，省略了部分操作、代码）：

public class Demo {
    public boolean login(User user) {
        String userName = user.getUserName();
        String password = user.getPassword();
        // 非空校验（数据校验部分）
        if (StringUtils.isEmpty(userName) && StringUtils.isEmpty(password)) {
            System.out.println("数据校验不通过！");
            return false;
        }
        System.out.println("数据校验通过！");

        // 用户名、密码校验，模拟验证
        if (userName != "xingzhi" && password != "987") {
            System.out.println("用户名或密码错误！");
            return false;
        }
        System.out.println("用户名、密码校验通过！");
        user.setRoleName("visitor");

        // 用户角色校验
        if (user.getRoleName() != "admin") {
            System.out.println("无权限登录！");
            return false;
        }
        System.out.println("权限验证通过");
        return true;
    }

    // 模拟登录接口调用
    public static void main(String[] args) {
        Demo demo = new Demo();
        User user = new User().setUserName("xingzhi").setPassword("987");
        if (demo.login(user)) {
            System.out.println("登陆成功！");
        } else {
            System.out.println("登陆失败！");
        }
    }
}

// 模拟一个用户类
class User {
    private String userName;
    private String password;
    private String roleName;

    public String getUserName() {
        return userName;
    }

    public User setUserName(String userName) {
        this.userName = userName;
        return this;
    }

    public String getPassword() {
        return password;
    }

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

    public String getRoleName() {
        return roleName;
    }

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

输出结果如下：

这样确实把需求实现了，但是

根据这一场景，责任链模式是一个很好的选择。因为进行完一个校验后还需要后续的校验，所以我们选择使用第二种责任链的链表实现方式来完成需求（需要注意的是，当某一处理者不通过时，就不往下传递了，所以我在Ihandler接口类中新增了handlerStatus属性用来记录处理者的处理状态）。代码如下：（但我感觉我这个案例可能不太好.....）

/** 处理者父类 */
abstract class abstractHandler {
    // 下一个处理者
    protected abstractHandler nextHandler;
    protected boolean handlerStatus;

    // 子类需要实现的处理方法
    protected abstract boolean doHandle(User user);

    // 设置下一个处理者
    public void setNextHandler(abstractHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    // 获取下一个处理者
    public abstractHandler getNextHandler() {
        return this.nextHandler;
    }

    // 父类调用子类的处理方法并向后请求
    public final boolean handle(User user) {
        handlerStatus = doHandle(user);
        if (!handlerStatus) return false;
        // 与前一种责任链所不同的是，这里不需要通过前面是否处理判断是否传递，而是一直传递
        if (this.nextHandler != null) {
            System.out.println("[IHandler]-nextHandler: " + this.nextHandler.getClass());
            this.nextHandler.handle(user);
        }
        return true;
    }
}

/**
 * 数据校验处理者
 */
class ValidateHandler extends abstractHandler {
    @Override
    public boolean doHandle(User user) {
        System.out.println("[ValidateHandler]: doHandler()");
        // 如果用户名和密码不为空，则进行处理
        if (!StringUtils.isEmpty(user.getUserName()) && !StringUtils.isEmpty(user.getPassword())) {
            System.out.println("数据校验成功！");
            return true;
        } else {
            System.out.println("数据格式不通过！");
            return false;
        }
    }
}

/**
 * 身份校验处理者
 */
class AuthenticationHandler extends abstractHandler {
    @Override
    public boolean doHandle(User user) {
        System.out.println("[AuthenticationHandler]: doHandler()");
        if ("xingzhi".equals(user.getUserName()) && "987".equals(user.getPassword())) {
            user.setRoleName("admin");
            System.out.println("身份验证通过！");
            return true;
        } else {
            System.out.println("身份验证不通过！");
            return false;
        }
    }
}

/** 角色校验处理者 */
class RoleHandler extends abstractHandler {
    @Override
    public boolean doHandle(User user) {
        System.out.println("[RoleHandler]: doHandler()");
        if ("admin".equals(user.getRoleName())) {
            System.out.println("橘色校验通过！");
            return true;
        } else {
            System.out.println("角色校验不通过！");
            return false;
        }
    }
}

/**
 * 责任链
 */
class LoginHandlerChain {
    // 责任链的头结点
    private abstractHandler headHandler;
    // 责任链的尾结点
    private abstractHandler tailHandler;

    // 向责任链中添加处理者
    public LoginHandlerChain addHandler(abstractHandler handler) {
        // 把处理者的下一个结点设为空
        handler.setNextHandler(null);
        // 如果头结点为空，说明责任链现在没有任何处理者，此时把头结点和尾结点都设置为函数传入的IHandler实例
        if (this.headHandler == null) {
            this.headHandler = handler;
            this.tailHandler = handler;
            return this; // 设置好后就返回，因为后面要给head非空时的情况赋值
        }
        // headHandler非空时，把传进来的结点加入到链表尾部
        this.tailHandler.setNextHandler(handler);
        this.tailHandler = handler;
        return this;
    }

    // 责任链调用处理者去处理请求
    public boolean handle(User user) {
        if (this.headHandler != null) {
            return this.headHandler.handle(user);
        }
        return false;
    }
}

// 模拟一个用户类
class User {
    private String userName;
    private String password;
    private String roleName;
    private String Permission;

    public String getUserName() {
        return userName;
    }

    public User setUserName(String userName) {
        this.userName = userName;
        return this;
    }

    public String getPassword() {
        return password;
    }

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

    public String getRoleName() {
        return roleName;
    }

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

    public String getPermission() {
        return Permission;
    }

    public User setPermission(String permission) {
        Permission = permission;
        return this;
    }
}

/**
 * 基于链表实现的责任链（处理后就停止的责任链）
 */
public class Demo {
    public static void main(String[] args) {
        User user = new User()
                .setUserName("xingzhi")
                .setPassword("987");
        LoginHandlerChain loginHandlerChain = new LoginHandlerChain()
                .addHandler(new ValidateHandler())
                .addHandler(new AuthenticationHandler())
                .addHandler(new RoleHandler());
        if (loginHandlerChain.handle(user)) {
            System.out.println("登陆成功！欢迎您：" + user.getUserName());
        } else {
            System.out.println("登陆失败！");
        };
    }
}

运行结果如图：

在这个场景中使用责任链模式就可以满足开闭原则，提高代码的扩展性。

比如，现在需要在角色认证后进行权限认证，这时我们只需要增加一个权限验证类就行了，但是我这个User类还得改改....所以我这个案例举得不太好（有点又臭又长了）....仅供参考...哈哈...

/** 权限校验处理者 */
class PermissionHandler extends abstractHandler {
    @Override
    public boolean doHandle(User user) {
        System.out.println("[PermissionHandler]: doHandler()");
        if ("menu:add".equals(user.getPermission())) {
            System.out.println("权限校验通过！");
            return true;
        } else {
            System.out.println("权限校验不通过！");
            return false;
        }
    }
}

责任链模式在源码中的体现

在看过了我的糟糕的案例后，我们来看看大师的作品，源码中的责任链模式：

/**
 * 先留个坑...有时间了来填...
 */

责任链模式的优缺点

最后，总结下责任链模式的优缺点。

优点

• 将请求的发送者和接收者解耦。
• 简化对象，减少代码的复杂性。（处理者不需要知道责任链的内部构造以及如何处理的）
• 满足开闭原则，提高代码的扩展性。（动态地新增或删除责任）

缺点

• 不容易观察运行时的特征，出现问题不好排查。（如果某一节点出现问题，则容易造成系统崩溃）
• 并不一定保证请求一定会执行。（责任链过长时，请求没被处理或者处理时间过长，会影响整体性能）