职责链

最新推荐文章于 2024-08-11 16:14:24 发布
最新推荐文章于 2024-08-11 16:14:24 发布
阅读量514 收藏
点赞数
分类专栏： Design Patterns 文章标签： 设计模式 职责链
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dtnqy/article/details/23451269
版权

1，问题定义

客户端发起一个请求，会有多个对象来处理，将处理对象连成一个“链”，这个链可认为是“处理流程”，链上的每个处理对象有不同的处理逻辑，由链上的符合条件的对象来处理。这么做的好处是：请求和处理对象解耦，处理流程可以变换，处理对象可替换。


2，实现步骤

定义一个处理请求的抽象类，定义处理请求的抽象方法，定义一个可以设置另一个处理对象的方法（即链上的下一个处理节点）。


示例代码（假设情景：员工向领导申请经费，不同级别的领导有不同的最高限额授权，处理流程为先给项目经理，再给部门经理，最后给总经理）

/**
 * 处理请求的抽象类
 * @author Abner
 *
 */
abstract class Handler{
	protected Handler handler = null;
	
	/**
	 * 用于接收职责链上的下一个处理节点
	 * @param handler
	 */
	public void setHandler(Handler handler){
		this.handler = handler;
	}
	
	/**
	 * 处理请求的业务方法
	 * @param user
	 * @param fee
	 * @return
	 */
	protected abstract String handleRequest(String user,double fee);
}

/**
 * 具体的请求处理类，项目经理
 * @author Abner
 *
 */
class ProjectManager extends Handler{

	@Override
	protected String handleRequest(String user, double fee) {
		String str = "";
		
		if(fee <= 500){
			if("小张".equals(user)){
				str = "项目经理允许 "+user+" 申请的经费 "+fee;
			}else{
				str = "项目经理不允许 "+user+" 申请的经费 "+fee;
			}
		}else{
			if(this.handler != null){
				str = this.handler.handleRequest(user, fee);
			}
		}
		
		return str;
	}
	
}

/**
 * 具体的请求处理类，部门经理
 * @author Abner
 *
 */
class DepartmentManager extends Handler{
	
	@Override
	protected String handleRequest(String user, double fee) {
		String str = "";
		
		if(fee <= 1000){
			if("小张".equals(user)){
				str = "部门经理允许 "+user+" 申请的经费 "+fee;
			}else{
				str = "部门经理不允许 "+user+" 申请的经费 "+fee;
			}
		}else{
			if(this.handler != null){
				str = this.handler.handleRequest(user, fee);
			}
		}
		
		return str;
	}
	
}

/**
 * 具体的请求处理类，总经理
 * @author Abner
 *
 */
class GeneralManager extends Handler{
	
	@Override
	protected String handleRequest(String user, double fee) {
		String str = "";
		
		if("小张".equals(user)){
			str = "总经理允许 "+user+" 申请的经费 "+fee;
		}else{
			str = "总经理不允许 "+user+" 申请的经费 "+fee;
		}
		
		return str;
	}
	
}

	public static void main(String[] args) {
		Handler hg = new GeneralManager();
		Handler hd = new DepartmentManager();
		Handler hp = new ProjectManager();
		
		hd.setHandler(hg);
		hp.setHandler(hd);
		
		p(hp.handleRequest("小张", 300));
		p(hp.handleRequest("小李", 300));
		
		p(hp.handleRequest("小张", 800));
		p(hp.handleRequest("小李", 800));
		
		p(hp.handleRequest("小张", 1200));
		p(hp.handleRequest("小李", 1200));
	}
	
	static void p(String s){
		System.out.println(s);
	}

输出 

项目经理允许 小张 申请的经费 300.0
项目经理不允许 小李 申请的经费 300.0
部门经理允许 小张 申请的经费 800.0
部门经理不允许 小李 申请的经费 800.0
总经理允许 小张 申请的经费 1200.0
总经理不允许 小李 申请的经费 1200.0

