设计模式-责任链模式

最新推荐文章于 2024-09-20 19:06:24 发布
最新推荐文章于 2024-09-20 19:06:24 发布
阅读量282 收藏
点赞数 6
分类专栏： # 设计模式 文章标签： 设计模式 责任链模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gs19990923/article/details/133318873
版权

# 责任链模式

1.简介

责任链模式是一种行为设计模式，允许你将请求沿着处理者链进行发送。收到请求后，每个处理者均可对请求进行处理，或将其传递给链上的下一个处理者。

其实就是将请求的发送和接受解耦，让多个接受对象都有机会处理这个请求。将这些接受对象串成一条链，并沿着这条链传递这个请求，直到链上的某个对象能够处理它为止。

2.UML图

在这里插入图片描述

  • **处理者(Handler)😗*声明了所有具体处理者的通用接口。该接口通常仅包含单个方法用于请求处理，但有时其还会包含一个设置链上下个处理者的方法。
  • **基础处理者(Base Handler)😗*是一个可选的类，你可以将所有处理者共用的代码放置在其中。通常情况下，该类中定义了一个保存对于下个处理者引用的成员变量。客户端可通过将处理者传递给上个处理者的构造函数或者设定方法来创建链。该类还可以实现默认的处理行为：确定下个处理者存在后再将请求传递给它。
  • **具体处理者(Concrete Handlers)😗*包含处理请求的实际代码。每个处理者接收到请求后，都必须决定是否进行处理，以及是否沿着链传递请求。处理者通常是独立且不可变的，需要通过构造函数一次性获取所有的必要数据。
  • **客户端(Client)😗*可根据程序逻辑一次性或者动态的生成链，需要注意的是，请求可以发送给链上任意一个处理者，也并非一定要从第一个开始。

3.代码示例

设想一个场景，小白的妈妈给小白列了一个清单(洗头、洗脸、吃早饭)，小白需要吧清单上的任务完成之后才可以开始学习。

如果我们不使用任何模式：

首先定义一个准备列表：

package com.gs.designmodel.chainofduty.bad;

import lombok.Data;

/**
 * @author: Gaos
 * @Date: 2023-08-28 20:15
 **/
@Data
public class PreparationList {

    private boolean washFace;

    private boolean washHair;

    private boolean haveBreakfast;

    public boolean isWashFace() {
        return washFace;
    }

    public void setWashFace(boolean washFace) {
        this.washFace = washFace;
    }

    public boolean isWashHair() {
        return washHair;
    }

    public void setWashHair(boolean washHair) {
        this.washHair = washHair;
    }

    public boolean isHaveBreakfast() {
        return haveBreakfast;
    }

    public void setHaveBreakfast(boolean haveBreakfast) {
        this.haveBreakfast = haveBreakfast;
    }
}

学习类：

package com.gs.designmodel.chainofduty.bad;

/**
 * @author: Gaos
 * @Date: 2023-08-28 20:19
 **/
public class Test {

    public static void main(String[] args) {
        PreparationList preparationList = new PreparationList();
        if(preparationList.isWashHair()) {
            System.out.println("洗头");
        }
        if(preparationList.isWashFace()) {
            System.out.println("洗脸");
        }
        if(preparationList.isHaveBreakfast()) {
            System.out.println("吃早饭");
        }
        System.out.println("任务完成");
    }
}

这个例子虽然实现了我们的需求，但是也有一些问题：

  • 准备列表类中如果增加一件事情的时候，你必须修改study类中的方法进行适配。
  • 如果这些事情的顺序现在需要修改，那么你也必须要修改study类中相对应的方法。

下面我们使用一下责任链模式，它的特点是 链上的每个对象都持有下个对象的引用。

首先我们抽象出一个 AbstractPrepareFilter:

package com.gs.designmodel.chainofduty.normal;

import com.gs.designmodel.chainofduty.bad.PreparationList;

/**
 * @author: Gaos
 * @Date: 2023-08-28 20:21
 **/
public abstract class AbstractPrepareFilter {
		
  // 持有下一个对象的引用
    private AbstractPrepareFilter next;

