设计模式七：责任链模式

news/2024/5/19 13:26:37 标签: 设计模式, 责任链模式, java

文章目录

1、责任链模式

责任链模式为请求创建了一个接收者对象的链，在这种模式下，通常每个节点都包含对另一个节点者的引用。每个节点针对请求，处理自己感兴趣的内容，处理完之后可以结束，也可以向下一个节点传递继续处理；

角色：

  1. 抽象处理者角色：处理请求的抽象类，定义了处理请求的抽象方法；(抽象类或接口实现)；
  2. 具体处理者角色：处理请求的具体实现类；(持有下家对象的引用)；

例：请假流程都是先由本部门审核，根据时间长短再进行下一级审批

在这里插入图片描述

java">//抽象类
public abstract class Handler {
    /**
     * 请假天数
     */
    public int maxday;
    /**
     * 请假人
     */
    public String name;

    public Handler(String name, int maxday) {
        this.maxday = maxday;
        this.name = name;
    }

    private Handler nextHandler;

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

    /**
     * 处理请假：判断请假天数，超过本部门限定时间则交由上一级部门
     */

    public final void handlingFakeSlips(int day) {
        if (this.maxday >= day) {
            this.agree(day);
        }
        else {
            if (nextHandler != null) {
                System.out.println(name+":天数已超过我的审批权限，已提交我的上级审批");
                nextHandler.handlingFakeSlips(day);
            }
            else {
                System.out.println("天数时间过长，准备辞职吧！！！");
            }
        }
    }

    /**
     * 审批动作：子类来实现
     * @param day
     */
    abstract void agree(int day);
}

//部门实现类
public class RDDepartment extends Handler{
    public RDDepartment(String name, int maxday) {
        super(name, maxday);
    }
    @Override
    void agree(int maxday) {
        System.out.println(name + "：研发部门请假审批通过，请假天数：" + maxday);
    }
}

//主管实现类
public class Supervisor extends Handler{
    public Supervisor(String name, int maxday) {
        super(name, maxday);
    }
    @Override
    void agree(int maxday) {
        System.out.println(name + "：主管请假审批通过，请假天数：" + maxday);
    }
}

//董事实现类
public class Director extends Handler{
    public Director(String name, int maxday) {
        super(name, maxday);
    }
    @Override
    void agree(int maxday) {
        System.out.println(name + "：请假董事审批通过，请假天数：" + maxday);
    }
}

//组装链
public class HandlerChain {
    private Handler head;
    private Handler tail;
    public HandlerContext(){
        RDDepartment rdDepartment = new RDDepartment("研发部门",5);
        Supervisor supervisor = new Supervisor("项目主管",30);
        Director director = new Director("董事",180);

        rdDepartment.setNextHandler(supervisor);
        supervisor.setNextHandler(director);

        head = rdDepartment;
        tail = director;
    }
    public void doHandler(Integer days){
        head.handlingFakeSlips(days);
    }
}


//请求
public class Request {
    public static void main(String[] args) {
        HandlerChain handlerChain = new HandlerChain();
        handlerChain.doHandler(360);
    }
}

优点（when,why）：

​ 1.发送者与接收者之间的耦合度降低（解耦）

​ 2.可以灵活添加新的责任链中的对象

缺点：

​ 1.不能保证请求一定被接收

​ 2.一定程度上影响性能

这种形式很难进行动态新增和调整处理节点，一种比较复杂的控制节点的形式如Netty中的责任链模式应用，见下一节

2、spring中的责任链模式

Spring Interceptor

回顾springmvc处理请求的流程：DispatcherServlet接收到请求后，执行doDispatcher()方法，流程回顾请求处理流程图

其中通过HandlerMapping获得的是HandlerExecutionChain 对象

