一文带你彻底搞懂什么是责任链模式！！

最新推荐文章于 2024-07-14 23:18:55 发布
最新推荐文章于 2024-07-14 23:18:55 发布
阅读量781 收藏 12
点赞数 23
分类专栏： 设计模式 文章标签： 责任链模式 java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63653444/article/details/140305014
版权

文章目录

在这里插入图片描述

什么是责任链模式？

在我们日常生活中，经常会出现一种场景：一个请求需要经过多个对象的处理才能得到最终的结果。比如，一个请假申请，需要经过组长、部门经理、总经理等多个级别的审批。这种场景下，使用责任链模式是一种非常优雅的解决方案。

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它的主要目的是将请求的发送者和接收者解耦，使得多个对象都有机会处理这个请求。这种模式通过将请求沿着处理者链进行传递，直到有一个对象处理它为止。

在这里插入图片描述

在责任链模式中，主要涉及以下三个角色：

  1. 抽象处理者（Handler）：处理器抽象接口，定义了处理请求的方法和执行下一步处理的处理器。
  2. 具体处理者（ConcreteHandler）：实现抽象处理者接口，具体处理请求的逻辑在这里实现。如果不能处理当前请求，则将请求传递给下一个处理者。
  3. 客户端（Client）：负责创建并组装责任链，将请求发送给链中的第一个处理者。

在这里插入图片描述

在这里插入图片描述

代码：

// 抽象处理器
public abstract class Handler {
    private Handler next;

    public Handler getNext() {
        return next;
    }

    public void setNext(Handler next) {
        this.next = next;
    }
    public abstract void handle(Object request);
}

// 具体处理器 1
public class ConcreteHandler1 extends Handler {
    @Override
    public void handle(Object request) {
        System.out.println("concrete handler 1 execute request. request: " + request);
        if (getNext() != null) {
            getNext().handle(request);
        }
    }
}

// 具体处理器 2
public class ConcreteHandler2 extends Handler {
    @Override
    public void handle(Object request) {
        System.out.println("concrete handler 2 execute request. request: " + request);
        if (getNext() != null){
            getNext().handle(request);
        }
    }
}

// 具体处理器 3
public class ConcreteHandler3 extends Handler {
    @Override
    public void handle(Object request) {
        System.out.println("concrete handler 3 execute request. request: " + request);
        if (getNext() != null) {
            getNext().handle(request);
        }
    }
}


public static void main(String[] args) {
    Handler concreteHandler1 = new ConcreteHandler1();
    Handler concreteHandler2 = new ConcreteHandler2();
    Handler concreteHandler3 = new ConcreteHandler3();

    concreteHandler1.setNext(concreteHandler2);
    concreteHandler2.setNext(concreteHandler3);

    concreteHandler1.handle("my request.");
}

从上面的代码我们可以看到其实责任链模式是非常简单的，但是其中有几个点需要注意一下：

  • 首先我们需要对整个责任链进行初始化，即设置每个处理器的 next。
  • 在每个具体处理器处理完之后需要手动调用下一个处理器的 handle 方法来执行下一步处理，这里其实还可以使用模板方法模式进行优化。

控制台输出如下：

concrete handler 1 execute request. request: my request.
concrete handler 2 execute request. request: my request.
concrete handler 3 execute request. request: my request.

详细示例

以日常请假为例。请假申请会先到你的直属 leader 处审批，审批通过后再到部门 leader 处审批，部门 leader 通过后，最后到人事处报备记录请假天数。

如果在传统企业里面，我们需要手写一份请假表，然后跑到直属 leader 办公室，让直属 leader 签字，然后再到部门 leader 办公室签字，最后还要跑到人事处上交请假单，这样相当于发出了三次请求，才能走完整个请假流程。

在这里插入图片描述

但是当我们使用责任链模式后整个请假流程就变的简单了，我们只需要发起一次请假请求，接下来你的请假请求便会自动的在审批人中间进行流转，这个时候我们的责任链模式便派上用场。