    public AbstractPrepareFilter(AbstractPrepareFilter next) {
        this.next = next;
    }
	// 如果有下一个对象就执行，没有的话就代表所有对象执行完毕
    public void doFilter(PreparationList preparationList, Study study) {
        prepare(preparationList);
        if(next == null) {
            study.study();
        }else {
            next.doFilter(preparationList, study);
        }
    }
		
  // 留一个抽象方法给子类实现
    public abstract void prepare(PreparationList preparationList);
}

然后我们开始实现各个功能：

洗脸：

package com.gs.designmodel.chainofduty.normal;

import com.gs.designmodel.chainofduty.bad.PreparationList;

/**
 * @author: Gaos
 * @Date: 2023-08-28 20:25
 **/
public class WashFaceFilter extends AbstractPrepareFilter{

    public WashFaceFilter(AbstractPrepareFilter next) {
        super(next);
    }

    @Override
    public void prepare(PreparationList preparationList) {
        if(preparationList.isWashFace()) {
            System.out.println("洗脸");
        }
    }
}

洗头：

package com.gs.designmodel.chainofduty.normal;

import com.gs.designmodel.chainofduty.bad.PreparationList;

/**
 * @author: Gaos
 * @Date: 2023-08-28 20:27
 **/
public class WashHairFilter extends AbstractPrepareFilter{

    public WashHairFilter(AbstractPrepareFilter next) {
        super(next);
    }

    @Override
    public void prepare(PreparationList preparationList) {
        if(preparationList.isWashHair()) {
            System.out.println("洗头");
        }
    }
}

吃早饭：

package com.gs.designmodel.chainofduty.normal;

import com.gs.designmodel.chainofduty.bad.PreparationList;

/**
 * @author: Gaos
 * @Date: 2023-08-28 20:28
 **/
public class EatBreakfastFilter extends AbstractPrepareFilter{

    public EatBreakfastFilter(AbstractPrepareFilter next) {
        super(next);
    }

    @Override
    public void prepare(PreparationList preparationList) {
        if(preparationList.isHaveBreakfast()) {
            System.out.println("吃早餐");
        }
    }
}

学习类：

package com.gs.designmodel.chainofduty.normal;

/**
 * @author: Gaos
 * @Date: 2023-08-28 20:23
 **/
public class Study {

    public void study() {
        System.out.println("计划完成，开始学习");
    }
}

测试类(调用方)：

package com.gs.designmodel.chainofduty.normal;

import com.gs.designmodel.chainofduty.bad.PreparationList;

/**
 * @author: Gaos
 * @Date: 2023-08-28 20:28
 **/
public class Test {
    public static void main(String[] args) {
        PreparationList preparationList = new PreparationList();
        preparationList.setWashFace(true);
        preparationList.setWashHair(false);
        preparationList.setHaveBreakfast(true);

        Study study = new Study();
        AbstractPrepareFilter haveBreakfastFilter = new EatBreakfastFilter(null);
        AbstractPrepareFilter washFaceFilter = new WashFaceFilter(haveBreakfastFilter);
        AbstractPrepareFilter washHairFilter = new WashHairFilter(washFaceFilter);

        washHairFilter.doFilter(preparationList, study);
    }
}

结果：

洗脸
吃早餐
计划完成，开始学习

这种方式虽然使用了责任链模式，并将学习和准备工作之间接耦，无论加多少准备工作都不需要修改study中的方法，但是也还有一些问题。

  • 增加或者减少责任链对象，都需要修改客户端的代码。
  • AbstractPrepareFilter washFaceFilter = new WashFaceFilter(haveBreakfastFilter)，这种方式不够优雅，很容易搞不清楚到底会调用哪个责任链对象。

我们针对上述问题再做一个升级版：

首先还是抽象一个 Filter:

package com.gs.designmodel.chainofduty.special;

import com.gs.designmodel.chainofduty.bad.PreparationList;


/**
 * @author: Gaos
 * @Date: 2023-08-28 20:30
 **/
public interface StudyPrepareFilter {

    public void doFilter(PreparationList preparationList, FilterChain filterChain);
}

注意这里多了一个 FilterChain, 用于串联起所有的责任链对象，同时它也属于StudyPrepareFilter的一个子类：

package com.gs.designmodel.chainofduty.special;