java">protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    //......
    HandlerExecutionChain mappedHandler = null;
	//......
    mappedHandler = getHandler(processedRequest);
    //......     
    HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
	//......
}

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    if (this.handlerMappings != null) {
        for (HandlerMapping mapping : this.handlerMappings) {
            HandlerExecutionChain handler = mapping.getHandler(request);
            if (handler != null) {
                return handler;
            }
        }
    }
    return null;
}

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
    if (this.handlerAdapters != null) {
        for (HandlerAdapter adapter : this.handlerAdapters) {
            if (adapter.supports(handler)) {
                return adapter;
            }
        }
    }
    throw new ServletException("No adapter for handler [" + handler +
                               "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}

HandlerExecutionChain 中包含一个handler对象（后面匹配能处理handler的适配器对象执行，详情对应适配器模式中讲解），还有一个拦截器列表List<HandlerInterceptor> interceptorList，所有的实现了HandlerInterceptor接口的类都会被加载进这个集合中，在请求处理前后分别以责任链的形式调用拦截器的preHandle和postHandle

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

void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
    throws Exception {

    HandlerInterceptor[] interceptors = 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);
        }
    }
}

这里的链是由集合List维护，使用List有序的特性一次调用每个拦截器，通过方法返回的结果判断是否需要传递到下一个拦截器

Servlet Filter

servlet中Filter的调用也是通过责任链模式，通过FilterChain作为链条的管理者

java">//FilterChain接口
public interface FilterChain {
    public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException;
}

//FilterChain实现类
public class MockFilterChain implements FilterChain {
	
    //......
	private final List<Filter> filters;
	//......
    
	@Override
	public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
		Assert.notNull(request, "Request must not be null");
		Assert.notNull(response, "Response must not be null");
		Assert.state(this.request == null, "This FilterChain has already been called!");

		if (this.iterator == null) {
			this.iterator = this.filters.iterator();
		}

		if (this.iterator.hasNext()) {
			Filter nextFilter = this.iterator.next();
			nextFilter.doFilter(request, response, this);
		}

		this.request = request;
		this.response = response;
	}
}

由上可知，FilterChain中管理的 List<Filter> filters即为所有实现了Filter的过滤器，调用过滤器的时候，通过FilterChain进行链条的调用。

java">//Filter接口
public interface Filter {

    default public void init(FilterConfig filterConfig) throws ServletException {}

    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain)
            throws IOException, ServletException;

    default public void destroy() {}
}

//Filter实现类
public class AuthFilter extends AuthenticationFilter {
   //......
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest httpRequest = toLowerCase((HttpServletRequest)request);
        String tokenString = httpRequest.getParameter("delegation");
        if (tokenString != null) {
            filterChain.doFilter(httpRequest, response);
        } else {
            super.doFilter(httpRequest, response, filterChain);
        }
    }
    //......
}

Filter的doFilter方法最后调用filterChain.doFilter(httpRequest, response);即传递至下一个Filter进行处理

Netty

Netty中的handler使用了责任链模式，但是其中回调过多，责任链模式的体现不清晰，参考该文章**Spring中如何使用责任链模式**，将责任链抽离出来，完成在spring中的调用

在这里插入图片描述

该模型中，具有多条链，每条链属于不同层级，链中节点为HandlerContext，HandlerContext包含相邻接点的引用，还有Handler的引用

Pipeline：为链条的管理者，通过Pipeline来调用责任链

HandlerContext：为链条中节点的上下文，它里面有链条的前一个节点和后一个节点的HandlerContext引用

Handler: 具体的处理程序，与HandlerContext一一对应

我们先仅看Filter事件这一条链，整个结构由Pipeline管理整条链

在这里插入图片描述

java">//Pipelie接口
public interface Pipeline {
    Pipeline fireTaskFiltered();
}

//Pipeline实现类
Component("pipeline")
@Scope("prototype")
public class DefaultPipeline implements Pipeline, ApplicationContextAware, InitializingBean {
    // 创建一个默认的handler，将其注入到首尾两个节点的HandlerContext中，其作用只是将链往下传递
    private static final Handler DEFAULT_HANDLER = new Handler() {};

    // 将ApplicationContext注入进来的主要原因在于，HandlerContext是prototype类型的，因而需要
    // 通过ApplicationContext.getBean()方法来获取其实例
    private ApplicationContext context;

    // 创建一个头结点和尾节点，这两个节点内部没有做任何处理，只是默认的将每一层级的链往下传递，
    // 这里头结点和尾节点的主要作用就是用于标志整个链的首尾，所有的业务节点都在这两个节点中间
    private HandlerContext head;
    private HandlerContext tail;

