设计模式07-责任链模式

这篇具有很好参考价值的文章主要介绍了设计模式07-责任链模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

责任链模式属于行为设计模式,常见的过滤器链就是使用责任链模式设计的。

1、真实开发场景的问题引入

Q:假设有一个闯关游戏,共三关,每一关达到通过条件后才能进入下一关,使用java实现。
A:针对这个问题,按照朴素的想法,我们可以定义三个类,分别是第一关、第二关、第三关,客户端启动游戏首先进入第一关,然后第一关通过后进入第二关,依次类推。我们可以得到这样的代码如下:

@Slf4j
public class FirstLevel {
    @Autowired
    private SecondLevel secondLevel;
    public void play(){
        log.info("进入第一关");
        //游戏操作,获得分数
        int res = 80;
        if(res >= 80){
            secondLevel.play();
        }else {
            return;
        }
    }
}
@Component
@Slf4j
public class SecondLevel {
    @Autowired
    private ThirdLevel thirdLevel;
    public void play(){
        log.info("进入第二关");
        //游戏操作,获得分数
        int res = 90;
        if(res >= 90){
            thirdLevel.play();
        }else {
            return;
        }
    }
}
@Component
@Slf4j
public class ThirdLevel {
    public void play(){
        log.info("进入第三关");
        //游戏操作,获得分数
        int res = 95;
        if(res >= 95){
            log.info("游戏通关");
        }else {
            return;
        }
    }
}

@SpringBootTest
@RunWith(SpringRunner.class)
@Slf4j
class DpApplicationTests {
    @Autowired
    private FirstLevel firstLevel;

    @Test
    public void client(){
        firstLevel.play();
    }
}

上述代码有什么问题呢?

  • 耦合性太强,每个类中包含其他类
  • 如果想改变关卡的顺序需要改类内部代码

2、责任链模式讲解

责任链模式应用的场景是:一个请求,有很多处理者可以处理,这些处理者构成一个链,请求只需要发送到链上,不用管最终是谁处理了请求,也不用管请求在链上是怎么传递的。这样就实现了请求者与被请求者的解耦,同时也只需定义一条链,把处理者放到链上同时定义好处理者的顺序,处理者之间也不用相互持有。

2.1 核心类及类图

设计模式07-责任链模式,设计模式,设计模式,责任链模式,java

一个抽象处理器接口和三个具体的处理器,在处理器链类中有一个List,其中放的是三个具体处理器,在客户端中使用处理器链对象与请求交互。

2.2 基本代码

  • 1 定义一个处理器返回结果类型,其中包括处理结果数据(范型)、是否继续在链上传播
@Data
public class ProcessResult<R> {
    private boolean next;
    private R data;

    public ProcessResult(boolean next, R data) {
        this.next = next;
        this.data = data;
    }

    /**
     * 继续处理并返回数据
     * @param data
     * @param <R>
     * @return
     */
    public static <R> ProcessResult resumeData(R data){
        return new ProcessResult(true,data);
    }

    /**
     * 继续处理不返回数据
     * @param <R>
     * @return
     */
    public static <R> ProcessResult resumeNoData(){
        return new ProcessResult(true,null);
    }

    /**
     * 不继续处理+返回数据
     * @param <R>
     * @return
     */
    public static <R> ProcessResult stopData(R data){
        return new ProcessResult(false,data);
    }

    /**
     * 不继续处理+不返回数据
     * @param <R>
     * @return
     */
    public static <R> ProcessResult stopNoData(){
        return new ProcessResult(false,null);
    }
}

  • 2 定义抽象的处理器,返回值为上面定义的类型;有两个范型,一个是处理器接收的参数,另一个是处理器返回具体数据的类型(包裹在ProcessResult中)
public interface Processor<Result,Param> {
    /**
     * 使用范型的方法、类,需要指定范型
     * @param param 处理器参数
     * @return Res 返回结果
     */
    ProcessResult<Result> process(Param param );


    /**
     * 接口的默认方法,表示该处理器是否已经处理过请求
     * @return
     */
    default boolean isProcessed(){
        return false;
    }
}
  • 3 定义三个具体的处理器,用来处理请求,使用order注解规定了JavaBean扫描的顺序,实现Processor注意指明范型参数