3，认识职责链

 3.1，如何构建链

按照实现的地方可以分为：在客户端发出请求前，组合职责链，称为外部链。在Handler里面实现链的组合，称为内部链。在处理对象中，这要求处理对象不仅要处理业务，还要对整个业务流程熟悉。

  3.2，谁来处理

由职责链中符合条件的那个对象处理，如果该请求被处理了，那请求就到处为止。如果整个链中没有合适的对象，那该请求就不会被处理了。

  3.3，处理多种请求

设计时应该考虑到未来功能的扩展，比如会有多种请求。对于多种请求，可以在接口中分别定义多个方法，每种方法对应一种请求，但这种方式的缺点是每次扩展业务，都需要改接口，而且接口对应的实现类也需要改，这种方式不靠谱。另外的方式是，在接口中定义一个“通用”的方法用来处理请求，不论什么样的请求都用这个方法，将请求的业务参数封装到一个专门的请求类中，在类中定义请求的类型，在接口的实现类中针对不同类型的请求实现不同，当新增请求类型了，那就写一个之前的接口实现类的子类，在子类中重写业务方法。


示例：

当只有一个业务类型时

/**
 * 处理请求的抽象类
 * @author Abner
 *
 */
abstract class Handler{
	protected Handler handler = null;
	
	/**
	 * 用于接收职责链上的下一个处理节点
	 * @param handler
	 */
	public void setHandler(Handler handler){
		this.handler = handler;
	}
	
	/**
	 * 处理请求的业务方法
	 * @param user
	 * @param fee
	 * @return
	 */
	protected abstract String handleRequest(Request request);
}

/**
 * 具体的请求处理类，项目经理
 * @author Abner
 *
 */
class ProjectManager extends Handler{

	@Override
	protected String handleRequest(Request request) {
		String str = "";
		
		if(request.getType() == Request.FOOD_FEE){
			if(request.getFee() <= 500){
				if("小张".equals(request.getUser())){
					str = "项目经理允许 "+request.getUser()+" 申请的经费 "+request.getFee();
				}else{
					str = "项目经理不允许 "+request.getUser()+" 申请的经费 "+request.getFee();
				}
			}else{
				if(this.handler != null){
					str = this.handler.handleRequest(request);
				}
			}
		}
		
		return str;
	}
	
}


/**
 * 具体的请求处理类，部门经理
 * @author Abner
 *
 */
class DepartmentManager extends Handler{
	
	@Override
	protected String handleRequest(Request request) {
		String str = "";
		
		if(request.getType() == Request.FOOD_FEE){
			if(request.getFee() <= 1000){
				if("小张".equals(request.getUser())){
					str = "部门经理允许 "+request.getUser()+" 申请的经费 "+request.getFee();
				}else{
					str = "部门经理不允许 "+request.getUser()+" 申请的经费 "+request.getFee();
				}
			}else{
				if(this.handler != null){
					str = this.handler.handleRequest(request);
				}
			}
		}
		
		return str;
	}
	
}


/**
 * 具体的请求处理类，总经理
 * @author Abner
 *
 */
class GeneralManager extends Handler{
	
	@Override
	protected String handleRequest(Request request) {
		String str = "";
		
		if(request.getType() == Request.FOOD_FEE){
			if("小张".equals(request.getUser())){
				str = "总经理允许 "+request.getUser()+" 申请的经费 "+request.getFee();
			}else{
				str = "总经理不允许 "+request.getUser()+" 申请的经费 "+request.getFee();
			}
		}
		
		return str;
	}
	
}


/**
 * 请求类，封装了请求数据
 * @author Abner
 *
 */
class Request{
	public static int FOOD_FEE = 1;
	public static int TRAVEL_FEE = 2;
	
