设计模式-责任链模式（Chain of Responsibility）

于 2023-11-10 07:00:00 发布
阅读量920 收藏 5
点赞数 1
分类专栏： # 设计模式 文章标签： 设计模式 责任链模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/miaoyl1234/article/details/134294193
版权

设计模式-责任链模式（Chain of Responsibility）

一、责任链模式概述

1.1 什么是责任链模式

责任链模式是一种面向对象设计模式，该模式中包含了一系列处理对象和命令对象。每个处理对象都有能力决定自己可以处理哪些命令对象，如果遇到无法处理的命令对象，它会将请求传递给下一个处理对象。这种模式的核心在于避免请求发送者与接收者之间的紧密耦合，让多个对象都有可能接收请求，并将这些对象连接成一条链，沿着这条链传递请求，直到有对象处理它为止。

以公司员工请假为例，员工的请假请求可能有多个领导可以批准，但每个领导的批准权限不同。员工需要根据自己要请假的天数去找对应的领导签名。这就是责任链模式的一个生动实例。其实现过程就如同“击鼓传花”游戏，每个参与者都有机会处理事件，但如果无法处理则继续传给下一个人。

在开发中，责任链模式常用于处理复杂数据处理和校验的场景。通过使用责任链模式，可以将一个请求的处理过程分解为一系列的处理对象，使得代码更加清晰、灵活和易于维护。

1.2 简单实现责任链模式

首先，我们定义一个抽象的处理类（Handler）：

public abstract class Handler {
    protected Handler nextHandler;

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

    public abstract void handleRequest(String request);
}

然后，我们创建具体的处理类（ConcreteHandler），它们继承自抽象的处理类，并实现了handleRequest方法：

public class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("A")) {
            System.out.println("ConcreteHandlerA处理了请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("没有处理器可以处理该请求：" + request);
        }
    }
}

public class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("B")) {
            System.out.println("ConcreteHandlerB处理了请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("没有处理器可以处理该请求：" + request);
        }
    }
}

然后，我们创建具体的处理类（ConcreteHandler），它们继承自抽象的处理类，并实现了handleRequest方法：

public class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("A")) {
            System.out.println("ConcreteHandlerA处理了请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("没有处理器可以处理该请求：" + request);
        }
    }
}

public class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("B")) {
            System.out.println("ConcreteHandlerB处理了请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("没有处理器可以处理该请求：" + request);
        }
    }
}

最后，我们在客户端代码中创建处理器对象，并将它们连接起来：

public class Client {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();

        handlerA.setNextHandler(handlerB);

        handlerA.handleRequest("A"); // 输出：ConcreteHandlerA处理了请求：A
        handlerA.handleRequest("B"); // 输出：ConcreteHandlerB处理了请求：B
        handlerA.handleRequest("C"); // 输出：没有处理器可以处理该请求：C
    }
}

这样，我们就实现了一个简单的责任链模式。当客户端发送一个请求时，它会沿着责任链传递，直到找到一个可以处理该请求的处理器。

1.3 使用责任链模式的注意事项

  • 1、存在循环调用的风险。在实现责任链模式时，可能存在节点之间的循环调用，从而形成死循环。这种循环调用的风险通常出现在两种情况下：一是责任链节点自身会对请求进行多次处理；二是责任链节点之间相互调用。为了避免这种情况，需要对责任链节点的处理逻辑进行严格的控制和规范，确保节点的处理逻辑只能一次性地对请求进行处理，并且不会出现相互调用的情况。另外，可以通过设置最大处理次数或者设置超时时间等机制来防止出现死循环，从而避免对系统的影响。

  • 2、确定责任链的顶端和底端。在实现责任链模式时，需要确定责任链的顶端和底端，以确保请求能够被正确地传递和处理。

  • 3、避免请求发送者与接收者之间的紧密耦合关系。在责任链模式中，客户只需要将请求发送到责任链上即可，无须关心请求的处理细节和请求的传递过程，这样可以降低系统的耦合度。

  • 4、注意性能问题。由于每个处理器都需要处理请求和传递请求，因此使用责任链模式可能会导致系统性能下降。为了解决这个问题，可以考虑使用异步处理等方式来提高系统的性能。

二、责任链模式的用途

