责任链模式的应用与解析

于 2024-07-20 17:54:15 发布
阅读量271 收藏 2
点赞数 4
分类专栏： 设计模式 Java 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_82095378/article/details/140575005
版权

目录

责任链模式

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

责任链模式结构

在这里插入图片描述

  1. 处理者（Handler）声明了所有具体处理者的通用接口。该接口通常仅包含单个方法用于请求处理，但有时其还会包含一个设置链上下个处理者的方法。

  2. 基础处理者（Base Handler）是一个可选的类，你可以将所有处理者共用的样本代码放置在其中。通常情况下，该类中定义了一个保存对于下个处理者引用的成员变量。 客户端可通过将处理者传递给上个处理者的构造函数或设定方法来创建链。该类还可以实现默认的处理行为：确定下个处理者存在后再将请求传递给它。

  3. 具体处理者（Concrete Handlers）包含处理请求的实际代码。每个处理者接收到请求后，都必须决定是否进行处理，以及是否沿着链传递请求。处理者通常是独立且不可变的，需要通过构造函数一次性地获得所有必要地数据。

  4. 客户端（Client）可根据程序逻辑一次性或者动态地生成链。值得注意的是，请求可发送给链上的任意一个处理者，而非必须是第一个处理者。

责任链模式通用代码：

//抽象处理者
public abstract class Handler{
    //下一个处理者
	private Handler nextHandler;
	// 对请求做出处理
	public final Response handleMessage(Request request){
		Response response = null ;
		//判断处理级别
		if(this.getHandlerLever().equals(request.getHandlerLever())){
			 response = this.echo(request);
	}else{
			 if(this.nextHandler != null){
				 response = this.nextHandler.handleMessage(request);
			 }else{
				 ...
			 }
			 return response;
	}
	
	public void setNext(Handler _handler){
		this.nextHandler = _handler;
	}
    
    //处理级别
    protected abstract Level getHandlerLevel();
    //处理任务
    protected abstract Response echo(Request request);

}

//具体处理者
public class ConcreteHandler1 extends Handler {
    //级别
    protected abstract Level getHandlerLevel(){
    ...
}
    //处理任务
    protected abstract Response echo(Request request){
    ...
}
}

public class Level{
    
}

public class Request{
    public Level getRequestLevel(){
        ...
    }
}

public class Response{
    ...
}

责任链模式适用场景

  1. 当程序需要使用不同方式处理不同种类请求， 而且请求类型和顺序预先未知时， 可以使用责任链模式。

  2. 当必须按顺序执行多个处理者时， 可以使用该模式。

  3. 如果所需处理者及其顺序必须在运行时进行改变， 可以使用责任链模式。

在这里插入图片描述

**识别方法：**该模式可通过一组对象的行为方法间接调用其他对象的相同方法来识别， 而且所有对象都会遵循相同的接口。

责任链模式优缺点

责任链模式优点：

  • 你可以控制请求处理的顺序。

  • 单一职责原则。 你可对发起操作和执行操作的类进行解耦。

  • 开闭原则。 你可以在不更改现有代码的情况下在程序中新增处理者。

责任链模式缺点：

  • 部分请求可能未被处理。

练手题目

题目描述

小明所在的公司请假需要在OA系统上发布申请，整个请求流程包括多个处理者，每个处理者负责处理不同范围的请假天数，如果一个处理者不能处理请求，就会将请求传递给下一个处理者，请你实现责任链模式，可以根据请求天数找到对应的处理者。

审批责任链由主管(Supervisor), 经理(Manager)和董事（Director)组成，他们分别能够处理3天、7天和10天的请假天数。如果超过10天，则进行否决。

输入描述

第一行是一个整数N（1 <= N <= 100), 表示请求申请的数量。

接下来的N行，每行包括一个请求申请的信息，格式为"姓名 请假天数"

输出描述

对于每个请假请求，输出一行，表示该请求是否被批准。如果被批准/否决，输出被哪一个职级的人批准/否决。

在这里插入图片描述

题解

初始解法：

import java.util.Scanner;

/**
 * 抽象处理器类，定义了责任链的基本结构
 */
abstract class Handler {
    public final static int SUPERVISOR_LEVEL_REQUEST = 1;
    public final static int MANAGER_LEVEL_REQUEST = 2;
    public final static int DIRECTOR_LEVEL_REQUEST = 3;
    
    private Handler nextHandler;
    private int level = 0;
    
    public Handler(int level) {
        this.level = level;
    }
    
    /**
     * 处理请求的方法
     * @param request 需要处理的请求
     * @return 处理结果
     */
    public final Response handleRequest(Request request) {
        if (this.level == request.getRequestLevel()) {
            return this.response(request);
        } else {
            if (this.nextHandler != null) {
                return this.nextHandler.handleRequest(request);
            } else {
                return new Response("Request denied");
            }
        }
    }
    