在这里插入图片描述

代码如下：

// 请假抽象处理器
public abstract class DayOffHandler {
    private DayOffHandler next;

    public DayOffHandler getNext() {
        return next;
    }

    public void setNext(DayOffHandler next) {
        this.next = next;
    }
    public abstract void handle(String request);

}
// 直属 leader 处理
public class GroupLeaderHandler extends DayOffHandler {
    @Override
    public void handle(String request) {
        System.out.println("直属 leader 审查: " + request);
        System.out.println("同意请求");
        if (getNext() != null) {
            getNext().handle(request);
        }
    }
}
// 部门 leader 处理
public class DepartmentLeaderHandler extends DayOffHandler{
    @Override
    public void handle(String request) {
        System.out.println("部门 leader 审查: " + request);
        System.out.println("同意请求");
        if (getNext() != null) {
            getNext().handle(request);
        }
    }
}
// 人事处处理
public class HRHandler extends DayOffHandler {
    @Override
    public void handle(String request) {
        System.out.println("人事处审查: " + request);
        System.out.println("同意请求，记录请假");
        if (getNext() != null) {
            getNext().handle(request);
        }
    }
}

客户端：

public static void main(String[] args) {

    DayOffHandler groupLeaderHandler = new GroupLeaderHandler();
    DayOffHandler departmentLeaderHandler = new DepartmentLeaderHandler();
    DayOffHandler hrHandler = new HRHandler();
    groupLeaderHandler.setNext(departmentLeaderHandler);
    departmentLeaderHandler.setNext(hrHandler);

    System.out.println("收到面试通知，需要请假");
    String request = "家中有事，请假半天，望批准";
    System.out.println("发起请求：");
    groupLeaderHandler.handle(request);
}

上面的代码定义了请假抽象处理类和三个具体的处理人，我们需要将这三个处理人的流程初始化串联起来，并且一步步的执行下去

结果：

收到面试通知，需要请假
发起请求：
直属 leader 审查: 家中有事，请假半天，望批准
同意请求
部门 leader 审查: 家中有事，请假半天，望批准
同意请求
人事处审查: 家中有事，请假半天，望批准
同意请求，记录请假

SpingMVC 中的责任链模式使用

在 SpringMVC 中的 Interceptor 用到了责任链模式。首先来看看 Interceptor 的抽象处理类;

public interface HandlerInterceptor {
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }

    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }

    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    }
}

在抽象处理类中，定义了三个方法，分别是处理前置处理器、后置处理器和整个流程完成之后的处理。通过 HandlerExecutionChain 将拦截器串联起来，在 HandlerExecutionChain 中，我们需要关注 applyPreHandle、applyPostHandle 和 triggerAfterCompletion 三个方法，这三个方法分别执行了拦截器中所定义的 preHandle 、postHandle 和 afterCompletion 方法。并且从代码中也能够看处，和前面的过滤器一样，所有的拦截器都存放在 interceptors 数组中，并在三个方法中遍历 interceptors 数组依次执行相应的方法

public class HandlerExecutionChain {
    @Nullable
    private HandlerInterceptor[] interceptors;

    boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HandlerInterceptor[] interceptors = this.getInterceptors();
        if (!ObjectUtils.isEmpty(interceptors)) {
            for(int i = 0; i < interceptors.length; this.interceptorIndex = i++) {
                HandlerInterceptor interceptor = interceptors[i];
                if (!interceptor.preHandle(request, response, this.handler)) {
                    this.triggerAfterCompletion(request, response, (Exception)null);
                    return false;
                }
            }
        }