    // 用于业务调用的request对象，其内部封装了业务数据
    private Request request;
    // 用于执行任务的task对象
    private Task task;

    // 最初始的业务数据需要通过构造函数传入，因为这是驱动整个pipeline所需要的数据，
    // 一般通过外部调用方的参数进行封装即可
    public DefaultPipeline(Request request) {
        this.request = request;
    }

    // 这里我们可以看到，每一层级的调用都是通过HandlerContext.invokeXXX(head)的方式进行的，
    // 也就是说我们每一层级链的入口都是从头结点开始的，当然在某些情况下，我们也需要从尾节点开始链
    // 的调用，这个时候传入tail即可。

    // 触发任务过滤的链调用
    @Override
    public Pipeline fireTaskFiltered() {
        HandlerContext.invokeTaskFiltered(head, task);
        return this;
    }

    // 用于往Pipeline中添加节点的方法，读者朋友也可以实现其他的方法用于进行链的维护
    void addLast(Handler handler) {
        HandlerContext handlerContext = newContext(handler);
        tail.prev.next = handlerContext;
        handlerContext.prev = tail.prev;
        handlerContext.next = tail;
        tail.prev = handlerContext;
    }

    // 这里通过实现InitializingBean接口来达到初始化Pipeline的目的，可以看到，这里初始的时候
    // 我们通过ApplicationContext实例化了两个HandlerContext对象，然后将head.next指向tail节点，
    // 将tail.prev指向head节点。也就是说，初始时，整个链只有头结点和尾节点。
    @Override
    public void afterPropertiesSet() throws Exception {
        head = newContext(DEFAULT_HANDLER);
        tail = newContext(DEFAULT_HANDLER);
        head.next = tail;
        tail.prev = head;
    }

    // 使用默认的Handler初始化一个HandlerContext
    private HandlerContext newContext(Handler handler) {
        HandlerContext context = this.context.getBean(HandlerContext.class);
        context.handler = handler;
        return context;
    }

    // 注入ApplicationContext对象
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        this.context = applicationContext;
    }
}

Pipeline的实现类内部除了实现接口的方法，其他方法均为初始化

  • DEFAULT_HANDLER: Pipeline管理一条链表，该链表的每个节点包含HandlerContext和Handler两个对象， 而链表的首和尾两个节点由Pipeline自己指定（其他自定义的节点放在首尾两节点之间），DEFAULT_HANDLER用来作为首尾节点的Handler，不起任何作用
  • context: 由于这些类的作用域均不是单例，所以要使用ApplicationContext.getBean()方法获取，所以类实现了ApplicationContextAware接口的setApplicationContext方法，用于注入ApplicationContext对象
  • private HandlerContext head, tail: 为一条链的首尾两个节点，从这儿也可以看出，链条的每个节点都是通过HandlerContext来引用的，HandlerContext再引用一个Handler
java">@Component
@Scope("prototype")
public class HandlerContext {

    HandlerContext prev;
    HandlerContext next;
    Handler handler;

    private Task task;

    public void fireTaskFiltered(Task task) {
        invokeTaskFiltered(next(), task);
    }

    /**
     * 处理任务过滤事件
     */
    static void invokeTaskFiltered(HandlerContext ctx, Task task) {
        if (null != ctx) {
            try {
                ctx.handler().filterTask(ctx, task);
            } catch (Throwable e) {
                ctx.handler().exceptionCaught(ctx, e);
            }
        }
    }

    private HandlerContext next() {
        return next;
    }

    private Handler handler() {
        return handler;
    }
}

HandlerContext作为节点，应有前后两个节点的引用pre next，还有具体处理任务的Handler

fireTaskFiltered方法供Hanndler调用，将请求传递给下一个节点处理(方法实现中区下一个HandlerContext去执行)

invokeTaskFiltered静态方法供Pipeline 和 上一个节点的fireTaskFiltered方法调用，去执行Handler的方法

java">public interface Handler {
    /**
     * 查询到task之后，进行task过滤的逻辑
     */
    default void filterTask(HandlerContext ctx, Task task) {
        ctx.fireTaskFiltered(task);
    }
}

Handler定义了感兴趣的事件（暂时只看过滤事件）

Handler的实现类由我们根据自己的需要去编写，实现Handler接口即可