import com.gs.designmodel.chainofduty.bad.PreparationList;
import com.gs.designmodel.chainofduty.normal.Study;

import java.util.ArrayList;
import java.util.List;

/**
 * @author: Gaos
 * @Date: 2023-08-28 20:32
 **/
public class FilterChain implements StudyPrepareFilter{
		
  // 计数器
    private int pos = 0;

    private Study study;

    private List<StudyPrepareFilter> studyPrepareFilters;

    public FilterChain(Study study) {
        this.study = study;
    }

    public void addFilter(StudyPrepareFilter studyPrepareFilter) {
        if(studyPrepareFilters == null) {
            studyPrepareFilters = new ArrayList<>();
        }
        studyPrepareFilters.add(studyPrepareFilter);
    }

    @Override
    public void doFilter(PreparationList preparationList, FilterChain filterChain) {
        // 所有过滤器已经执行完毕，执行study方法
        if(pos == studyPrepareFilters.size()) {
            study.study();
          // 否则调用下一个对象的方法
        }else {
            studyPrepareFilters.get(pos++).doFilter(preparationList, filterChain);
        }

    }
}

然后我们还是实现各个功能，这里需要注意各个实现类需要显式的调用 FilterChain 中的 doFilter()方法：

洗脸：

package com.gs.designmodel.chainofduty.special;

import com.gs.designmodel.chainofduty.bad.PreparationList;

/**
 * @author: Gaos
 * @Date: 2023-08-28 20:37
 **/
public class WashFaceFilter implements StudyPrepareFilter{
    @Override
    public void doFilter(PreparationList preparationList, FilterChain filterChain) {
        if(preparationList.isWashFace()) {
            System.out.println("洗脸");
        }
        filterChain.doFilter(preparationList, filterChain);
    }
}

洗头：

package com.gs.designmodel.chainofduty.special;

import com.gs.designmodel.chainofduty.bad.PreparationList;

/**
 * @author: Gaos
 * @Date: 2023-08-28 20:38
 **/
public class WashHairFilter implements StudyPrepareFilter{
    @Override
    public void doFilter(PreparationList preparationList, FilterChain filterChain) {
        if(preparationList.isWashHair()) {
            System.out.println("洗头");
        }
        filterChain.doFilter(preparationList, filterChain);
    }
}

吃早饭：

package com.gs.designmodel.chainofduty.special;

import com.gs.designmodel.chainofduty.bad.PreparationList;

/**
 * @author: Gaos
 * @Date: 2023-08-28 20:39
 **/
public class EatBreakfastFilter implements StudyPrepareFilter{
    @Override
    public void doFilter(PreparationList preparationList, FilterChain filterChain) {
        if(preparationList.isHaveBreakfast()) {
            System.out.println("吃完早饭");
        }
        filterChain.doFilter(preparationList, filterChain);
    }
}

测试类(调用方)：

package com.gs.designmodel.chainofduty.special;

import com.gs.designmodel.chainofduty.bad.PreparationList;
import com.gs.designmodel.chainofduty.normal.Study;

/**
 * @author: Gaos
 * @Date: 2023-08-28 20:40
 **/
public class Test {
    public static void main(String[] args) {
        PreparationList preparationList = new PreparationList();
        preparationList.setWashFace(true);
        preparationList.setWashHair(false);
        preparationList.setHaveBreakfast(true);

        Study study = new Study();

        StudyPrepareFilter washFaceFilter = new WashFaceFilter();
        StudyPrepareFilter washHairFilter = new WashHairFilter();
        StudyPrepareFilter haveBreakfastFilter = new EatBreakfastFilter();

        FilterChain filterChain = new FilterChain(study);
        filterChain.addFilter(washFaceFilter);
        filterChain.addFilter(washHairFilter);
        filterChain.addFilter(haveBreakfastFilter);

        filterChain.doFilter(preparationList, filterChain);
    }
}

结果：

洗脸
吃完早饭
计划完成，开始学习

