设计模式十四:责任链模式(Chain of Responsibility Pattern)

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

责任链模式(Chain of Responsibility Pattern)是一种行为设计模式,它允许你将请求沿着处理者链进行传递,直到有一个处理者能够处理该请求。
在责任链模式中,多个处理者对象被连接成一个链。当接收到一个请求时,每个处理者会判断自己是否有能力来处理该请求,如果可以处理则直接处理,如果不能处理,则将请求传递给链中的下一个处理者。这样,请求就会依次经过整个链,直到找到一个合适的处理者处理请求或者请求到达链的末端仍然没有处理者能够处理。

责任链模式适用于以下场景:

责任链模式适用于在处理对象之间存在松散耦合、需要动态指定处理对象并且能够按照特定顺序执行处理步骤的情况下使用。

  1. 请求需要被多个对象处理:当一个请求需要经过多个对象的处理时,可以使用责任链模式。每个对象都能够判断自己是否能够处理该请求,从而实现责任的分担和协作。
  2. 需要动态指定处理对象:通过将处理者对象组织成一个链,可以在运行时动态地指定处理请求的对象集合。这样可以灵活地增加或删除处理者,并且不影响客户端代码。
  3. 可以按照顺序执行处理步骤:如果有一系列相关的处理步骤需要按照特定的顺序执行,可以使用责任链模式。每个处理者只负责完成自己的处理步骤,从而简化了客户端代码,并且提高了代码的可维护性。
  4. 需要避免请求发送者和接收者之间的耦合:责任链模式通过将请求发送者和接收者解耦,使得发送者不需要知道是哪个具体处理者来处理请求。这样可以降低系统的耦合度并提高代码的灵活性。
  5. 有时候需要在处理请求之前进行预处理或后处理操作:责任链模式可以方便地在处理请求之前或之后进行其他操作,例如日志记录、数据统计等。

责任链模式的主要角色

在责任链模式中,每个具体处理者都有可能处理请求,也有可能将请求转发给链中的下一个处理者。这样,在调用方和具体处理者之间形成了一条职责链,请求会按照职责链上的顺序依次传递,直到有一个处理者能够处理请求,或者职责链的末端没有处理者能够处理请求时结束。通过动态地组织处理者对象,责任链模式可以灵活地处理请求,并且能够简化代码结构。

  1. 抽象处理者(Handler):定义一个接口,声明了处理请求的方法,并且可以拥有一个指向下一处理者的引用。该角色可以是抽象类或接口。
  2. 具体处理者(Concrete Handler):实现抽象处理者接口,对请求进行具体的处理。如果自己无法处理请求,可以将请求转发给下一个处理者。
  3. 客户端(Client):创建处理者对象,并且将请求发送到处理者链中的第一个处理者对象。客户端通常不关心具体的处理者对象,只需要知道链中的第一个处理者。

责任链模式的java代码实例

实现处理一个系统bug,由初级程序员到高级程序员到架构师顺级处理
抽象处理者

public interface Handler {

    /**
     * 下一个处理者
     *
     * @param handler
     */
    void setNext(Handler handler);

    /**
     * 处理bug
     *
     * @param bugLevel
     * @return
     */
    String dealBug(int bugLevel);

}

具体处理者

/**
 * 初级程序员
 */
public class JuniorProgrammer implements Handler {

    private Handler nextHandler;

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

    @Override
    public String dealBug(int bugLevel) {
        String res = "";
        if (bugLevel < 3) {
            System.out.println("JuniorProgrammer deal this bug!");
        } else if (nextHandler != null) {
            System.out.println("JuniorProgrammer hand over to SeniorProgrammer this bug!");
            res = nextHandler.dealBug(bugLevel);
        } else {
            System.out.println("JuniorProgrammer throw this bug!");
            res = "bug is throw into the street";
        }
        return res;
    }
}

/**
 * 高级程序员
 */
public class SeniorProgrammer implements Handler {
    private Handler nextHandler;

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

    @Override
    public String dealBug(int bugLevel) {
        String res = "";
        if (bugLevel < 6) {
            System.out.println("SeniorProgrammer deal this bug!");
        } else if (nextHandler != null) {
            System.out.println("SeniorProgrammer hand over to Architect this bug!");
            res = nextHandler.dealBug(bugLevel);
        } else {
            System.out.println("SeniorProgrammer throw this bug!");
            res = "bug is throw into the street";
        }
        return res;
    }

}

/**
 * 架构师
 */
public class Architect implements Handler {
    private Handler nextHandler;

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

    @Override
    public String dealBug(int bugLevel) {
        String res = "";
        if (bugLevel < 8) {
            System.out.println("Architect deal this bug!");
        } else if (nextHandler != null) {
            System.out.println("Architect hand over to BOSS this bug!");
            res = nextHandler.dealBug(bugLevel);
        } else {
            System.out.println("Architect is run!");
            res = "bug is throw into the street";
        }
        return res;
    }
}

客户端

