[设计模式]职责链(责任链)模式

水深无声 2022-12-30 01:23 222阅读 0赞

**github地址:**[https://github.com/1711680493][https_github.com_1711680493]

[点我进入github][https_github.com_1711680493]

如需了解更多设计模式,请进入我的设计模式专栏

--------------------

**目录**

职责链模式

定义

优点

缺点

结构

应用场景

扩展

实战

总结

--------------------

**可直接跳过此部分**

有一段时间没有写设计模式方面的文章了，这次因为某种需求使用到了责任链模式，于是记录一下

首先讲一下我的需求

我在做一个文件上传的功能，也就意味着需要将接收到的数据保存起来

那么，保存在什么地方呢？

我的项目后续会放到多台电脑上（多台电脑跑一个程序），于是需要使用格外的机器来保存图片，这时使用到的是网络

但是目前我使用的是一台电脑，所以保存到本地，于是我想到了将保存地址放入配置文件中

这时，我需要一个解析地址的方法

比如我输入 http://xxx.xxx 就返回 HTTP 的工具对象，输入 C:/xxx 就返回本地文件对象

具体不在乎是什么对象，只需要能够输入(input)/输出(output) 即可

最开始想到使用解释器模式，最终发现责任链模式更为合适

**概述**

可以想象一下需求，我们输入一串字符串，然后这个字符串依次经过处理类，最终返回指定对象

一个职责链就如同其名一样，一条链子，所以都是依次被执行，每一个对象有机会

例如上面的例子，假设有类 HTTP 用来判断是否为http链接，File 用来判断是否为本地地址，那么流程如下

客户端输入链接->HTTP处理 不能处理/不是->File处理

↓ 可以处理 ↓可以处理

返回对应对象 返回对应对象

但是按照上面这样，比如我增加 https，则会经过 File 在处理 https，性能就会降低

于是我想到了分级（树结构），策略模式+职责链模式完成我的需求

就好比 有专门做Java开发的和专门做 C\# 开发的，做Java开发的主程接到需求，这需求是用C\#开发xxx，就直接把需求丢给C\#主程

但是需求是Java的，自己有不会或者不想搞，就丢给别的Java开发

以上,我将此功能写在了我的Java工具包中 https://github.com/1711680493/ShendiKit 对应 shendi.kit.path.URL

--------------------

# 职责链模式 #

职责链模式又叫责任链模式(Chain of Responsibility)

把请求从链中的一个对象传到下一个对象,直到请求被响应为止,通过这种方式去除对象之间的耦合

## 定义 ##

为了避免请求发送者与多个请求处理者耦合在一起,将所有请求的处理者通过前一对象记住其下一个对象的引用而连成的一条链,

当有请求发生时,可将请求沿着这条链传递,直到有对象处理它为止

在责任链模式中,客户只需要将请求发送到责任链上即可,无须关心请求的处理细节和请求的传递过程,所以责任链将请求的发送者和请求的处理者解耦了

责任链模式是一种对象行为型模式

## 优点 ##

降低了对象之间的耦合度,该模式使得一个对象无需知道到底是哪一个对象处理其请求以及链的结构,发送者和接收者也无需拥有对方的明确信息

增强了系统的可扩展性,可以根据需要增加新的请求处理类,满足开闭原则

增强了给对象指派职责的灵活性,当工作流程发生变化,可以动态地改变链内成员或者调动它们的次序,也可动态地新增或者删除责任

责任链简化了对象之间的链接,每个对象只需保持一个指向其后继者的引用,不需保持其他所有处理者的引用,这避免了使用众多if,或者if else语句

责任分担,每个类只需要处理自己该处理的工作,不该处理的传递给下一个对象完成,明确各类的责任范围,符合类的单一职责原则

## 缺点 ##

不能保证每个请求一定被处理,由于一个请求没有明确的接收者,所以不能保证它一定会被处理,该请求可能一直传到链的末端都得不到处理

对比较长的职责链,请求的处理可能涉及多个处理对象,系统性能将受到一定影响

职责链建立的合理性要靠客户端来保证,增加了客户端的复杂性,可能会由于职责链的错误设置而导致系统出错,如可能会造成循环调用

通常情况下,可以通过数据链表来实现职责链模式的数据结构

## 结构 ##

抽象处理者角色: 定义处理请求的接口,包含抽象处理方法和一个后继链接

具体处理者角色: 实现抽象处理者的处理方法,判断能否处理本次请求,如果可以处理请求则处理,否则将该请求转给他的后继者

客户类角色: 创建处理链,并向链头的具体处理者对象提交请求,它不关心处理细节和请求的传递过程

## 应用场景 ##

有多个对象可以处理一个请求,哪个对象处理该请求由运行时刻自动确定

可动态指定一组对象处理请求,或添加新的处理对象

在不明确指定请求处理者的情况下,向多个处理者中的一个提交请求

## 扩展 ##

*  纯的职责链模式:一个请求必须被某一个处理者对象接收,且一个具体处理者对某个请求的处理只能采用两种行为之一,自己处理(承担责任);把责任推给下家处理;
 *  不纯的职责链模式:允许出现某一个具体处理者对象在承担了请求的一部分责任后又将剩余的责任传给下家的情况,且一个请求可以最终不被任何接收端对象所接收

## 实战 ##

通过传递字符串来演示一下

/**
     * 职责链模式
     * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>
     * @version 1.0
     */
    public class ChainOfResponsibility {
    
    	public static void main(String[] args) {
    
    		Handler ha = new HandlerA();
    		Handler hb = new HandlerB();
    		Handler hbc = new HandlerBC();
    		
    		ha.h = hb;
    		hb.h = hbc;
    		
    		ha.handler("ABC");
    	}
    	
    }
    
    /**
     * 抽象处理者
     * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>
     * @version 1.0
     */
    abstract class Handler {
    	
    	protected Handler h;
        public void setHandler(Handler h) {
        	this.h = h;
        }
        
        public abstract void handler(String req);
    	
    }
    
    /**
     * 具体处理者,只处理A
     * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>
     * @version 1.0
     */
    class HandlerA extends Handler {
    
    	@Override
    	public void handler(String req) {
    		if (req.contains("A")) {
    			System.out.println("有A");
    			// 如果还有别的则交给下一个执行
    			if (req.contains("B") || req.contains("C")) {
    				if (h != null) h.handler(req);
    			}
    		} else {
    			if (h != null) h.handler(req);
    		}
    	}
    	
    }
    
    /**
     * 具体处理者,只处理AB
     * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>
     * @version 1.0
     */
    class HandlerB extends Handler {
    
    	@Override
    	public void handler(String req) {
    		if (req.contains("B")) {
    			System.out.println("有B");
    			// 如果还有别的则交给下一个执行
    			if (req.contains("A") || req.contains("C")) {
    				if (h != null) h.handler(req);
    			}
    		} else {
    			if (h != null) h.handler(req);
    		}
    	}
    	
    }
    
    /**
     * 具体处理者,只处理BC
     * @author Shendi <a href='tencent://AddContact/?fromId=45&fromSubId=1&subcmd=all&uin=1711680493'>QQ</a>
     * @version 1.0
     */
    class HandlerBC extends Handler {
    
    	@Override
    	public void handler(String req) {
    		if (req.contains("BC")) {
    			System.out.println("有BC");
    			// 如果还有别的则交给下一个执行
    			if (req.contains("A") || req.contains("B")) {
    				if (h != null) h.handler(req);
    			}
    		} else {
    			if (h != null) h.handler(req);
    		}
    	}
    	
    }

输出如下

![20201223192402946.png][]

## 总结 ##

职责链模式由客户端创建处理链(将对象创建,给设置下一个链是什么)后调用第一个链来进行处理

[https_github.com_1711680493]: https://github.com/1711680493
[20201223192402946.png]: /images/20221120/5fca52af74ee4880ab59d557c7efd78e.png