	int type;
	String user;
	double fee;
	public int getType() {
		return type;
	}
	public void setType(int type) {
		this.type = type;
	}
	public String getUser() {
		return user;
	}
	public void setUser(String user) {
		this.user = user;
	}
	public double getFee() {
		return fee;
	}
	public void setFee(double fee) {
		this.fee = fee;
	}
	
}

当增加了需求 

class ProjectManager2 extends ProjectManager{
	@Override
	protected String handleRequest(Request request) {
		String str = "";
		if(request.getType() == Request.TRAVEL_FEE){ //新的业务需求
			if(request.getFee() <= 500){
				str = "项目经理同意 "+request.getUser()+" 差旅费申请 "+request.getFee();
			}else{
				if(this.handler != null){
					str = this.handler.handleRequest(request);
				}
			}
		}else{ //其他的需求交给父类处理
			str = super.handleRequest(request);
		}
		
		return str;
	}
}

class GeneralManager2 extends GeneralManager{
	@Override
	protected String handleRequest(Request request) {
		String str = "";
		if(request.getType() == Request.TRAVEL_FEE){ //新的业务需求
			if(request.getFee() <= 5000){
				str = "总经理同意 "+request.getUser()+" 差旅费申请 "+request.getFee();
			}else{
				if(this.handler != null){
					str = this.handler.handleRequest(request);
				}
			}
		}else{ //其他的需求交给父类处理
			str = super.handleRequest(request);
		}
		
		return str;
	}
}


class DepartmentManager2 extends DepartmentManager{
	@Override
	protected String handleRequest(Request request) {
		String str = "";
		if(request.getType() == Request.TRAVEL_FEE){ //新的业务需求
			if(request.getFee() <= 1000){
				str = "部门经理同意 "+request.getUser()+" 差旅费申请 "+request.getFee();
			}else{
				if(this.handler != null){
					str = this.handler.handleRequest(request);
				}
			}
		}else{ //其他的需求交给父类处理
			str = super.handleRequest(request);
		}
		
		return str;
	}
}

客户端调用 

	public static void main(String[] args) {
		Handler hg = new GeneralManager2();
		Handler hd = new DepartmentManager2();
		Handler hp = new ProjectManager2();
		
		hd.setHandler(hg);
		hp.setHandler(hd);
		
		Request req = new Request();
		req.setFee(200);
		req.setType(Request.FOOD_FEE);
		req.setUser("小丽");
		
		System.out.println(hp.handleRequest(req));
		
		Request req2 = new Request();
		req2.setFee(2000);
		req2.setType(Request.TRAVEL_FEE);
		req2.setUser("小五");
		
		System.out.println(hp.handleRequest(req2));
	}

输出 

项目经理不允许 小丽 申请的经费 200.0
总经理同意 小五 差旅费申请 2000.0

这种方式的缺点是，客户端得知道每种类型的请求对应的业务处理类型，还有，没增加一种请求都写一个新的子类，要么类层次过多，要么粒度太细。

   3.4，功能链

标准的职责链是当请求被链中的一个节点处理后，整个流程就结束了。现在扩展下，可以将业务中一系列功能拆分成多个步奏，每个步奏都封装在一个处理节点里，处理流程的要从头走到尾才结束。与web中的Filter类似，过了一个Filter，过另一个Filter，直到结束。


这种方式的缺点是，客户端得知道每种类型的请求对应的业务处理类型，还有，没增加一种请求都写一个新的子类，要么类层次过多，要么粒度太细。