    /**
     * 设置下一个处理器
     * @param nextHandler 下一个处理器
     */
    public void setNext(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }
    
    /**
     * 具体的响应方法，由子类实现
     * @param request 需要处理的请求
     * @return 处理结果
     */
    protected abstract Response response(Request request);
}

/**
 * 主管处理
 */
class SupervisorHandler extends Handler {
    public SupervisorHandler() {
        super(Handler.SUPERVISOR_LEVEL_REQUEST);
    }
    
    @Override
    protected Response response(Request request) {
        System.out.println(request.getName() + " Approved by Supervisor.");
        return new Response("Approved by Supervisor");
    }
}

/**
 * 经理处理
 */
class ManagerHandler extends Handler {
    public ManagerHandler() {
        super(Handler.MANAGER_LEVEL_REQUEST);
    }
    
    @Override
    protected Response response(Request request) {
        System.out.println(request.getName() + " Approved by Manager.");
        return new Response("Approved by Manager");
    }
}

/**
 * 董事处理
 */
class DirectorHandler extends Handler {
    public DirectorHandler() {
        super(Handler.DIRECTOR_LEVEL_REQUEST);
    }
    
    @Override
    protected Response response(Request request) {
        System.out.println(request.getName() + " Approved by Director.");
        return new Response("Approved by Director");
    }
}

/**
 * 请求类，包含请求的详细信息
 */
class Request {
    private String name;
    private int level = 0;
    private int nums;
    
    public Request(String name, int nums) {
        this.name = name;
        this.nums = nums;
        if (nums > 0 && nums <= 3) {
            level = Handler.SUPERVISOR_LEVEL_REQUEST;
        } else if (nums > 3 && nums <= 5) {
            level = Handler.MANAGER_LEVEL_REQUEST;
        } else if (nums > 5 && nums <= 10) {
            level = Handler.DIRECTOR_LEVEL_REQUEST;
        } else {
            level = -1;
        }
    }
    
    public int getRequestLevel() { return this.level; }
    public String getName() { return this.name; }
    public int getNums() { return this.nums; }
}

/**
 * 响应类，包含处理结果
 */
class Response {
    private String message;
    
    public Response(String message) {
        this.message = message;
    }
    
    public String getMessage() {
        return this.message;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // 创建处理器链
        SupervisorHandler supervisorHandler = new SupervisorHandler();
        ManagerHandler managerHandler = new ManagerHandler();
        DirectorHandler directorHandler = new DirectorHandler();
        
        supervisorHandler.setNext(managerHandler);
        managerHandler.setNext(directorHandler);
        
        int n = scanner.nextInt();
        scanner.nextLine(); 
        while (n-- > 0) {
            String[] s = scanner.nextLine().split(" ");
            Request request = new Request(s[0], Integer.parseInt(s[1]));
            Response response = supervisorHandler.handleRequest(request);
            if (request.getRequestLevel() == -1) {
                System.out.println(request.getName() + " Denied by Director.");
            }
        }
        
        scanner.close();
    }
}

优化后：

import java.util.Scanner;

// 抽象处理器类，定义了责任链的基本结构
abstract class Handler {
    public final static int SUPERVISOR_LEVEL_REQUEST = 1;
    public final static int MANAGER_LEVEL_REQUEST = 2;
    public final static int DIRECTOR_LEVEL_REQUEST = 3;
    
    private Handler nextHandler;
    private int level = 0;
    
    // 构造函数，设置处理器的级别
    public Handler(int _level) {
        this.level = _level;
    }
    
    // 处理请求的方法
    public final Response handleMessage(Request request) {
        if (this.level == request.getRequestLevel()) {
            return this.response(request);
        } else {
            if (this.nextHandler != null) {
                return this.nextHandler.handleMessage(request);
            } else {
                return new Response("Request denied");
            }
        }
    }
    
    // 设置下一个处理器
    public void setNext(Handler _handler) {
        this.nextHandler = _handler;
    }
    
    protected abstract Response response(Request request);
}

// 主管处理
class SupervisorHandler extends Handler {
    public SupervisorHandler() {
        super(Handler.SUPERVISOR_LEVEL_REQUEST);
    }
    
    @Override
    protected Response response(Request request) {
        System.out.println(request.getName() + " Approved by Supervisor.");
        return new Response("Approved by Supervisor");
    }
}

// 经理处理
class ManagerHandler extends Handler {
    public ManagerHandler() {
        super(Handler.MANAGER_LEVEL_REQUEST);
    }
    
    @Override
    protected Response response(Request request) {
        System.out.println(request.getName() + " Approved by Manager.");
        return new Response("Approved by Manager");
    }
}

// 董事处理
class DirectorHandler extends Handler {
    public DirectorHandler() {
        super(Handler.DIRECTOR_LEVEL_REQUEST);
    }
    