        return true;
    }

    void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv) throws Exception {
        HandlerInterceptor[] interceptors = this.getInterceptors();
        if (!ObjectUtils.isEmpty(interceptors)) {
            for(int i = interceptors.length - 1; i >= 0; --i) {
                HandlerInterceptor interceptor = interceptors[i];
                interceptor.postHandle(request, response, this.handler, mv);
            }
        }

    }

    void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex) throws Exception {
        HandlerInterceptor[] interceptors = this.getInterceptors();
        if (!ObjectUtils.isEmpty(interceptors)) {
            for(int i = this.interceptorIndex; i >= 0; --i) {
                HandlerInterceptor interceptor = interceptors[i];

                try {
                    interceptor.afterCompletion(request, response, this.handler, ex);
                } catch (Throwable var8) {
                    logger.error("HandlerInterceptor.afterCompletion threw exception", var8);
                }
            }
        }

    }
}

总结

责任链模式是常见的设计模式，各个不同职责的处理器串联起来，通过一次请求便能够执行完每个处理器的处理方法。

通过这样的方式请求的发送者只需发出一次请求同时也不需要知道详细的链路结构；而请求的接送方只关心自己的处理逻辑，自己处理完成之后将请求传递给下一个接收者，从而完成自己的任务，这样便实现了请求发送者和接收者的解耦。

