设计模式之责任链模式

举报
炒香菇的书呆子 发表于 2022/05/22 23:45:23 2022/05/22
【摘要】 责任链模式是什么责任链模式是一种行为型设计模式,也就是重点是处理数据,假设我们有一份数据,需要经过很多个节点处理,那么就会是以下这个样子:一个节点处理完之后,交给下一个节点,不知道大家有没有使用过审批流,当我们提完一个审批单后,你的leader审批,leader审批通过之后就是总监批,总监后面可能是高级总监,或者cto,或者hr。他们在同一个链条上,倘若你的leader没有审批完,后面的节...

责任链模式是什么

责任链模式是一种行为型设计模式,也就是重点是处理数据,假设我们有一份数据,需要经过很多个节点处理,那么就会是以下这个样子:

一个节点处理完之后,交给下一个节点,不知道大家有没有使用过审批流,当我们提完一个审批单后,你的leader审批,leader审批通过之后就是总监批,总监后面可能是高级总监,或者cto,或者hr。他们在同一个链条上,倘若你的leader没有审批完,后面的节点是不可能收到信息的。如果你的leader拒绝了你的申请,那数据也不会到达后面的审批节点。

如果你接触过前端,JS 中点击某个 div 的时候会产生冒泡事件,也就是点击下面的A, AB里面,BC里面, A-> B -> C 会依次收到点击事件:

再举个例子,在 SpringMVC中,我们有时候会定义一些拦截器,对请求进行预处理,也就是请求过来的时候,会依次经历拦截器,通过拦截器之后才会进入我们的处理业务逻辑代码。

之前,在做人员管理的时候,有涉及到人员离职情况的处理流程,要交接工作,解除权限,禁用账号等等,这整个处理流程就很适合使用责任链来处理。当然,自动处理流程是会出错的,保存每一个阶段的状态,针对出错的场景,可以手动去从断开责任链的地方接着执行。这整个流程的框架就是应用了责任链,但是根据实际场景也添加了不少其他的东西。

两点疑问

  1. 责任链的每一个节点是不是一定包含下一个节点的引用?

答:不一定,要么把所有责任节点放在一个list里面,依次处理;要么每个节点包含下一个责任节点的引用,

  1. 责任链到底是不允许中断还是不允许中断?

答:两种都可以,不拘泥于细节,可以根据自己的场景使用。

责任链模式中的角色

责任链一般有以下的角色:

  • Client(客户端):调用责任链处理器的处理方法,或者在第一个链对象中调用handle方法。
  • Handler(处理器):抽象类,提供给实际处理器继承然后实现handle方法,处理请求
  • ConcreteHandler(具体处理器):实现handler的类,同时实现handle方法,负责处理业务逻辑类,不同业务模块有不同的ConcreteHandler
  • HandlerChain:负责组合责任链的所有节点以及流程(如果节点包含下一个节点的引用,那么HandlerChain可以不存在)

审批链的实现

下面我们分别来实现不同的写法,假设现在有一个场景,秦怀入职了一家公司,哼哧哼哧干了一年,但是一直没调薪,又过了一年,总得加薪了吧,不加就要提桶跑路了,于是秦怀大胆去内部系统提了一个申请单:【加薪申请】

不中断模式

先演示不中断模式,得先弄个申请单的实体,里面包含了申请单的名字和申请人:

public class Requisition {
    // 名称
    public String name;


    // 申请人
    public String applicant;


    public Requisition(String name, String applicant) {
        this.name = name;
        this.applicant = applicant;
    }
}

责任链中的每个责任节点,也就是处理器,可以抽象成为一个接口:

public interface Handler {
    // 处理申请单
    void process(Requisition requisition);
}

我们依次实现了三个不同的责任节点,分别代表leader,总监,hr审批:

public class ManagerHandler implements Handler {
    @Override
    public void process(Requisition requisition) {
        System.out.println(String.format("Manager 审批来自[%s]的申请单[%s]...", requisition.applicant, requisition.name));
    }
}
public class DirectorHandler implements Handler{
    @Override
    public void process(Requisition requisition) {
        System.out.println(String.format("Director 审批来自[%s]的申请单[%s]...", requisition.applicant, requisition.name));
    }
}
public class HrHandler implements Handler{
    @Override
    public void process(Requisition requisition) {
        System.out.println(String.format("Hr 审批来自[%s]的申请单[%s]...", requisition.applicant, requisition.name));
    }
}

责任节点都有了,我们需要用一个责任链把它们组合起来:

public class HandlerChain {
    List<Handler> handlers = new ArrayList<>();


    public void addHandler(Handler handler){
        handlers.add(handler);
    }


    public void handle(Requisition requisition){
        for(Handler handler:handlers){
            handler.process(requisition);
        }
        System.out.println(String.format("来自[%s]的申请单[%s]审批完成", requisition.applicant, requisition.name));
    }
}

客户端测试类:

public class ClientTest {
    public static void main(String[] args) {
        HandlerChain handlerChain = new HandlerChain();
        handlerChain.addHandler(new ManagerHandler());
        handlerChain.addHandler(new DirectorHandler());
        handlerChain.addHandler(new HrHandler());
        handlerChain.handle(new Requisition("加薪申请","秦怀"));
    }
}

运行结果:

Manager 审批来自[秦怀]的申请单[加薪申请]...
Director 审批来自[秦怀]的申请单[加薪申请]...
Hr 审批来自[秦怀]的申请单[加薪申请]...
来自[秦怀]的申请单[加薪申请]审批完成

从结果上来看,申请单确实经历过了每一个节点,形成了一条链条,这就是责任链的核心思想。每个节点拿到的都是同一个数据,同一个申请单。

中断模式

秦怀加薪的想法很美好,但是现实很骨感,上面的审批流程一路畅通,但是万一 Hr 想拒绝掉这个申请单了,上面的代码并没有赋予她这种能力,因此,代码得改!(Hr 内心:我就要这个功能,明天上线)。

既然是支持中断,也就是支持任何一个节点审批不通过就直接返回,不会再走到下一个节点,先给抽象的处理节点方法加上返回值:

public interface Handler {
    // 处理申请单
    boolean process(Requisition requisition);
}

三个处理节点也同步修改:

public class ManagerHandler implements Handler {
    @Override
    public boolean process(Requisition requisition) {
        System.out.println(String.format("Manager 审批通过来自[%s]的申请单[%s]...", requisition.applicant, requisition.name));
        return true;
    }
}
public class DirectorHandler implements Handler{
    @Override
    public boolean process(Requisition requisition) {
        System.out.println(String.format("Director 审批通过来自[%s]的申请单[%s]...", requisition.applicant, requisition.name));
        return true;
    }
}
public class HrHandler implements Handler{
    @Override
    public boolean process(Requisition requisition) {
        System.out.println(String.format("Hr 审批不通过来自[%s]的申请单[%s]...", requisition.applicant, requisition.name));
        return false;
    }
}

处理链调整:

public class HandlerChain {
    List<Handler> handlers = new ArrayList<>();


    public void addHandler(Handler handler) {
        handlers.add(handler);
    }


    public void handle(Requisition requisition) {
        for (Handler handler : handlers) {
            if (!handler.process(requisition)) {
                System.out.println(String.format("来自[%s]的申请单[%s]审批不通过", requisition.applicant, requisition.name));
                return;
            }
        }
        System.out.println(String.format("来自[%s]的申请单[%s]审批完成", requisition.applicant, requisition.name));
    }
}

修改完成之后的结果:

Manager 审批通过来自[秦怀]的申请单[加薪申请]...
Director 审批通过来自[秦怀]的申请单[加薪申请]...
Hr 审批不通过来自[秦怀]的申请单[加薪申请]...
来自[秦怀]的申请单[加薪申请]审批不通过

秦怀哭了,加薪的审批被 hr 拒绝了。虽然被拒绝了,但是秦怀也感受到了可以中断的责任链模式,这种写法在处理请求的时候也比较常见,因为我们不希望不合法的请求到正常的处理逻辑中。

包含下一个节点的引用