责任链模式主要用于处理那些需要经过多个处理步骤或处理者才能完成的请求。其主要应用场景包括：

  • 1、过滤器模式：例如在Java Web应用中，过滤器链用于对HTTP请求和响应进行处理。每个过滤器负责处理特定的任务，然后将请求传递给下一个过滤器。这种场景下，责任链模式可以有效地解耦每个过滤器的处理逻辑。

  • 2、事件处理模式：在图形用户界面编程中，事件处理通常采用责任链模式。例如在一个按钮上，可能有多个监听器（如点击、鼠标移动等），每个监听器负责处理一种特定的事件。当事件发生时，会沿着监听器链进行传递，直到有监听器处理该事件为止。

  • 3、工作流引擎：在企业级应用中，工作流引擎通常使用责任链模式来处理复杂的业务流程。每个处理节点负责处理流程中的特定步骤，然后将工作项传递给下一个处理节点。

  • 4、权限设计：在权限设计中，可以使用责任链模式来实现权限验证。例如，一个用户可能需要经过多个角色的权限验证，每个角色负责验证一部分权限。这样既可以实现权限验证的逻辑分离，又可以提高系统的灵活性和扩展性。

三、责任链模式实现方式

3.1 基于接口实现责任链模式

首先，我们需要定义一个处理请求的接口，然后创建具体的处理器类实现该接口。最后，在客户端代码中，我们将处理器对象链接在一起，形成一个责任链。

以下是一个简单的Java实现：

定义处理请求的接口：

public interface RequestHandler {
    void setNextHandler(RequestHandler nextHandler);
    void handleRequest(String request);
}

创建具体的处理器类实现该接口：

public class ConcreteHandlerA implements RequestHandler {
    private RequestHandler nextHandler;

    @Override
    public void setNextHandler(RequestHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(String request) {
        if (request.startsWith("A")) {
            System.out.println("ConcreteHandlerA处理了请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("没有处理器可以处理该请求：" + request);
        }
    }
}

public class ConcreteHandlerB implements RequestHandler {
    private RequestHandler nextHandler;

    @Override
    public void setNextHandler(RequestHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public void handleRequest(String request) {
        if (request.startsWith("B")) {
            System.out.println("ConcreteHandlerB处理了请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("没有处理器可以处理该请求：" + request);
        }
    }
}

在客户端代码中，将处理器对象链接在一起，形成一个责任链：

public class Client {
    public static void main(String[] args) {
        RequestHandler handlerA = new ConcreteHandlerA();
        RequestHandler handlerB = new ConcreteHandlerB();

        handlerA.setNextHandler(handlerB);

        handlerA.handleRequest("A1");
        handlerA.handleRequest("B1");
        handlerA.handleRequest("C1");
    }
}

运行客户端代码，输出结果如下：

ConcreteHandlerA处理了请求：A1
ConcreteHandlerB处理了请求：B1
没有处理器可以处理该请求：C1

3.2 基于抽象类实现责任链模式

要实现基于抽象类的责任链模式，首先需要创建一个抽象类，然后创建具体的处理器类继承自抽象类。最后在客户端代码中，将处理器对象链接在一起，形成一个责任链。以下是一个简单的示例：

创建一个抽象类Handler：

public abstract class Handler {
    protected Handler nextHandler;

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

    public abstract void handleRequest(String request);
}

创建具体的处理器类ConcreteHandlerA和ConcreteHandlerB，分别继承自Handler：

public class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("A")) {
            System.out.println("ConcreteHandlerA处理了请求：" + request);
        } else {
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            } else {
                System.out.println("没有处理器可以处理该请求：" + request);
            }
        }
    }
}

public class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("B")) {
            System.out.println("ConcreteHandlerB处理了请求：" + request);
        } else {
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            } else {
                System.out.println("没有处理器可以处理该请求：" + request);
            }
        }
    }
}

在客户端代码中，将处理器对象链接在一起，形成一个责任链：

public class Client {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();

        handlerA.setNextHandler(handlerB);

        handlerA.handleRequest("A");
        handlerA.handleRequest("B");
        handlerA.handleRequest("C");
    }
}

运行客户端代码，输出结果如下：

ConcreteHandlerA处理了请求：A
ConcreteHandlerB处理了请求：B
没有处理器可以处理该请求：C

3.3 基于匿名内部类实现责任链模式

public interface Handler {
    void setNextHandler(Handler nextHandler);
    void handleRequest(String request);
}

public class ConcreteHandlerA implements Handler {
    private Handler nextHandler;

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