public static void main(String[] args) {
        Handler juniorProgrammer = new JuniorProgrammer();
        Handler seniorProgrammer = new SeniorProgrammer();
        Handler architect = new Architect();
        juniorProgrammer.setNext(seniorProgrammer);
        seniorProgrammer.setNext(architect);
        System.out.println(juniorProgrammer.dealBug(2));
        //结果:
        // JuniorProgrammer deal this bug!
        System.out.println(juniorProgrammer.dealBug(5));
        //结果:
        // JuniorProgrammer hand over to SeniorProgrammer this bug!
        // SeniorProgrammer deal this bug!
        System.out.println(juniorProgrammer.dealBug(9));
        //结果:
        // JuniorProgrammer hand over to SeniorProgrammer this bug!
        // SeniorProgrammer hand over to Architect this bug!
        // Architect is run!
        // bug is throw into the street
    }

责任链模式的优缺点

责任链模式有以下优点:

  1. 解耦职责:责任链模式可以将请求的发送者与接收者解耦,发送者不需要知道具体的接收者是谁,而是通过链式传递请求,每个处理者只负责处理自己所能处理的请求。
  2. 灵活性和扩展性:可以动态地添加、修改或删除处理者,灵活配置责任链,满足不同的业务需求。新的请求处理者可以很方便地添加到责任链的末尾,同时也可以很容易地拆分或重组责任链。
  3. 可靠性:由于请求在责任链中依次传递,每个处理者只负责处理自己所能处理的请求,因此可以保证每个请求都会被处理。

责任链模式的缺点包括:文章来源地址https://www.toymoban.com/news/detail-641865.html

  1. 请求可能无法被处理:如果没有正确地配置责任链,或者所有处理者都无法处理某个请求,那么该请求可能无法被处理。
  2. 运行时性能开销:由于请求的传递是通过链式调用实现的,每个处理者都需要进行判断是否能够处理请求,并将请求转发给下一个处理者,可能会导致一定的运行时性能开销。
  3. 可能导致系统复杂性增加:过多或过少的处理者以及复杂的处理逻辑可能会导致责任链变得非常复杂,增加系统的复杂性。需要仔细设计和管理责任链,以确保其简洁、高效。

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

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

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

相关文章

  • 设计模式—职责链模式(Chain of Responsibility)

    目录 思维导图 什么是职责链模式? 有什么优点呢? 有什么缺点呢? 什么场景使用呢? 代码展示 ①、职责链模式 ②、加薪代码重构 使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链,并沿着这条链传递该请求,直到有

    2024年02月10日
    浏览(37)
  • 设计模式--职责链模式(Chain of Responsibility Pattern)

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

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

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

    2024年02月08日
    浏览(35)
  • 责任链模式(Chain of Responsibility)

    命令链(Chain of Command)。 责任链是一种行为设计模式 , 允许你将请求沿着处理者链进行发送。收到请求后,每个处理者均可对请求进行处理,或将其传递给链上的下个处理者 。 1. 问题 假如你正在开发一个在线订购系统。你希望对系统访问进行限制, 只允许认证用户创建

    2024年02月11日
    浏览(40)
  • 责任链模式(Chain of Responsibility)

    责任链模式是对象的行为模式。使多个对象都有机会处理请求,从而避免请求的发送者和接受者直接的耦合关系。

    2024年02月05日
    浏览(49)
  • 二十四种设计模式与六大设计原则(三):【装饰模式、迭代器模式、组合模式、观察者模式、责任链模式、访问者模式】的定义、举例说明、核心思想、适用场景和优缺点

    接上次博客:二十四种设计模式与六大设计原则(二):【门面模式、适配器模式、模板方法模式、建造者模式、桥梁模式、命令模式】的定义、举例说明、核心思想、适用场景和优缺点-CSDN博客 目录 装饰模式【Decorator Pattern】 定义 举例说明 核心思想 适用场景 优缺点 迭代

    2024年04月17日
    浏览(61)
  • 设计模式-责任链模式

    遇到一个面试的场景题目,让实现税率的计算 请使用Java语言实现如下税率计算: 1~5000 税率 0 5001~8000 3% 8001~17000 10% 17001~30000 20% 30001~40000 25% 40001~60000 30% 60001~85000 35% 85001~ 45% 要求 ⅰ. 逻辑正确,代码优雅 ⅱ. 可扩展性,考虑区间的变化,比如说起征点从5000变成10000等等,或者

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

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

    2024年02月12日
    浏览(39)
  • 设计模式—责任链模式

    一、待解决问题 : 减少代码中 if else 语句,降低代码圈复杂度或深度,增强可读性。 1、需求背景: 采购订单创建,需要验证采购员、物料、供应商、供应商的银行账号等信息。如采购员权限到期、或供应商失效等问题,都无法下单。 2、代码如下: 学习使用责任链模式后

    2024年02月10日
    浏览(45)
  • 设计模式——责任链模式

    使多个对象都有机会处理请求,从而避免了请求的发送者和接收者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,知道有对象处理它为止。 优点 能将请求和处理分开。请求者可以不用知道是谁处理的,处理者可以不用知道请求的全貌,两者解耦提高系

    2024年02月15日
    浏览(41)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包