前面说过,**在责任链模式里,很多对象由每一个对象对其下家的引用而连接起来形成一条链。**上面的写法都是不包含下一个节点引用的写法。下面我们实践一下,如何使用引用写法完成责任链。

改造Handler接口为抽象类:

public abstract class Handler {

    private Handler nextHandler;

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

    // 处理申请单
    protected abstract boolean process(Requisition requisition);

    // 暴露方法
    public boolean handle(Requisition requisition) {
        boolean result = process(requisition);
        if (result) {
            if (nextHandler != null) {
                return nextHandler.handle(requisition);
            } else {
                return true;
            }
        }
        return false;
    }
}

三个实现类不变:

public class ManagerHandler extends Handler{
    @Override
    boolean process(Requisition requisition) {
        System.out.println(String.format(
                "Manager 审批通过来自[%s]的申请单[%s]...", requisition.applicant, requisition.name));
        return true;
    }
}
public class DirectorHandler extends Handler {
    @Override
    public boolean process(Requisition requisition) {
        System.out.println(String.format(
                "Director 审批通过来自[%s]的申请单[%s]...", requisition.applicant, requisition.name));
        return true;
    }
}

public class HrHandler extends Handler{
    @Override
    public boolean process(Requisition requisition) {
        System.out.println(String.format("Hr 审批不通过来自[%s]的申请单[%s]...",
                requisition.applicant, requisition.name));
        return false;
    }
}

测试方法,构造嵌套引用:

public class ClientTest {
    public static void main(String[] args) {
        HrHandler hrHandler = new HrHandler();
        DirectorHandler directorHandler = new DirectorHandler();
        directorHandler.setNextHandler(hrHandler);
        ManagerHandler managerHandler = new ManagerHandler();
        managerHandler.setNextHandler(directorHandler);

        managerHandler.handle(new Requisition("加薪申请","秦怀"));
    }
}

可以看到运行结果也是一样:

Manager 审批通过来自[秦怀]的申请单[加薪申请]...
Director 审批通过来自[秦怀]的申请单[加薪申请]...
Hr 审批不通过来自[秦怀]的申请单[加薪申请]...

拓展一下

其实责任链配合上Spring更加好用,主要有两点:

1、可以使用注入,自动识别该接口的所有实现类。

@Autowire
public List<Handler> handlers;

2、可以使用@Order注解,让接口实现类按照顺序执行。

@Order(1)
public class HrHandler extends Handler{
  ...
}

源码中的应用

  • Mybatis 中的 Plugin 机制使用了责任链模式,配置各种官方或者自定义的 Plugin,与 Filter 类似,可以在执行 Sql 语句的时候执行一些操作。
  • Spring中使用责任链模式来管理Adviser

比如Mybatis中可以添加若干的插件,比如PageHelper,多个插件对对象的包装采用的动态代理来实现,多层代理。

//责任链插件
public class InterceptorChain {

  private final List<Interceptor> interceptors = new ArrayList<>();
  // 生成代理对象
  public Object pluginAll(Object target) {
    for (Interceptor interceptor : interceptors) {
      target = interceptor.plugin(target);
    }
    return target;
  }
  //一层一层的拦截器
  public void addInterceptor(Interceptor interceptor) {
    interceptors.add(interceptor);
  }

  public List<Interceptor> getInterceptors() {
    return Collections.unmodifiableList(interceptors);
  }

}

总结

责任链模式的优点:

  • 降低对象直接的耦合度,对象会自动传递到下一个责任节点,不管是引用方式,还是非引用方式。
  • 增强拓展性,如果需要添加新的责任节点,也比较方便,实现特定的接口即可。
  • 责任节点的顺序可控,可以指定一个顺序属性,排序即可。
  • 每个责任节点职责专一,只处理自己的任务,符合类的单一职责原则。

责任链的缺点:

  • 如果责任链比较长,性能会受影响。
  • 责任链可能会中途断掉,请求不一定会被接收。

责任链一般是在流程化的处理中,多个节点处理同一份数据,依次传递,可能有顺序要求,也可能没有,处理器的能力抽象成接口,方便拓展。

【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息, 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。