    @Override
    public void handleRequest(String request) {
        if ("A".equals(request)) {
            System.out.println("ConcreteHandlerA处理了请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("没有处理器可以处理该请求：" + request);
        }
    }
}

public class ConcreteHandlerB implements Handler {
    private Handler nextHandler;

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

    @Override
    public void handleRequest(String request) {
        if ("B".equals(request)) {
            System.out.println("ConcreteHandlerB处理了请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("没有处理器可以处理该请求：" + request);
        }
    }
}

public class Client {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();

        handlerA.setNextHandler(handlerB);

        handlerA.handleRequest("A");
        handlerA.handleRequest("B");
        handlerA.handleRequest("C");
    }
}

3.4 基于Lambda表达式实现责任链模式

责任链模式是一种行为设计模式，它允许多个对象处理一个请求，从而避免了请求的发送者和接收者之间的耦合关系。在Java中，我们可以使用Lambda表达式和接口来实现责任链模式。

首先，我们需要定义一个处理器接口，该接口包含一个处理方法：

public interface Handler {
    void handleRequest(String request);
}

接下来，我们可以创建具体的处理器类，实现这个接口：

public class ConcreteHandlerA implements Handler {
    private Handler nextHandler;

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

    @Override
    public void handleRequest(String request) {
        if (request.equals("A")) {
            System.out.println("ConcreteHandlerA处理了请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("没有处理器可以处理该请求：" + request);
        }
    }
}

public class ConcreteHandlerB implements Handler {
    private Handler nextHandler;

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

    @Override
    public void handleRequest(String request) {
        if (request.equals("B")) {
            System.out.println("ConcreteHandlerB处理了请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("没有处理器可以处理该请求：" + request);
        }
    }
}

最后，我们可以使用Lambda表达式来创建处理器对象，并设置责任链：

public class Main {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();

        handlerA.setNextHandler(handlerB);