java">@Component
public class DurationHandler implements Handler {
    @Override
    public void filterTask(HandlerContext ctx, Task task) {
        System.out.println("时效性检验");
        ctx.fireTaskFiltered(task);
    }
}

@Component
public class RiskHandler implements Handler {
    @Override
    public void filterTask(HandlerContext ctx, Task task) {
        System.out.println("风控拦截");
        ctx.fireTaskFiltered(task);
    }
}

@Component
public class TimesHandler implements Handler {
    @Override
    public void filterTask(HandlerContext ctx, Task task) {
        System.out.println("次数限制检验");
        ctx.fireTaskFiltered(task);
    }
}

这里我们已经实现了Pipeline，HandlerContext和Handler，知道这些bean都是被Spring所管理的bean，那么我们接下来的问题主要在于如何进行整个链的组装。这里的组装方式比较简单，其主要需要解决两个问题：

  • 对于后续写业务代码的人而言，其只需要实现一个Handler接口即可，而无需处理与链相关的所有逻辑，因而我们需要获取到所有实现了Handler接口的bean；
  • 将实现了Handler接口的bean通过HandlerContext进行封装，然后将其添加到Pipeline中。

以上可以由spring完成，通过生命实现接口BeanPostProcessor的类，实现postProcessAfterInitialization方法，可以在初始化完Pipeline后，获取所有实现了Handler的bean，并添加到pipeline中，spring自动调用该方法

java">@Component
public class HandlerBeanProcessor implements BeanPostProcessor, ApplicationContextAware {

    private ApplicationContext context;

    // 该方法会在一个bean初始化完成后调用，这里主要是在Pipeline初始化完成之后获取所有实现了
    // Handler接口的bean，然后通过调用Pipeline.addLast()方法将其添加到pipeline中
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean instanceof DefaultPipeline) {
            DefaultPipeline pipeline = (DefaultPipeline) bean;
            Map<String, Handler> handlerMap = context.getBeansOfType(Handler.class);
            handlerMap.forEach((name, handler) -> pipeline.addLast(handler));
        }

        return bean;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        this.context = applicationContext;
    }
}
  • postProcessAfterInitialization(Object bean, String beanName): 实现了BeanPostProcessor的该方法，在spring启动之后没初始化完成一个Bean之后，都会调用该方法

如此，当初始化完pipeline之后，获取实现了Handler接口的所有实现类，在addLast()方法中为每一个Handler初始化一个HandlerContext，并添加到Pipeline中

如此下来，整个过程调用如下

java">@Service
public class ApplicationService {

    @Autowired
    private ApplicationContext context;

    public void mockedClient(Request request) {
        Pipeline pipeline = newPipeline(request);
        pipeline.fireTaskFiltered();
    }

    private Pipeline newPipeline(Request request) {
        return context.getBean(DefaultPipeline.class, request);
    }
}

1、spring项目启动，加载和初始化Bean，当加载到DefaultPipeline的时候，由于实现了InitializingBean接口，所以会调用初始化方法afterPropertiesSet()，为DefaultPipeline添加两个首尾节点HandlerContext；

2、当初始化完成Pipeline之后，调用postProcessAfterInitialization(Object bean, String beanName);