所谓职责链，不过是将一系列操作，这些可能是平行的（标准的职责链），也可能是相互依赖的（功能链），将其他分离出来，抽象一个统一的接口，每步操作都实现这个接口，并且提供将这些步骤连接起来的方式。由此获得的好处是，这些操作的顺序可以动态的组合（当业务流程变化时），当其中某个操作需要修改或替换时，也很容易可以实现。（分离职责，动态组合）
所谓职责链，不过是将一系列操作，这些可能是平行的（标准的职责链），也可能是相互依赖的（功能链），将其他分离出来，抽象一个统一的接口，每步操作都实现这个接口，并且提供将这些步骤连接起来的方式。由此获得的好处是，这些操作的顺序可以动态的组合（当业务流程变化时），当其中某个操作需要修改或替换时，也很容易可以实现。（分离职责，动态组合）
Abner_Niu
关注
专栏目录
职责链模式
学习记录
11-10 675
一、职责链模式介绍 职责链模式，又叫责任链模式，为请求创建了一个接受者对象的链。这种模式对请求的发送者和接受者进行解耦。职责链模式中，每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依次类推。 职责链模式，使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传...
设计模式之【职责链模式】
Janway-Win
04-11 836
什么是职责链模式？职责链模式适用于什么场景？开源代码中如何使用职责链模式？让我们一起学习设计模式之【职责链模式】。
Java设计模式之职责链模式介绍
热门推荐
qq_25409421的博客
06-15 3万+
职责链模式(chain of responsibility pattern) 定义: 避免将一个请求的发送者与接收者耦合在一起,让多个对象都有机会处理请求.将接收请求的对象连接成一条链，并且沿着这条链传递请求,直到有一个对象能够处理它为止。在职责链模式中，多个处理器（也就是刚刚定义中说的“接收对象”）依次处理同一个请求。一个请求先经过 A 处理器处理，然后再把请求传递给 B 处理器，B处理器处理完后再 传递给 C 处理器，以此类推，形成一个链条。
设计模式-职责链模式
安歌
12-13 517
职责链模式职责链模式定义职责链模式实例小结职责链模式优点职责链模式缺点 职责链模式定义 职责链模式是指解决请求发送者和请求的接受者之间的耦合，通过职责链上的多个对象对分解请求流程，实现请求在多个对象之间的传递，直到最后一个对象完成请求的处理。 职责链模式通过对需求的分解，把每件事情独立出一个模块对象去处理，这样完整的需求就被分解成一部分一部分相互独立的模块需求，通过这些对象的分工协作，每个对象只做与自己份内的事，无关的事传到下一个对象中去做，直到需求完成。 职责链模式实例 小结 职责链模式优点 解耦了请求
Java职责链模式详解
LYQ
01-20 1593
在现实生活中，常常会出现这样的事例：一个请求有多个对象可以处理，但每个对象的处理条件或权限不同。例如，公司员工请假，可批假的领导有部门负责人、副总经理、总经理等，但每个领导能批准的天数不同，员工必须根据自己要请假的天数去找不同的领导签名，也就是说员工必须记住每个领导的姓名、电话和地址等信息，这增加了难度。这个时候就可以使用我们职责链模式了。职责链模式是行为型的设计模式之一，其将链中的每一个节点看作是一个对象，每个节点处理的请求均不同，且内部自动维护一个下一节点对象。
Python 如何实现职责链设计模式？什么是职责链设计模式？Python 职责链设计模式示例代码
天河书阁 - VicRestart
11-19 332
职责链（Chain of Responsibility）设计模式是一种行为型设计模式，旨在构建一个对象链，每个对象都有机会处理请求，并且可以将请求传递给链中的下一个对象。在这个模式中，请求沿着链条依次传递，直到其中的某个对象处理请求为止。每个处理器（Handler）对象都包含一个指向下一个处理器的引用，形成了一个链式结构。请求进入链条的顶端，并从顶端的处理器开始处理，若顶端处理器无法处理该请求，它会将请求传递给下一个处理器，直至找到合适的处理器为止。
C# 设计模式之职责链模式
最新发布
鲤籽鲲的博客
08-11 1204
C# 设计模式之职责链模式
瑞_23种设计模式_职责链模式
阿瑞——从事Java后端，喜欢研读源码、自研框架、分享经验
03-20 2024
本文章为瑞_系列专栏之《23种设计模式》的职责链模式篇。主要是抽象处理者类 Handler 类中的submit方法，即递归+多态。通常用于实现不同的处理对象来处理一个请求，但具体由哪个对象处理则在运行时动态决定，可以有效避免使用众多的 if 或者 if···else 语句。为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。
「聊设计模式」之职责链模式（Chain of Responsibility）
**My Coding Family**
09-19 208
🏆本文收录于《聊设计模式》专栏，专门攻坚指数级提升，助你一臂之力，带你早日登顶🚀，欢迎持续关注&&收藏&&订阅！
设计模式之职责链模式（Chain of Responsibility Pattern）
weixin_40261082的博客
07-08 1052
设计模式之职责链模式（Chain of Responsibility Pattern）
实例讲解C#中的职责链模式
08-18
实例讲解C#中的职责链模式 职责链模式是一种常见的设计模式，它允许将处理请求的责任传递给多个对象，以便处理该请求。今天，我们将使用C#语言来实现一个职责链模式的示例，以便更好地理解和学习。 职责链模式的...
C++设计模式之职责链模式
09-04
职责链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许将请求沿着处理者对象的链式结构进行传递，直到某个对象能够处理该请求。在C++中，职责链模式通常用于解耦发送者和接收者，使得系统更加...
JavaScript设计模式之职责链模式应用示例
10-18
职责链模式是一种行为设计模式，它的核心思想是建立一个处理请求的对象链，每个对象都包含对请求的处理逻辑，以及将请求传递给下一个对象的能力。这样，请求可以在链上逐个传递，直到某个对象处理它。这种模式可以...
第17章_职责链模式.ppt
03-30
在职责链中，多个对象可以接收并处理同一个请求，这些对象形成一条链，请求沿着链传递，直到某个对象负责处理。这种方式减少了对象间的耦合，因为客户端不需要知道具体的处理者是谁，只需要将请求发送到链上。同时，...
Python设计模式之职责链模式原理与用法实例分析
09-19
职责链模式（Chain of Responsibility）是一种行为设计模式，它的核心思想是将一系列处理请求的对象组织成一条链，并在链上的每个对象（称为处理者）中定义处理请求的逻辑。当一个请求进入系统时，它会从链头开始，...
观察者模式
dtnqy的专栏
04-08 651
问题描述：
Singleton Pattern
dtnqy的专栏
02-19 632
参考文档 深入浅出单实例Singleton设计模式    by 陈浩 单例模式-维基百科
抽象工厂
dtnqy的专栏
04-02 626
抽象工厂是为一系列相关对象或相互依赖的对象创建一个接口，该接口内的方法不是随意的，各方法所返回的对象是相关或相互依赖的。 简单工厂，工厂方法，抽象工厂，三者之间的关系是：后者包含前者的特性，后者比前者更复杂一些，更进一步。简单工厂就是“选择实现”，面向接口编程，将接口对象的创建隔离起来。工厂方法在简单工厂的基础上，将接口对象的创建“延迟”到子类中去实现，工厂方法一般不对外使用，只在工厂类
简单工厂
dtnqy的专栏
03-31 621
《Design Pattern》 这个系列算是阅读《研磨设计模式》的读书笔记。 “面向接口编程” 接口中所有方法都是抽象方法，所有成员变量都是常量，只有方法定义而没有方法实现。 接口规定了实现类的外观 接口的思想，“封装隔离”，对方法调用和方法实现进行了隔离，方法实现的改变不会影响方法的调用，提高了灵活性，可扩展和维护性，“接口是系统可插拔的保证” 接口和抽象类的选择：优先使用接
C#职责链模式：灵活应对变化的策略
职责链模式(CoR, Chain of Responsibility)，是一种行为型设计模式，它在软件工程中被用来解决那些在执行流程中存在不确定性和灵活性的问题。其核心思想是将一个请求的处理过程分解为一系列的处理阶段，每个阶段都...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值