不决问春风
关注
  • 23
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一文彻底搞懂Java开发中常用的设计模式(1)
永远在路上
02-02 1416
Gang of Four（四人帮）在《设计模式：可复用面向对象软件的基础》一书中提出了23种设计模式，分为**创建型模式、结构型模式和行为型模式**，其中创建型模式5种，结构性模式7种，行为型模式11种。
一文彻底搞懂单例设计模式
qq_34800986的博客
03-12 166
所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例， 并且该类只提供一个取得其对象实例的方法(静态方法)。 比如 Hibernate 的 SessionFactory，它充当数据存储源的代理，并负责创建 Session 对象。SessionFactory 并不是轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory 就够，这是就会使用到单例模式。
一文搞懂策略模式(优化策略模式完全消除if else)
热门推荐
BookSea的博客
05-19 1万+
注重版权，转载请注明原作者和原文链接 作者：码农BookSea 原文链接：https://blog.csdn.net/bookssea/article/details/107309591 先看后赞，养成习惯。 点赞收藏，人生辉煌。 文章目录前言一、策略模式介绍二、策略模式应用(消除 if else)三、如何对策略模式进行优化总结 前言 策略模式是设计模式里面比较简单的设计模式，其特点简单又实用，是我最喜欢的模式之一。当初学策略模式是因为听说策略模式可以用来消除 if else语句。 多重条件语句.
一文彻底搞懂微服务架构
Java学习之道
09-26 2015
点击上方"Java学习之道"，选择"关注"公众号每天10:24，干货准时送达！本文链接：https://tinyurl.com/y6jhnszm本文将介绍微服务架构...
一文搞懂计算机网络
2301_77186032的博客
04-26 1759
计算机网络可以分为：广域网、城域网、局域网和个人区域网。广域网：覆盖几十到几千公里，比如我们日常说的上网，用百度、谷歌等，用的就是广域网。城域网：一般覆盖一个城市，大约 5 到 50 公里，比如有的城市的宽带。局域网：一般覆盖一公里左右，比如一个公司的内网。个人区域网：覆盖范围只有几米，比如自己给自己开热点。有人说，这些我都不在乎，我就在乎它快不快，看视频卡不卡，这就要提到网络的质量参数了。判断一个网络的质量有 7 个性能指标。速率：这个很好理解，就是传输速度。
开源软件 | 一文彻底搞懂许可证的定义、起源、分类及八大主流许可证，让你选型不再头疼
所有成功的背后，都是痛苦的坚持，所有的痛苦，都是傻瓜般的不放弃!
05-24 2243
开源许可证是一种法律协议，它规定了软件代码可以被如何使用、修改和分发。其中，著作权是指对于软件代码的创作者所拥有的法律权利，包括复制、发布、演绎等权利。分发是指分发指软件作者向他人提供软件源代码或二进制代码或二者的副本。著作权法默认禁止共享，没有许可证的软件就不能免费地使用、修改、共享。在开源许可证中，通常会涉及到著作权许可授权的问题。这些许可协议可以分为两大类：强制性许可证和非强制性许可证。强制性许可证要求使用该软件的用户必须遵守特定的协议，否则将面临诉讼风险。
彻底搞懂Netty的线程模型
03-01 3762
前言 Netty是基于异步的事件驱动的高性能网络框架和工具，常见的分布式中间件底层都有涉及到Netty。 要学习netty线程模型，先了解三种IO模型，这样理解netty线程模型和IO模型更轻松。 BIO 同步阻塞IO模型 一个线程负责连接，多线程则为每一个接入开启一个线程一个请求一个应答请求之后应答之前客户端会一直阻塞 NIO 同步非阻塞I/O 基于IO多路复用技术的“非阻塞同步”IO模型。简单来说，内核将可读可写事件通知应用，由应用主动发起读写操作； AIO 异步非阻塞IO，AIO 引入异步通道的
一文搞懂架构（业务架构、数据架构、技术架构...）
IT人IT事
04-30 2199
在软件行业，对于什么是架构，都有很多的争论，每个人都有自己的理解。在不同的书籍上, 不同的作者, 对于架构的定义也不统一, 角度不同, 定义不同。此君说的架构和彼君理解的架构未必是一回事。因此我们在讨论架构之前，我们先讨论架构的概念定义, 因为概念是人认识这个世界的基础和用来沟通的手段，如果对架构概念理解不一样，那沟通起来自然不顺畅，本文根据相关资料进行总结。
一文搞懂23种设计模式, 再不会来找我
qq_38685072的博客
03-01 896
应用于某些场景的压根就不用管它我们只记三大特性和六大原则就已经掌握了大部分的设计模式要了解任何事物, 方法论很重要, 形式的东西无所谓。
Istio是啥？一文带你彻底了解！
02-24
官方对Istio的介绍浓缩成了一句话：Anopenplatformtoconnect,secure,controlandobserveservices.翻译过来，就是”连接、安全加固、控制和观察服务的开放平台“。开放平台就是指它本身是开源的，服务对应的是微服务，...
一文让你读懂什么是机器学习
02-25
在进入正题前，我想大家心中可能会有一个疑惑：机器学习有什么重要性，以至于要阅读完这篇非常长的文章呢？我并不直接回答这个问题前。相反，我想请大家看两张图：图1机器学习界的执牛耳和互联网界大鳄的联姻这幅图...
一文带你读懂计算机视觉
01-27
最近，我已经阅读了很多与计算机视觉相关的资料并做了大量实验，...选择什么，关键是GPU集成视觉的UI应用程序：ownphotos应用：个人图片整理自动驾驶汽车自动无人机验证码识别/OCR过滤网站/应用程序上的图片自动标记应
23种设计模式之责任链模式
最新发布
好我谢特的博客
07-14 421
一问看懂责任链模式
设计模式之责任链模式
07-11 1166
责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它允许多个对象按照顺序处理请求，并且每个对象可以选择自己是否处理该请求或将其传递给下一个对象。该模式通过将请求的发送者和接收者解耦，提供了更大的灵活性和可扩展性。
责任链模式+CompletableFuture异步处理
weixin_43076660的博客
07-12 337
责任链模式+CompletableFuture异步处理
配置Java开发环境
Broken_x的博客
07-10 1587
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 544
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
elk部署springboot
Chihirozy的博客
07-11 406
elk部署springboot。
一文弄懂责任链设计模式
09-10
责任链设计模式是一种行为型设计模式，用于将请求的发送者和接收者解耦，使多个对象都有机会处理该请求。该模式将这些对象串成链，并沿着这条链传递请求，直到有一个对象能够处理它为止。 责任链模式的核心是定义一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值