    @Override
    protected Response response(Request request) {
        System.out.println(request.getName() + " Approved by Director.");
        return new Response("Approved by Director");
    }
}

// 请求级别的枚举，定义了不同级别的请假天数范围
enum RequestLevel {
    SUPERVISOR(1, 3),
    MANAGER(4, 5),
    DIRECTOR(6, 10);

    private final int minDays;
    private final int maxDays;

    RequestLevel(int minDays, int maxDays) {
        this.minDays = minDays;
        this.maxDays = maxDays;
    }

    // 根据天数确定请求级别
    public static RequestLevel fromDays(int days) {
        for (RequestLevel level : values()) {
            if (days >= level.minDays && days <= level.maxDays) {
                return level;
            }
        }
        return null;
    }

    public int getValue() {
        return ordinal() + 1;
    }
}

// 请求类，包含请求的详细信息
class Request {
    private String name;
    private int level;
    private int nums;
    
    public Request(String name, int nums) {
        this.name = name;
        this.nums = nums;
        RequestLevel requestLevel = RequestLevel.fromDays(nums);
        this.level = (requestLevel != null) ? requestLevel.getValue() : -1;
    }
    
    public int getRequestLevel() {
        return this.level;
    }
    
    public String getName() {
        return this.name;
    }
    
    public int getNums() {
        return this.nums;
    }
}

// 响应类，包含处理结果
class Response {
    private String message;
    
    public Response(String message) {
        this.message = message;
    }
    
    public String getMessage() {
        return this.message;
    }
}