可能会奇怪，这种写法如果增加或者减少一个责任链对象不是仍然需要修改客户端代码吗？ 但是我们其实将所有的责任链对象都封装到 FilterChain中去了。就像 Servlet、或者过滤器，增加或者减少我们不需要改动代码，我们只需要修改相应的 web.xml文件，或者是注册 bean对象时修改一下，在初始化的时候进行注入，就不需要修改业务层面的代码了。这其实也是 Servlet中 Filter的工作原理，它也是典型的责任链模式。

4.总结

当程序需要使用不同方式处理不同种类请求，而且请求类型和顺序预先未知的时候、当必须按照顺序执行多个处理者的时候、如果所需处理者及其顺序必须在运行时进行改变的时候，我们可以使用责任链模式。

它实现了请求发送者和处理者之前的耦合，使各个责任链对象可以专注于自己的事情，同时可以动态对对象个数、顺序做操作。但对代码结构和设计要求更多了，你不能把链变成一个环，那请求就会一直在里面循环。同时作为客户端来讲你的请求也可能无法达到链尾，或者直到链尾都未被处理。

参考文章：

https://blog.csdn.net/ShuSheng0007/article/details/116138433

https://www.cnblogs.com/xrq730/p/10633761.html

希望这篇文章对大家有所帮助，您的赞和收藏是对我最大的支持和认可！