3、加载所有实现了Hnadler接口的Bean，并通过pipeline.addLast(Handler handler方法为每一个handler创建一个HandlerContext，并添加到链条中;

至此形成了一条链

4、service想执行该链的时候，通过有参构造方法，将请求request传递给pipeline，调用pipeline.fireTaskFiltered();

5、pipeline.fireTaskFiltered()中，会调用HandlerContext的静态方法HandlerContext.invokeTaskFiltered(HandlerContext ctx, Task task)将第一个HandlerContext传入去执行，其handler的filterTask(HandlerContext ctx, Task task)方法执行具体逻辑

6、handler的filterTask(HandlerContext ctx, Task task)方法最后会调用ctx的invokeTaskFiltered(HandlerContext ctx, Task task)方法，该方法会使用invokeTaskFiltered(next(), task)去执行下一个节点ctx.handler().filterTask(ctx, task)

7、直至最后到节点tail没有下一个节点会停止执行；

至此单条链的责任链模式已完成

在netty中，并不是一条链，每一个handler有很多针对不同的事件的处理

在pipeline中有所有的事件，我们相对某一个事件处理是，实现handler的对应方法的处理逻辑，就会在对应层级的链中加入该handler，netty多层级代码责任链参考：Spring中如何使用责任链模式


http://www.niftyadmin.cn/n/5396402.html

相关文章

C++:回调函数的应用

C++:回调函数的应用

本文关于回调函数的学习的学习资料都来自于这里。 原文写得非常详细&#xff0c;所以将原文的大部分内容作为笔记摘抄了过来。 文章目录 1.回调函数1.1普通函数作为回调函数1.2类的静态函数作为回调函数1.3类的非静态成员函数作为回调函数1.4优化--非静态包装为静态 2. std::f…
阅读更多...
k8s部署 多master节点负载均衡以及集群高可用

k8s部署 多master节点负载均衡以及集群高可用

一、k8s 添加多master节点实验 1、master02节点初始化操作 2、在master01节点基础上&#xff0c;完成master02节点部署 ①从master01节点复制所需要的文件 需要从master01节点复制etcd数据库所需要的ssl证书、kubernetes安装目录&#xff08;二进制文件、组件与apiserver通信…
阅读更多...
vue使用Swiper插件实现卡片化轮播图

vue使用Swiper插件实现卡片化轮播图

swiper轮播图滚动 1.安装swiper 官网&#xff1a;Swiper中文网-轮播图幻灯片js插件,H5页面前端开发 注意&#xff1a; 下载插件【要5.x】&#xff0c;不然会出现各种BUG。 npm i swiper5.x vue-awesome-swiper4.1.1 -S 2.HTML代码 <div class"examples"><…
阅读更多...
面试redis篇-12Redis集群方案-分片集群

面试redis篇-12Redis集群方案-分片集群

原理 主从和哨兵可以解决高可用、高并发读的问题。但是依然有两个问题没有解决&#xff1a; 海量数据存储问题高并发写的问题 使用分片集群可以解决上述问题&#xff0c;分片集群特征&#xff1a; 集群中有多个master&#xff0c;每个master保存不同数据每个master都可以有…
阅读更多...
MyBatis 学习（一）之 MyBatis 概述

MyBatis 学习（一）之 MyBatis 概述

目录 1 MyBatis 介绍 2 MyBatis 的重要组件 3 MyBatis 执行流程 4 参考文档 1 MyBatis 介绍 MyBatis 是一个半自动化的 ORM &#xff08;Object-Relational Mapping&#xff0c;对象关系映射&#xff09;持久层框架&#xff0c;它允许开发者通过 XML 或注解将对象与数据库中…
阅读更多...
（十七）devops持续集成开发——使用jenkins流水线pipeline方式发布一个微服务项目

（十七）devops持续集成开发——使用jenkins流水线pipeline方式发布一个微服务项目

前言 本节内容是一套关于微服务项目在docker环境中使用jenkins流水线部署的完整方案，在开始本节内容之前，我们需要提前安装好docker环境，以及docker本地镜像仓库docker harbor，同时安装好SonarQube用于代码验证，具体的安装步骤可参考作者的往期博客内容。 正文 在源码仓…
阅读更多...
【STM32 物联网】AT指令与TCP，发送与接收数据

【STM32 物联网】AT指令与TCP，发送与接收数据

文章目录 前言一、连接TCP服务器1.1 配置Wifi模式1.2 连接路由器1.3 查询ESP8266设备IP地址1.4 连接TCP服务器 二、向服务器接收数据和发送数据2.1 发送数据2.2 接收数据 总结 前言 随着物联网&#xff08;IoT&#xff09;技术的迅速发展&#xff0c;越来越多的设备和系统开始…
阅读更多...
备战蓝桥杯————k个一组反转单链表

备战蓝桥杯————k个一组反转单链表

k个反转单链表&#xff0c;顾名思义就是k个节点为一组进行反转&#xff0c;这是一道困难的题目&#xff0c;如何解答&#xff0c;可以在我们前面的反转链表中得到思路。 如何 K 个一组反转单链表 题目描述 给你链表的头节点 head &#xff0c;每 k 个节点一组进行翻转&#xf…
阅读更多...
最新文章

Copyright @ 2022~2023