// 主类
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // 创建处理器链
        SupervisorHandler supervisorHandler = new SupervisorHandler();
        ManagerHandler managerHandler = new ManagerHandler();
        DirectorHandler directorHandler = new DirectorHandler();
        
        // 设置处理器链的顺序
        supervisorHandler.setNext(managerHandler);
        managerHandler.setNext(directorHandler);
        
        int n = scanner.nextInt();
        scanner.nextLine(); 
        
        // 处理每个请求
        while (n-- > 0) {
            String[] s = scanner.nextLine().split(" ");
            Request request = new Request(s[0], Integer.parseInt(s[1]));
            Response response = supervisorHandler.handleMessage(request);
            if (request.getRequestLevel() == -1) {
                System.out.println(request.getName() + " Denied by Director.");
            }
        }
        
        scanner.close();
    }
}
天马行空的程序猿
关注
  • 4
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Go语言设计模式之责任链模式
菜刚RyuGou的专栏
05-10 1万+
用Go语言这种非面向对象的语言如何实现责任链模式？我们的日常工作中哪些框架和组件使用了责任链模式？
设计模式：责任链模式的应用场景及源码应用
mf97532的博客
12-28 1508
责任链模式（Chain of Responsibility Pattern）是将链中每一个节点看作是一个对象，每个节点处理的请求均不同，且内部自动维护一个下一节点对象。当一个请求从链式的首端发出时，会沿着链的路径依次传递给每一个节点对象，直至有对象处理这个请求为止，属于行为型模式。就像一场足球比赛，通过层层传递，最终射门。
责任链模式-解析与示例
04-23 504
这个例子非常简化，具体情况会根据实际业务需要做出相应的调整和完善。此外，在 Spring 框架中，很多已有的组件比如Filter等已经形成了一个责任链，可以通过配置文件或注解的方式灵活组合。
深入探索Java设计模式：责任链模式解析与实践
热门推荐
weixin_44976692的博客
03-11 2万+
通过本篇博客的学习，相信您已经对Java设计模式中的责任链模式有了深入的了解。责任链模式是一种强大的设计模式，可以帮助我们构建灵活、可扩展的系统。希望本篇博客能够帮助您更好地理解责任链模式的原理和应用场景，欢迎分享并留下您的反馈！
Java 设计模式——责任链模式
代码星辰的博客
07-10 701
本文介绍了责任链模式的相关知识。
Netty框架之责任链模式及其应用
踩踩踩从踩的博客
09-28 1273
Netty框架之概述及基本组件介绍 Reactor网络编程模型解析 前言 在上篇博客介绍完netty框架的基本组件介绍和概述，也跟着代码看了下NioEventLoopGroup的启动过程，以及基于Reactor线程模型的解析，它是开发Netty的核心思想，也是整个Netty框架的核心思想；这篇文章分析Netty中责任链模式，该模式给netty框架提供了大量一些扩展，使得netty框架更适合在业务场景上使用。 设计模式 - 责任链模式 Netty中的责任链模式也就是来自设计模式中责任链模式。.
Java设计模式：使用责任链模式和状态模式优化‘审批流程‘
沉淀、分享、成长，让自己和他人都能有所收获！
04-26 1万+
在现代软件开发过程中，动态审核流程是确保数据质量和流程合规性的关键环节。本文将深入探讨一种链式处理模式，通过详实的代码示例和理论分析，展示如何高效构建一个灵活的审核流程。关键词：动态审核流程，链式处理模式，Java实现。链式处理模式（Chain of Responsibility）是一种常用的设计模式，通过将请求的发送者和接收者解耦，让多个对象都有机会处理这个请求。在本案例中，我们将使用Java语言演示一个简单的发布审核流程，其中包含多个审核阶段。在前两个示例中，责任链模式被用来处理一个请求的审批流程。
瑞_23种设计模式_职责链模式
阿瑞——从事Java后端，喜欢研读源码、自研框架、分享经验
03-20 1973
本文章为瑞_系列专栏之《23种设计模式》的职责链模式篇。主要是抽象处理者类 Handler 类中的submit方法，即递归+多态。通常用于实现不同的处理对象来处理一个请求，但具体由哪个对象处理则在运行时动态决定，可以有效避免使用众多的 if 或者 if···else 语句。为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。
Kotlin~责任链模式
Hynson的学习笔记
07-07 1062
允许多个对象按顺序处理请求或任务。 角色介绍 Handler: 处理器接口,提供设置后继者 ConcreteHandler：具体处理器，处理请求
责任链设计模式
guye
07-01 1754
责任链模式降低了请求发送者和接收者的耦合度，并且增强了系统的可扩展性，后期可以根据需要增加新的请求处理类，满足开闭原则。增强了给对象指派职责的灵活性，比如当工作流程发生变化，可以动态地改变链内的成员或者修改它们的次序，也可动态地新增或者删除责任。最后责任链简化了对象之间的连接，一个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if···else 语句。...
iOS应用设计模式开发中职责链(责任链)模式的实现解析
09-02
在iOS实现中，职责链模式的一个显著优势是，当客户端发送请求后，它不知道哪个对象会最终处理这个请求，这样系统可以在不影响客户端的情况下动态地重新组织和分配责任。这使得链的结构非常灵活，可以方便地添加、...
PHP设计模式之责任链模式的深入解析
10-27
在实际应用中，责任链模式常用于事件处理、权限控制、日志记录等多个领域，它可以简化代码结构，使系统更具可扩展性。通过理解并恰当使用责任链模式，开发者可以构建出更灵活、可维护的PHP应用程序。
java设计模式之责任链模式
12-03
在“java设计模式之责任链模式”的主题中，我们可以深入探讨如何在实际项目中应用责任链模式，包括但不限于以下方面： 1. **代码结构优化**：通过责任链模式，可以使代码结构更加清晰，降低类间的耦合度。 2. **可...
快速学习C# 设计模式之职责链模式
08-19
这个例子展示了职责链模式在微服务场景下的应用，提供了服务发现的容错机制。当注册中心不可用时，系统可以依次尝试从本地文件和内存缓存中获取服务信息，确保服务发现的可靠性。 总结起来，职责链模式的核心要点...
(一)js前端开发中设计模式前篇之对象
峰会路转的博客
07-17 251
改进版与基础版要分开测试，不然会互相影响到。
模板方法原理与C++实现
Black.Spider的博客
07-15 302
定义一个操作中的算法骨架（稳定的），而将一些步骤的实现延迟到子类中（变化的）。模板方法使得子类可以复用一个算法的结构，而只改变（重写）这个算法的特定步骤。模板方法是一种非常实用且常见的设计模式，它使用简单的机制（虚函数）为应用程序框架提供了灵活的扩展点。模板方法中被模板方法调用的虚函数可以有具体实现，也可以没有任何实现（纯虚函数），但一般访问权限为protected，因为作为算法的一部分，它没有对外单独开放的必要。
(三)js前端开发中设计模式之工厂模式
峰会路转的博客
07-17 262
工厂模式是一种创建型设计模式，它可以帮助我们根据需求创建对象。
java设计模式：02-创建型设计模式-概览
Mr_Air_Boy的博客
07-17 350
创建型模式（Creational Patterns）主要用于处理对象创建的机制，旨在以适当的方式创建对象。这些模式的目的是将对象的创建过程与系统的其他部分分离，以提高系统的灵活性和可扩展性。通过使用创建型模式，可以使系统在创建对象时更加灵活，减少耦合，提高代码的可维护性。
Java 和 SpringBoot 中的设计模式 详解
最新发布
weixin_68074170的博客
07-19 392
假如有一结果api结果返回值的类Person，其在代码中频繁被使用。这两种使用方法的弊端有：（1）：当只需要部分参数的时候需要再定义个构造函数（比如失败的情况只需要code和message，结果肯定是空，因此不需要data），且一旦参数较多，则；（2）；Lombok插件的@Builder注解。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

天马行空的程序猿

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

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

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

打赏作者

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

抵扣说明：

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

余额充值