@Component
@Order(1)
@Slf4j
public class ConcreteProcessor01 implements Processor<String,String>{
    @Override
    public ProcessResult<String> process(String s) {
        //通过参数判断是不是处理请求
        log.info("ConcreteProcessor01处理");
        //处理
        return ProcessResult.resumeData(s);
    }
}
@Component
@Order(2)
@Slf4j
public class ConcreteProcessor02 implements Processor<String,String>{
    @Override
    public ProcessResult<String> process(String s) {
        //通过参数判断是不是处理请求
        log.info("ConcreteProcessor02处理");
        //处理
        return ProcessResult.stopData(s);
    }
}
@Component
@Order(3)
@Slf4j
public class ConcreteProcessor03 implements Processor<String,String>{
    @Override
    public ProcessResult<String> process(String s) {
        //通过参数判断是不是处理请求
        log.info("ConcreteProcessor03处理");
        //处理
        return ProcessResult.resumeData(s);
    }
}
  • 4 定义处理器链,构造函数注入List

    类型参数,spring容器会扫描所有的P类型的Bean,放到List中。Processor<Result,Param> 前面定义的ConcreteProcessor01、02、03一致(即Processor<String,String>),但是这里为了保证BaseChain的通用性,即可以定义多个聚合不同类型处理器的处理器链,该处使用范型。

@Component
@Slf4j
public class BaseChain<Result,Param> {
    private List<Processor<Result,Param>> processors;

    @Autowired
    public BaseChain(List<Processor<Result,Param>> processors) {
        this.processors = processors;
    }

    public void doProcess(Param param) {
        for (Processor processor : processors) {
            ProcessResult process = processor.process(param);
            if (process.getData() != null) {
                log.info(process.getData().toString());
            }
            if (!process.isNext()) {
                return;
            }
        }
    }
}
  • 5 客户端
@SpringBootTest
@RunWith(SpringRunner.class)
@Slf4j
class DpApplicationTests {
    @Autowired
    private BaseChain baseChain;

    @Test
    public void chainTest(){
        baseChain.doProcess("123");
    }
}

输出:
设计模式07-责任链模式,设计模式,设计模式,责任链模式,java

3、利用构建者模式解决问题

针对1中的问题可以套用2中的代码解决

4、责任链模式的应用实例

Spring Web 中的 HandlerInterceptor

HandlerInterceptor接口在web开发中非常常用,里面有preHandle()、postHandle()、afterCompletion()三个方法,preHandle()方法在请求处理之前被调用、postHandle()方法在请求处理完成后,但在视图渲染之前被调用、afterCompletion()方法在视图渲染完成后被调用

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对所有的HandlerInterceptor进行调用。

public class HandlerExecutionChain {

	...

    //在数组中存放所有的过滤器
	@Nullable
	private HandlerInterceptor[] interceptors;
	//数组的下标
	private int interceptorIndex = -1;
	//pre的调度
	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];
        //preHandle返回false,进入该if,结束处理流程,
				if (!interceptor.preHandle(request, response, this.handler)) {
          //执行渲染完成后的逻辑
					triggerAfterCompletion(request, response, null);
					return false;
				}
        //修改当前指向的过滤器下标,记录最后一个成功执行preHandle()方法的拦截器的索引。
        //如果某个拦截器的preHandle()方法返回false,则遍历将停止,并且请求处理也将停止。
        //在这种情况下,HandlerExecutionChain需要调用所有已成功执行preHandle()方法的拦截器的afterCompletion()方法。
        //这时候就需要使用interceptorIndex得到最后一个成功执行的preHandle方法所在的拦截器在拦截链的位置。
				this.interceptorIndex = i;
			}
		}
		return true;
	}
}

5、总结

5.1 解决的问题

职责链上的处理者负责处理请求,客户只需要将请求发送到职责链上即可,无须关心请求的处理细节和请求的传递,所以职责链将请求的发送者和请求的处理者解耦了。

5.2 使用场景

在处理消息的时候以过滤很多道。

5.3 优缺点

优点: 1、降低耦合度。它将请求的发送者和接收者解耦。 2、简化了对象。使得对象不需要知道链的结构。 3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序,允许动态地新增或者删除责任。 4、增加新的请求处理类很方便。

缺点: 1、不能保证请求一定被接收。 2、系统性能将受到一定影响,而且在进行代码调试时不太方便,可能会造成循环调用。 3、可能不容易观察运行时的特征,有碍于除错。


