Chain of Responsibility 责任链模式 MD
我的GitHub | 我的博客 | 我的微信 | 我的邮箱 |
---|---|---|---|
baiqiantao | baiqiantao | bqt20094 | baiqiantao@sina.com |
责任链模式
简介
责任链模式是一种对象的行为模式。在责任链模式里,很多对象由每一个对象对其下家的引用
而连接起来形成一条链,请求在这个链上【传递】,直到链上的某一个对象决定处理此请求
。发出这个请求的客户端
并不知道链上的哪一个对象最终处理这个请求,这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。
责任链模式屏蔽了请求的处理过程
,你发起一个请求到底是谁处理的,这个你不用关心,只要你把请求抛给责任链的第一个处理者,最终会返回一个处理结果(当然也可以不做任何处理),作为请求者可以不用知道到底是需要谁来处理的
,这是责任链模式的核心。
责任链就是从一个起点发起请求,然后沿着任务链依次传递给每一个节点上的对象
,直到有一个节点处理这个请求为止。
使多个对象都有机会处理请求,从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有对象处理它为止。
现实中最适合责任链的应该就是部门领导之间的上报请求了。比如员工要申请一笔资金,会先向组长申请,额度如果在组长的范围内,组长就批了,组长权限不够就向主管申请,主管如果也额度不够就向经理申请。这就形成了个责任链。
组长,主管,经理。每个人都是责任链上的一个节点。一个请求被层层转达,直到被处理或没有一个人能处理。普通员工,就是那个申请的发起者,并不需要知道到底最后是谁审批的,他只要拿到钱就行了。这样就造成了请求者和处理者的解耦。
责任链有一个缺点是,大家在开发的时候要注意,调试不是很方便,特别是链条比较长,环节比较多的时候,由于采用了类似递归的方式,调试的时候逻辑可能比较复杂。
适用性
- 有多个对象可以处理一个请求,具体哪个对象处理该请求在运行时刻自动确定。
- 在请求的处理者不明确的情况下,向多个对象的一个提交请求。
- 需要动态指定一组对象处理请求。
角色
- Handler:抽象处理者角色,声明一个处理请求的方法,并保持对下一个处理节点Handler对象的引用。
- ConcreteHandler: 具体的处理者,对请求进行处理,如果不处理就讲请求转发给下一个节点上的处理对象。
作用:请求会被链上的对象处理,但是客户端不知道请求会被哪些对象处理
通过把请求从一个对象传递到链条中下一个对象的方式,直到请求被处理完毕,以实现对象间的解耦。
JDK中体现:ClassLoader的委托模型
简单版案例
抽象处理者
public abstract class Handler {
protected Handler successor;
public abstract void handleRequest(String condition);
}
实际处理者1
public class ConcreteHandler1 extends Handler {
@Override
public void handleRequest(String condition) {
if ("ConcreteHandler1".equals(condition)){
System.out.println("ConcreteHandler1 handled");
}else {
successor.handleRequest(condition);
}
}
}
实际处理者2
public class ConcreteHandler2 extends Handler {
@Override
public void handleRequest(String condition) {
if ("ConcreteHandler2".equals(condition)) {
System.out.println("ConcreteHandler2 handled");
} else {
successor.handleRequest(condition);
}
}
}
客户端调用
组成一条责任链
public class Client {
public static void main(String[] args) {
ConcreteHandler1 concreteHandler1 = new ConcreteHandler1();
ConcreteHandler2 concreteHandler2 = new ConcreteHandler2();
concreteHandler1.successor = concreteHandler2;
concreteHandler2.successor = concreteHandler1;
concreteHandler1.handleRequest("ConcreteHandler2");
}
}
简单版中,传递的都是统一的字符串,处理也比较简单。但是在实际开发中,责任链中的请求处理规则是不尽相同的,这种时候需要对请求进行封装,同时对请求的处理规则也进行一个封装,
复杂版案例
抽象处理者
public abstract class AbstractHandler {
protected AbstractHandler nextHandler;
public final void handleRequest(AbstractRequest request){
if (request.getRequestLevel()==getHandleLevel()){
handle(request);
}else {
if (nextHandler!=null){
nextHandler.handleRequest(request);
}else {
System.out.println("没有对象能处理这个请求");
}
}
}
protected abstract int getHandleLevel();
protected abstract void handle(AbstractRequest request);
}
三个处理者
public class Handler1 extends AbstractHandler {
@Override
protected int getHandleLevel() {
return 1;
}
@Override
protected void handle(AbstractRequest request) {
System.out.println("Handler1处理了请求:"+request.getRequestLevel());
}
}
public class Handler2 extends AbstractHandler {
@Override
protected int getHandleLevel() {
return 2;
}
@Override
protected void handle(AbstractRequest request) {
System.out.println("Handler2处理了请求:"+request.getRequestLevel());
}
}
public class Handler3 extends AbstractHandler {
@Override
protected int getHandleLevel() {
return 3;
}
@Override
protected void handle(AbstractRequest request) {
System.out.println("Handler3处理了请求:"+request.getRequestLevel());
}
}
抽象请求者
public abstract class AbstractRequest {
private Object obj;
public AbstractRequest(Object obj){
this.obj=obj;
}
public Object getContent(){
return obj;
}
public abstract int getRequestLevel();
}
实现的三个请求
public class Request1 extends AbstractRequest {
public Request1(Object obj) {
super(obj);
}
@Override
public int getRequestLevel() {
return 1;
}
}
public class Request2 extends AbstractRequest {
public Request2(Object obj) {
super(obj);
}
@Override
public int getRequestLevel() {
return 2;
}
}
public class Request3 extends AbstractRequest {
public Request3(Object obj) {
super(obj);
}
@Override
public int getRequestLevel() {
return 3;
}
}
客户端调用
public class Client {
public static void main(String[] args) {
//构造三个处理对象
AbstractHandler handler1 = new Handler1();
AbstractHandler handler2 = new Handler2();
AbstractHandler handler3 = new Handler3();
//串成一个责任链
handler1.nextHandler = handler2;
handler2.nextHandler = handler3;
//构造三个请求
AbstractRequest request1 = new Request1("A");
AbstractRequest request2 = new Request2("B");
AbstractRequest request3 = new Request3("C");
handler1.handleRequest(request1);
handler1.handleRequest(request2);
handler1.handleRequest(request3);
}
}
实际案例
抽象的领导
public abstract class Leader {
protected Leader nextLeader;
public final void handleRequest(int money) {
if (money < = getLimit()) {
handle(money);
} else {
if (nextLeader != null) {
nextLeader.handleRequest(money);
} else {
System.out.println(money + "没人能批准");
}
}
}
public abstract int getLimit();
public abstract void handle(int money);
}
三个具体的领导
public class GroupLeader extends Leader {
@Override
public int getLimit() {
return 5000;
}
@Override
public void handle(int money) {
System.out.println(money + "由组长批准");
}
}
public class Director extends Leader {
@Override
public int getLimit() {
return 10000;
}
@Override
public void handle(int money) {
System.out.println(money + "由主管批准");
}
}
public class Manager extends Leader {
@Override
public int getLimit() {
return 20000;
}
@Override
public void handle(int money) {
System.out.println(money + "由经理批准");
}
}
员工申请
public class Test {
public static void main(String[] args) {
Leader groupLeader = new GroupLeader();
Leader director = new Director();
Leader manager = new Manager();
groupLeader.nextLeader = director;
director.nextLeader = manager;
groupLeader.handleRequest(4000);
groupLeader.handleRequest(12000);
groupLeader.handleRequest(30000);
}
}
2016-04-21
Chain of Responsibility 责任链模式 MD的更多相关文章
- 设计模式(13)--Chain of Responsibility(责任链模式)--行为型
作者QQ:1095737364 QQ群:123300273 欢迎加入! 1.模式定义: 责任链模式是一种对象的行为模式.在责任链模式里,很多对象由每一个对象对其下家的引用而连接起来形成一 ...
- Chain of Responsibility 责任链模式
简介 责任链模式是一种对象的行为模式.在责任链模式里,很多对象由每一个对象对其[下家]的引用而连接起来形成一条链,请求在这个链上[传递],直到链上的某一个对象决定处理此请求.发出这个请求的客户端并不知 ...
- 设计模式(一)Chain Of Responsibility责任链模式
设计模式篇章,源于网课的学习,以及个人的整理 在我们接收用户提交的字符时,常常会使用到过滤,在学习责任链模式前,我们是这样做的 1.定义一个类 public class MsgProcesser { ...
- python 设计模式之 (Chain of Responsibility)责任链模式
#写在前面 对于每一种设计模式,如果不理解它的原理和结构,是写不出例子来的.所以弄明白很重要. 等过完这段浑浑噩噩的日子,我要找个遍地开花的地方开怀大笑一场 #责任链模式定义 简书上一网友就把这个定义 ...
- 设计模式C++学习笔记之十七(Chain of Responsibility责任链模式)
17.1.解释 概念:使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系.将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止. main(),客户 IWom ...
- Chain of Responsibility - 责任链模式
定义 使多个对象都有机会处理请求,从而避免请求的发送者和接受者之间的耦合度. 案例 比方如今有一个图形界面,它包含一个应用Application类,一个主窗体Window,一个buttonButton ...
- 设计模式19:Chain Of Responsibility 职责链模式(行为型模式)
Chain Of Responsibility 职责链模式(行为型模式) 请求的发送者与接受者 某些对象请求的接受者可能有多种多样,变化无常…… 动机(Motivation) 在软件构建过程中,一个请 ...
- Design Pattern Chain of Reponsibility 责任链模式
本程序实现一个责任链模式查询人名的资料. 開始都是查询第一个人,问其是否有某人的资料,假设有就返回结果,假设没有第一个人就会询问第二个人,第二个人的行为和第一个人的行为一致的,然后一致传递下去,直到找 ...
- 设计模式学习笔记——Chain of Responsibility职责链模式
重点在链.一条链,如果本节点处理不了,则传递给下一个节点处理. 关键是如何传给下一个节点? 主要是由本节点决定传给哪一个节点. public class Client { public static ...
随机推荐
- Mermaid 学习
基础 在 VS code 中安装插件 Markdown Preview Mermaid Support,则便可支持 Mermaid 流程图 flowchart graph LR; A-->B; ...
- 三种显著性检测算法(SR,HFT,GBMR)
一.谱残差(Spectral Residual, SR) 一种简单的图像显著性计算模型 http://www.cnblogs.com/CCBB/archive/2011/05/19/2051442. ...
- Spring 单例 httprequest 线程安全
@Autowired HttpServletRequest之所以线程安全是因为, httpsevletRequest 储存在 RequestContextHolder中. 每次http请求的doXXX ...
- mysql索引之三:索引使用注意规则(索引失效--存在索引但不使用索引)*
使用索引时,有以下一些技巧和注意事项: (1)越小的数据类型通常更好:越小的数据类型通常在磁盘.内存和CPU缓存中都需要更少的空间,处理起来更快.(2)简单的数据类型更好:整型数据比起字符,处理开销更 ...
- 使用命令行管理virtualBox
最近在鼓捣hadoop,装了几台虚拟机,,总感觉gui启动很别扭,后来发现virtualBox有个headless模式,只想说舒服! 常用命令 VBoxManage startvm name|id - ...
- luoguP3359 改造异或树 线段树合并
删边转化为加边 然后每次用线段树合并就行..... 确确实实很简单 然而为什么线段树合并跑不过$splay$的启发式合并,常数稍大了点... 复杂度$O(n \log n)$ #include < ...
- bzoj 1069
最开始想到的是枚举3个点,另一个点用卡壳的思想,但实际上可以只枚举两个点(对角线上的两个点),其余两个点用卡壳. /****************************************** ...
- CDOJ 1401 谭爷的黑暗沙拉 数学
谭爷的黑暗沙拉 题目连接: http://mozhu.today/#/problem/show/1401 Description 谭爷有\(n\)种不同种类的食材(水果&蔬菜),他想做出一份总 ...
- Codeforces Round #297 (Div. 2)A. Vitaliy and Pie 水题
Codeforces Round #297 (Div. 2)A. Vitaliy and Pie Time Limit: 2 Sec Memory Limit: 256 MBSubmit: xxx ...
- hdu 刷题记录
1007 最近点对问题,采用分治法策略搞定 #include<iostream> #include<cmath> #include<algorithm> using ...