必不可能穿格子衫
关注
专栏目录
UML学以致用
06-29
课程全程围绕一个真实项目展开，为你分享UML从需求分析到软件设计整个过程如何发挥作用。课程分享的是UML的新版本2.4，一共有13种图，而不是老版的9种图。学习收益：1. 学习UML新版的13种图。2. 学习在需求分析中应用UML，提升需求分析水平。 2.1 学习应用流程三剑客（活动图、状态机图、序列图）分析业务流程； 2.2 学习从序列图中提炼出用例； 2.3 学习应用类图分析业务概念模型3. 学习在软件设计中应用UML，提升软件设计水平。 3.1 学习应用部署图、包图和组件图进行架构设计； 3.2 学习业务结构建模如何转化为数据库设计； 3.3 学习应用序列图、类图、对象图进行详细设计
责任链模式详解
热门推荐
Java是世界上最好的语言
11-15 1万+
什么是责任链模式？ 责任链模式是将链中的每一个节点看作是一个对象，每个节点处理的请求不同，且内部自动维护一个下一节点对象。当一个请求从链式的首段发出时，会沿着链的路径依此传递给每一个节点对象，直至有对象处理这个请求为止。属于行为型模式。 应用场景 在日常生活中责任链模式还是很常见的。我们平时处理一些事务，往往是各部门协同合作完成某些任务。而每个部门都有各自的职责，因此很多时候事情完成一半便会转交给下一个部门，直至所有部门都通过一遍后事情才能完成。 责任链模式主要是解耦了请求与处理，客户只需要将请求发送到链上
设计模式---责任链
最新发布
weixin_44929475的博客
09-20 598
责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许你将请求沿着处理者链进行发送，直至其中一个处理者对其进行处理。这种模式可以解耦请求的发送者和接收者，增加或修改处理者时不需要改变客户端代码，提高了系统的灵活性和可维护性。
设计模式——责任链
种一棵树最好的时间是十年前，其次是现在
04-27 2682
OA系统的采购审批项目、职责链模式基本介绍、职责链模式解决 OA 系统采购审批项目
【设计模式——学习笔记】23种设计模式——职责链/责任链模式(Chain of Responsibility)（原理讲解+应用场景介绍+案例介绍+Java代码实现）
记录一名在读研究生的学习笔记、感悟、开发产物
08-15 2720
讲解责任链模式的思想，介绍其常见的应用场景，举例说明其实现方式
责任链模式
Filwaod
12-19 2316
这种情况可以使用职责链模式，把处理请求的对象实现成为职责对象，然后把它们构成一个职责链，当请求在这个链中传递的时候，具体由哪个职责对象来处理，会在运行时动态判断。职责链模式会把功能处理分散到单独的职责对象中，也就是每个职责对象只处理一个方面的功能，要把整个业务处理完，需要很多职责对象的组合，这样会产生大量的细粒度职责对象。职责链模式会把功能处理分散到单独的职责对象中，然后在使用的时候，可以动态组合职责形成职责链，从而可以灵活地给对象分配职责，也可以灵活地实现和改变对象的职责。职责链模式有以下优点。
java常用设计模式-责任链模式
08-26
责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许将请求沿着处理链进行传递，直到有一个处理程序处理它为止。在 Java 中实现责任链模式通常需要以下几个步骤： 定义处理器接口 首先，...
c++设计模式-行为型模式-责任链模式
06-19
c++设计模式-行为型模式-责任链模式；qt工程；c++简单源码； 责任链（Chain of Responsibility）模式的定义：为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的...
JAVA-设计模式-行为型模式-责任链模式
08-10
JAVA-设计模式-行为型模式-责任链模式
cpp代码-设计模式-责任链模式
07-14
责任链模式是一种行为设计模式，它允许我们向多个对象中的一个发送请求，而无需知道哪个对象会处理这个请求。在C++中，这种模式通常通过建立一个对象链来实现，每个对象都包含对下一个对象的引用，从而形成一条处理...
Java设计模式之责任链模式(UML类图分析+代码详解)
m0_51750419的博客
10-27 4849
职责链模式（Chain of Responsibility Pattern）, 又叫 责任链模式，为请求创建了一个接收者 对象的链(简单示意图)。这种模式对请求的 发送者和接收者进行解耦。职责链模式通常每个接收者都包含对另一个接 收者的引用。如果一个对象不能处理该请求， 那么它会把相同的请求传给下一个接收者，依 此类推。这种类型的设计模式属于行为型模式。
浅析Java设计模式【5】——责任链
孤山之王
08-05 1627
Java 设计模式，责任链
设计模型之责任链模式含UML完整实例)
atu1111的博客
04-16 4103
设计模型之责任链模式 1. 责任链模式 1.1 定义与特点   责任链（Chain of Responsibility）模式的定义：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。   注意：责任链模式也叫职责链模式。   在责任链模式中，客户只需要将请求发送到责任链上即可...
Java设计模式—责任链模式（Chin of Responsibility）
是个非常热爱生活、乐观、奋斗、努力的逗比青年
06-12 9657
这个示例中，具体处理器类实现了抽象处理器接口，并根据自己的能力来判断是否能够处理请求。如果不能处理，则将请求传递给下一个处理器。客户端创建责任链并将请求发送给第一个处理器，处理器依次处理请求，直到有一个处理器能够处理它为止。
责任链模式简单实现
咚咚呛的博客
08-05 752
责任链是由很多责任节点串联起来的一条任务链条，其中每一个责任节点都是一个业务处理环节。责任链模式（Chain of Responsibility）允许业务请求者将责任链视为一个整体并对其发起请求，而不必关心链条内部具体的业务逻辑与流程走向，也就是说，请求者不必关心具体是哪个节点起了作用，总之业务最终能得到相应的处理。在软件系统中，当一个业务需要经历一系列业务对象去处理时，我们可以把这些业务对象串联起来成为一条业务责任链，请求者可以直接通过访问业务责任链来完成业务的处理，最终实现请求者与响应者的解耦。...
责任链
weixin_40119194的博客
09-08 301
责任链Chain of Responsibility（CoR）——责任链模式，也叫职责链模式或者职责连锁模式责任链模式的定义　　责任链模式是一种对象的行为模式。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。要实现Chain of Responsibility模式，需要满足的基本条件是什么？ 不同的职责对象需要完成不同的
浅谈（chain of responsibility）责任链模式
学Java，找哪吒
10-25 9350
一、前言 责任链（chain of responsibility）模式很像异常的捕获和处理，当一个问题发生的时候，当前对象看一下自己是否能够处理，不能的话将问题抛给自己的上级去处理，但是要注意这里的上级不一定指的是继承关系的父类，这点和异常的处理是不一样的。所以可以这样说，当问题不能解决的时候，将问题交给另一个对象去处理，就这样一直传递下去直至当前对象找不到下线了，处理结束。如下图所示，处于同...
拦截器的设计模式--责任链模式
07-27
责任链模式是一种行为型设计模式，用于将请求的发送者和接收者解耦，并将多个对象组成一个链条，依次处理请求。在拦截器的设计中，责任链模式可以被用于实现请求的拦截和处理。 在责任链模式中，每个处理器对象都...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值