参考:
[1] 实战:设计模式之责任链设计模式深度解析
[2] 责任链模式在 Spring 中的应用
[3] 责任链模式-菜鸟教程文章来源地址https://www.toymoban.com/news/detail-569398.html

到了这里,关于设计模式07-责任链模式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Java 设计模式】行为型之责任链模式

    责任链模式(Chain of Responsibility Pattern)是一种行为型设计模式,用于将请求发送者和接收者解耦,使得多个对象都有机会处理请求。责任链模式通过创建一个处理请求的链,将请求沿着链传递,直到有一个对象能够处理为止。在本文中,我们将深入研究Java中责任链模式的定

    2024年01月24日
    浏览(49)
  • 【设计模式】Java 设计模式之责任链模式(Chain of Responsibility)

    责任链模式(Chain of Responsibility) 一、概述 责任链模式是一种行为设计模式,它允许请求在对象链中传递。每个对象都有机会处理该请求,并且能将其传递给链中的下一个对象。这种模式为请求创建了一个处理对象的链,并沿着这条链传递该请求,直到有一个对象处理它为止

    2024年03月22日
    浏览(42)
  • 【玩转23种Java设计模式】行为型模式篇:责任链模式

    软件设计模式(Design pattern),又称设计模式,是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。 汇总目录链接:【玩转23种Java设计模式】学习目录汇总

    2024年02月13日
    浏览(34)
  • Java设计模式—责任链模式(Chin of Responsibility)

    目录 前言 一、责任链模式的简介 二、责任链模式的概念 三、责任链模式的作用 四、责任链模式的优、缺点 1.责任链模式的优点 2.责任链模式的缺点 五、责任链模式的应用场景 六、代码案例 UML类图  1.定义一个请求枚举类  2.定义一个请求类 3.定义一个抽象处理接口 4、定

    2024年02月08日
    浏览(34)
  • Java设计模式-责任链(Chain of Responsibility)模式

    Java责任链(Chain of Responsibility)设计模式是指很多处理对象构成一个链,链中前一个对象指向后一个对象。请求在链中传递,一个请求可以被一个或者多个对象处理。调用方(即客户端)不知道请求会被链中的哪个对象处理,所以责任链模式可以方便组织责任链而不影响调用

    2024年02月16日
    浏览(45)
  • Java 大厂八股文面试专题-设计模式 工厂方法模式、策略模式、责任链模式

            在平时的开发中,涉及到设计模式的有两块内容,第一个是我们 平时使用的框架 (比如spring、mybatis等),第二个是我们自己开发业务使用的设计模式。         面试官一般比较关心的是你在开发过程中, 有没有使用过设计模式,或者你在简历上写了关于设计

    2024年02月10日
    浏览(53)
  • Java设计模式之责任链模式(UML类图分析+代码详解)

    大家好,我是一名在算法之路上不断前进的小小程序猿!体会算法之美,领悟算法的智慧~ 希望各位博友走过路过可以给我点个免费的赞,你们的支持是我不断前进的动力!! 加油吧!未来可期!! 本文将介绍java设计模式之责任链模式 OA系统采购审批需求 传统方案解决OA系

    2024年02月06日
    浏览(37)
  • Java设计模式之行为型-责任链模式(UML类图+案例分析)

    目录 一、基础概念 二、UML类图 三、角色设计 四、案例分析 4.1、在Java中实现 4.2、在SpringBoot中实现  五、总结  责任链模式是一种行为设计模式,它允许你将请求沿着处理者链进行发送。请求会被链上每个处理者处理,直到请求被处理完毕。该模式主要解决的是请求的发送者和

    2024年02月15日
    浏览(39)
  • 《设计模式》责任链模式

    定义 : 责任链模式将链中每一个节点都看成一个对象,并且将这些节点对象连成一条链,请求会沿着这条链进行传递,直到有对象处理它为止,这使得多个对象都有机会接收请求,避免了请求发送者和接收者之间的耦合。 属于 行为型 设计模式。 责任链模式的角色组成 :

    2024年02月13日
    浏览(42)
  • 【设计模式】责任链模式

    顾名思义,责任链模式(Chain of Responsibility Pattern)为请求创建了一个接收者对象的链。这种模式给予请求的类型,对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。 在这种模式中,通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处

    2024年02月12日
    浏览(37)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包