        handlerA.handleRequest("A");
        handlerA.handleRequest("B");
        handlerA.handleRequest("C");
    }
}

运行上述代码，输出结果如下：

ConcreteHandlerA处理了请求：A
ConcreteHandlerB处理了请求：B
没有处理器可以处理该请求：C
一碗油泼面
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java设计模式之责任链模式（Chain of Responsibility模式）介绍
09-03
责任链模式（Chain of Responsibility，CoR）是一种行为设计模式，它允许将请求沿着处理者对象的链式结构进行传递，直到某个对象处理这个请求。每个处理者对象都包含对下一个处理者的引用，如果当前处理者无法处理...
设计模式——责任链模式（职责链模式）
白日梦
01-05 1478
前言: 对于在生活中总会出现类似于请假，加薪，离职等多个对象对一个请求进行判断的情况，而在编写程序中也会出现类似情况，因此设计模式中责任链模式多用于处理该情况。 1.责任链模式概念 1.1责任链模式的定义 定义： 为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。 1.2 责任链模式优缺点: 主要优点： 降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理其请求
【设计模式】责任链模式 ( 简介 | 适用场景 | 优缺点 | 代码示例 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
08-13 6596
一、责任链模式简介、 二、责任链模式相关设计模式、 三、责任链模式 代码示例、 1、用户账户类、 2、校验器父类、 3、用户名校验器、 4、密码校验器、 5、电话号码校验器、 6、运行测试、
23种设计模式之职责链模式（Chain of Responsibility Pattern）
热门推荐
小威的博客
06-04 1万+
本篇文章将23种设计模式中的访问者模式，此篇文章为一天学习一个设计模式系列文章，后面会分享其他模式知识。
责任链模式详解
Java是世界上最好的语言
11-15 1万+
什么是责任链模式？ 责任链模式是将链中的每一个节点看作是一个对象，每个节点处理的请求不同，且内部自动维护一个下一节点对象。当一个请求从链式的首段发出时，会沿着链的路径依此传递给每一个节点对象，直至有对象处理这个请求为止。属于行为型模式。 应用场景 在日常生活中责任链模式还是很常见的。我们平时处理一些事务，往往是各部门协同合作完成某些任务。而每个部门都有各自的职责，因此很多时候事情完成一半便会转交给下一个部门，直至所有部门都通过一遍后事情才能完成。 责任链模式主要是解耦了请求与处理，客户只需要将请求发送到链上
浅谈（chain of responsibility）责任链模式
学Java，找哪吒
10-25 9085
一、前言 责任链（chain of responsibility）模式很像异常的捕获和处理，当一个问题发生的时候，当前对象看一下自己是否能够处理，不能的话将问题抛给自己的上级去处理，但是要注意这里的上级不一定指的是继承关系的父类，这点和异常的处理是不一样的。所以可以这样说，当问题不能解决的时候，将问题交给另一个对象去处理，就这样一直传递下去直至当前对象找不到下线了，处理结束。如下图所示，处于同...
设计模式之责任链模式
weixin_64366370的博客
05-07 2692
责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。
java常用设计模式-责任链模式
08-26
责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许将请求沿着处理链进行传递，直到有一个处理程序处理它为止。在 Java 中实现责任链模式通常需要以下几个步骤： 定义处理器接口 首先，...
chain-of-responsibility-demo 责任链模式demo
03-17
chain-of-responsibility-demo 责任链模式demo
c++设计模式-行为型模式-责任链模式
06-19
责任链（Chain of Responsibility）模式的定义：为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递...
设计模式C++学习之责任链模式（Chain of Responsibility）
09-07
设计模式C++学习之责任链模式（Chain of Responsibility）
行为型设计模式——责任链模式
最新发布
庄小焱
09-28 2002
责任链模式(Chain of responsibility pattern): 通过责任链模式, 你可以为某个请求创建一个对象链. 每个对象依序检查此请求并对其进行处理或者将它传给链中的下一个对象。
责任链模式
每一天都为明天的博客
10-08 1439
SpringBoot之责任链模式
【行为型模式】责任链模式
陈宝子的博客
04-17 985
责任链模式(Chain of Responsibility)是一种行为型设计模式，它允许对象在链上依次处理请求，用户只需要将请求发送到责任链上即可，无须关心请求的处理细节和请求的传递,从而避免了请求发送者和接收者之间的直接耦合。具体来说，当一个请求进入责任链时，每个对象都有机会对该请求进行处理，如果当前对象无法处理该请求，则将其传递给下一个对象，直到找到能够处理请求的对象为止。责任链模式在实际开发中非常常用，它可以帮助我们简化代码结构，提高可维护性和可扩展性。
责任链模式（Chain of Responsibility Pattern）
weixin_43771403的博客
08-24 803
责任链模式（避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止） 优点： 1、将请求发送者和接收者解耦，发送者和接收者也无须拥有对方的明确信息。 2、当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，动态地新增或者删除责任，增强了系统的可扩展性。 3、避免了使用众多的 if 或者 if···else 语句。 4、符合类的单一职责原则。 缺点： 1、请求没有明确的接收者，所
java设计模式---责任链模式详解
zhenghuishengq的博客
09-11 1万+
深入理解责任链模式
最近学习了责任链模式
weixin_30553065的博客
04-14 436
前言 来菜鸟这个大家庭10个月了，总得来说比较融入了环境，同时在忙碌的工作中也深感技术积累不够，在优秀的人身边工作必须更加花时间去提升自己的技术能力、技术视野，所以开一个系列文章，标题就轻松一点叫做最近学习了XXX吧，记录一下自己的学习心得。 由于最近想对系统进行一个小改造，想到使用责任链模式会非常适合，因此就系统地学习总结了一下责任链模式，分享给大家。 责任链模式的定义与特点 责任...
「设计模式(四) - 责任链模式」
我有一壶酒，足以慰风尘
01-17 607
「设计模式(四) - 责任链模式」 一、能力越大责任越大 顾名思义，“责任链”就像是一根链条串联起来的一系列操作，每个操作都息息相关。请假的审批流程，报销流程等等依据不同职位对应的人员完成相应的审批操作；可以说是层层推进的。而我们最终关心的结果就是同意或者驳回。 二、责任链模式 Chain of Responsibility 当请求端Client发出请求时，为了降低请求者Client与处理对象们Handlers之间的耦合；同时满足众多Handlers都能有机会参与到对请求的处理，将Handler对象组成一
chain of responsibility 模式
04-10
责任链模式是一种行为型设计模式，用于将一系列处理程序组成链并沿着链传递请求，直到有一个处理程序处理请求为止。在这个模式中，请求从链的起点开始传递，经过每一个处理程序，直到到达链的末尾。每个处理程序决定是否处理请求并将其传递到下一个处理程序。这种设计可以使程序更加灵活，并支持动态地添加、修改或删除处理程序。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一碗油泼面

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值