被说了很多遍的设计模式---职责链模式

最新推荐文章于 2019-08-19 12:28:00 发布
最新推荐文章于 2019-08-19 12:28:00 发布
阅读量681 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 设计模式 职责链模式 教程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ABCD898989/article/details/64128600
版权

[把你的理性思维慢慢变成条件反射]

本文，我们讲介绍职责链模式，文章主题结构与上文一致。惯例，先来看看我们示例工程的环境：

操作系统：win7 x64

其他软件：eclipse mars，jdk8

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

经典问题：

审批流，权利及方法继承关系处理。

思路分析：

要点一：每一级具有明确的界限的，责任唯一的“权限”。

要点二：责任处理在运行时动态确定。

示例工程：


错误写法：


创建Manager.java文件，具体内容如下：

package com.csdn.ingo.gof_ChainOfResponsibility;

public class Manager {
	protected String name;

	public Manager(String name) {
		this.name = name;
	}

	public void getResult(String managerLevel, Request request) {
		if (managerLevel == "经理") {
			if (request.prequestType == "交通费报销单" && request.pnumber <= 2) {
				System.out.println("批准：" + name + ",报销金额:" + request.prequestContent);
			} else {
				System.out.println("无权处理");
			}
		} else if (managerLevel == "总监") {
			if (request.prequestType == "交通费报销单" && request.pnumber < 5) {
				System.out.println("批准：" + name + ",报销金额:" + request.prequestContent);
			} else {
				System.out.println("无权处理");
			}
		} else if (managerLevel == "总经理") {
			if (request.prequestType == "交通费报销单" && request.pnumber < 50) {
				System.out.println("批准：" + name + ",报销金额:" + request.prequestContent);
			} else if (request.prequestType == "交通费报销单" && request.pnumber > 50) {
				System.out.println("超出预算，重新申请");
			}
		}
	}
}
创建Request.java文件，具体内容如下： 

package com.csdn.ingo.gof_ChainOfResponsibility;

public class Request {
	private String requestType;
	public String prequestType;
	
	private String requestContent;
	public String prequestContent;
	
	private int number;
	public int pnumber;
	
	public String getRequestType() {
		return requestType;
	}
	public void setRequestType(String requestType) {
		this.requestType = requestType;
	}
	public String getRequestContent() {
		return requestContent;
	}
	public void setRequestContent(String requestContent) {
		this.requestContent = requestContent;
	}
	public int getNumber() {
		return number;
	}
	public void setNumber(int number) {
		this.number = number;
	}
}
创建Window.java文件，具体内容如下： 

package com.csdn.ingo.gof_ChainOfResponsibility;

public class Window {
	public static void main(String[] args) {
		Manager jingli = new Manager("经理");
		Manager zongjian = new Manager("总监");
		Manager zongjingli = new Manager("总经理");
		
		Request request = new Request();
		request.prequestType = "交通费报销单";
		request.prequestContent="交通费报销单5K元";
		request.pnumber = 5;
		
		jingli.getResult("经理", request);
		zongjian.getResult("总监", request);
		zongjingli.getResult("总经理", request);
	}
}

错误原因：

Manager类其违背了单一职责原则，违反了开闭原则，包含过多分支判断，不利于后期扩展。

推荐写法：


创建CommonManager.java文件，具体内容如下：

package com.csdn.ingo.gof_ChainOfResponsibility.two;

public class CommonManager extends Manager{

	public CommonManager(String name) {
		super(name);
	}

	@Override
	public void requestApplications(Request request) {
		if(request.prequestType=="交通费报销单"&&request.pnumber<=2){
			System.out.println("批准："+name+","+request.pnumber);
		}else if(superior!=null){
			superior.requestApplications(request);
		}
	}
}

创建GeneralManager.java文件，具体内容如下：

package com.csdn.ingo.gof_ChainOfResponsibility.two;

public class GeneralManager extends Manager {

	public GeneralManager(String name) {
		super(name);
	}

	@Override
	public void requestApplications(Request request) {
		if (request.prequestType == "交通费报销单" && request.pnumber < 50) {
			System.out.println("批准：" + name + ",报销金额:" + request.prequestContent);
		} else if (request.prequestType == "交通费报销单" && request.pnumber > 50) {
			System.out.println("超出预算，重新申请");
		} else if (superior != null) {
			superior.requestApplications(request);
		}
	}
}
创建MajorManager.java文件，具体内容如下： 

package com.csdn.ingo.gof_ChainOfResponsibility.two;

public class MajorManager extends Manager{

	public MajorManager(String name) {
		super(name);
	}

	@Override
	public void requestApplications(Request request) {
		if(request.prequestType=="交通费报销单"&&request.pnumber<=5){
			System.out.println("批准："+name+","+request.pnumber);
		}else if(superior!=null){
			superior.requestApplications(request);
		}
	}
}
创建Manager.java文件，具体内容如下： 

package com.csdn.ingo.gof_ChainOfResponsibility.two;

public abstract class Manager {
	protected String name;
	protected Manager superior;
	
	public Manager(String name){
		this.name = name;
	}
	public void setSuperior(Manager superior){
		this.superior = superior;
	}
	public abstract void requestApplications(Request request);
}
创建Request.java文件，具体内容参考上文。

创建Window.java文件，具体内容如下：

package com.csdn.ingo.gof_ChainOfResponsibility.two;

public class Window {
	public static void main(String[] args) {
		Manager jingli = new CommonManager("经理");
		Manager zongjian = new MajorManager("总监");
		Manager zongjingli = new GeneralManager("总经理");
		jingli.setSuperior(zongjian);
		zongjian.setSuperior(zongjingli);
		
		Request request = new Request();
		request.prequestType = "交通费报销单";
		request.prequestContent="交通费报销单5K元";
		request.pnumber = 5;
		jingli.requestApplications(request);
	}
}
推荐原因：

  • 每一级对象职责明确，能够在运行时动态决定处理请求的等级。
  • 类间关系的设计也有利于后期的维护与扩展。

模式总结：

职责链模式结构图：



职责链模式：使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求你，知道有一个对象处理它为止。

组成部分：

Handler（抽象处理类）：定义了一个处理请求的接口，一般设计为抽象类。对于其继承类而言，其仍然是一个处理器，因此在抽象类中需要定义一个抽象处理类型的对象（图中的successor），作为对下一级的引用。通过该引用，可以将各个继承类连接为一个责任链结构。

ConcreteHandler（具体处理者类）：定义为Handler抽象类的子类，用于实际处理请求。其中需要明确判断当前对象是否拥有处理该请求的权限。

模板代码：


创建ConcreteHandler1.java，ConcreteHandler2.java，ConcreteHandler3.java文件，具体内容如下：（注意区分每一级的if条件变化）

package com.csdn.ingo.gof_ChainOfResponsibility.one;

public class ConcreteHandler1 extends Handler {

	@Override
	public void HandleRequest(int request) {
		if(request>=0&&request<10){
			System.out.println(this.getClass().getName()+"处理请求："+request);
		}else if(successor!=null){
			successor.HandleRequest(request);
		}
	}
}
创建Handler.java文件，具体内容如下： 

package com.csdn.ingo.gof_ChainOfResponsibility.one;

public abstract class Handler {
	protected Handler successor;
	public void setSuccesor(Handler successor){
		this.successor = successor;
	}
	public abstract void HandleRequest(int request);
}
创建Window.java文件，具体内容如下： 

package com.csdn.ingo.gof_ChainOfResponsibility.one;

public class Window {
	public static void main(String[] args) {
		Handler h1 = new ConcreteHandler1();
		Handler h2 = new ConcreteHandler2();
		Handler h3 = new ConcreteHandler3();
		
		h1.setSuccesor(h2);
		h2.setSuccesor(h3);
		int requests[] ={2,3,13,32,3,21}; 
		for(int i:requests){
			h1.HandleRequest(i);
		}
	}
}

模式扩展：

“不纯洁”的职责链模式：

在上文所示的概念及示例代码中，我们展示的都是：明确的区别了每一级的职责。即，要么全部处理，要么全部交给下一级处理。

但是，实际上，我们还会遇到需要分级处理的情况，如网络协议的处理过程，每一级都是基于上一级的处理结果，计算当前值，并且将计算结果交给下一级继续处理。这样的处理过程在过滤器中也较为常用。

反思：

应用场景：

  1. 有多个对象可以处理一个请求，但具体交由谁处理，只有在运行时才能确定。
  2. 客户端不关心那个对象最终处理了该对象。但需要一个明确的处理或未出的结果。
  3. 客户端可以任意的指定处理对象层级关系，多个客户端有可能存在不同的处理层级安排。

优点：

  1. 客户端负责创建一个责任链，但丝毫不关心责任链的处理过程。只是期待最终的返回结果。
  2. 每一个对象只建立的向后的连接关系，简化的对象之间的关系设置。
  3. 在一组处理类中，可以存在不同的处理链。
  4. 对于后续新增，修改不必修改服务端，客户端只需重新建立责任链即可，满足了单一职责原则，开闭原则。

缺点：

  1. 一个请求极有可能到了链的末端仍然得不到处理，并且，客户端在最初也不知道当前请求是否一定被处理。
  2. 责任链的长度会对性能产生一定影响。对于测试与调试存在一定障碍。
  3. 需要主要避免死循环。

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

至此，被说了很多遍的设计模式---职责链模式 结束


参考资料：

图书：《大话设计模式》

其他博文：http://blog.csdn.NET/lovelion/article/details/7563445


y-yg
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计呼叫中心的类
雪儿的专栏
08-26 1091
public class CallHandler{ private static CallHandler instance; /* 三个员工层级：接线员，主管，经理 */ private final int LEVELS=3; /* 起始设定10位接线员，4位主管和2位经理 */ private final int NUM_RESPONDENTS=10; private f
Java 设计模式 -- 职责链模式
Hwaphon
05-20 3521
下面，将通过一个例子，对职责链模式进行介绍。问题：设想，你有一个呼叫中心，员工分成三个层级，接线员，主管和经理。客户来电时会先分配给接线员，若接线员处理不了，就必须将来电往上转给主管，若主管无法处理，将来电往上转给经理。请设计这个问题的类和数据结构（为了方便，将呼叫者的问题分等级，分别为 S 级，由接线员处理，SS 级，由主管处理，SSS级，由经理处理）。首先，分析一下这个问题，对于一次电话呼叫，肯
设计模式--职责链模式
IT老兵的驿站
05-14 479
参考http://blog.csdn.net/zhang_xinxiu/article/details/9963305，这篇文章写的很好。 其实，从这个角度来说，安卓的事件传递就是一个职责链，处理就返回true，就不再传递；不处理或者处理了一部分就返回false，继续传递。 Java的spring里面的AOP的概念应该也是应该也有一些这个意思了。
java设计模式---职责链模式
张勤一
07-19 1293
职责链的本质：分离职责，动态组合样例：/** * 定义职责对象的接口 * */ public abstract class Handler { protected Handler successor; /** * 设置下一个处理请求对象 * @param successor */
javascript设计模式 – 职责链模式原理与用法实例分析
11-21
本文实例讲述了javascript设计模式 – 职责链模式原理与用法。分享给大家供大家参考，具体如下： 介绍：很多情况下，在一个软件系统中可以处理某个请求的对象不止一个。例如一个网络请求过来，需要有对象去解析...
C#设计模式：责任链模式
12-22
　责任链模式是指一个处理需要涉及多个过程或者角色参与处理，并基于某个约定组成一个链，每个过程或者角色拥有各自职责进行处理。责任链模式有效组织一个过程处理，同时子过程之间职责明确。在.NET平台中很常见此...
研磨设计模式-part2
03-07
《研磨设计模式》在内容上深入、技术上实用、和实际开发结合程度很高，书中大部分的示例程序都是从实际项目中简化而来，因此很多例子都可以直接拿到实际项目中使用。如果你想要深入透彻地理解和掌握设计模式，并...
研磨设计模式-part4
03-07
《研磨设计模式》在内容上深入、技术上实用、和实际开发结合程度很高，书中大部分的示例程序都是从实际项目中简化而来，因此很多例子都可以直接拿到实际项目中使用。如果你想要深入透彻地理解和掌握设计模式，并...
研磨设计模式-part3
03-07
《研磨设计模式》在内容上深入、技术上实用、和实际开发结合程度很高，书中大部分的示例程序都是从实际项目中简化而来，因此很多例子都可以直接拿到实际项目中使用。如果你想要深入透彻地理解和掌握设计模式，并...
职责链（Chain of Responsibility）模式
weixin_30299709的博客
05-31 74
职责链（Chain of Responsibility）模式 责任链模式是一种对象的行为模式【GOF95】。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织链和分配责任。 从击鼓传花谈起 击鼓传花是一种...
c++ 设计模式23讲之职责链模式
whish1994的博客
08-19 108
职责链模式 定义： 避免请求发送者与处理者耦合，将多个处理对象连成一条链，传递请求直到有一对象处理它 优点： （1）链中对象不需知道链结构，由客户端创建链 （2）请求对象只需维护后继引用，不需维持它对所有候选者引用 （3）增加请求对象无需修改源代码，只需重新创建链 缺点： （1）一个请求没有明确的接受者，可能会未被处理 （2）较长的职责链设计多个处理对象，性能会受到一定影响 （...
设计模式-职责链模式
z444_579的博客
08-14 244
1. 职责链模式：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并且沿着这条链传递该请求，直到有一个对象处理它为止；2. 应用场景：给系统降低了耦合性，请求的发送者完全不必知道该请求会被哪个应答对象处理；3. 结构图
设计模式六大原则（1）：单一职责原则
luohai859的专栏
03-09 853
定义：不要存在多于一个导致类变更的原因。通俗的说，即一个类只负责一项职责。 问题由来：类T负责两个不同的职责：职责P1，职责P2。当由于职责P1需求发生改变而需要修改类T时，有可能会导致原本运行正常的职责P2功能发生故障。 解决方案：遵循单一职责原则。分别建立两个类T1、T2，使T1完成职责P1功能，T2完成职责P2功能。这样，当修改类T1时，不会使职责P2发生故障风险；同理，当修改T2时，也
职责链模式 Chain of Responsibility Pattern
hello
02-18 694
一、什么是职责链模式     Chain of Responsibility（CoR）模式也叫职责链模式或者职责连锁模式，是行为模式之一，该模式构造一系列分别担当不同的职责的类的对象来共同完成一个任务，这些类的对象之间像链条一样紧密相连，所以被称作职责链模式。 二、职责链模式的应用场景 例1：比如客户Client要完成一个任务，这个任务包括a,b,c,d四个部分。 首先客户Client把
设计模式C++实现二十：职责链模式
shiwazone的专栏
05-18 785
职责链模式（Chain of Responsibility）：使多个对象都有机会处理请求，从而避免请求的发送者和接受之间的耦合关系。将这个对象连城一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。 职责链模式处理中，当客户有一个请求时，请求沿着链传递直到有一个对象处理它，我们在设计的时候也必须保证每一个请求都能被处理。接受者和发送者都没有对方的明确信息，而且链中的每个对象自己也不知道自己
被说了很多遍的设计模式---备忘录模式
y-yg的博客
02-10 1442
[把你的理性思维慢慢变成条件反射] 好久不见，新年第一更，本文，我们讲介绍备忘录模式，文章主题结构与上文一致。惯例，先来看看我们示例工程的环境： 操作系统：win7 x64 其他软件：eclipse mars，jdk7 --------------------------------------------------------------------
被说了很多遍的设计模式---抽象工厂模式
y-yg的博客
11-03 1290
[把你的理性思维慢慢变成条件反射] 本文，我们讲介绍抽象工厂模式，文章主题结构与上文一致。惯例，先来看看我们示例工程的环境： 操作系统：win7 x64 其他软件：eclipse mars，jdk7 ------------------------------------------------------------------------------
用设计模式代替if-else
最新发布
05-27
当代码中的条件语句if-else过于复杂时，可以考虑使用设计模式代替if-else语句，提高代码的可读性和可维护性。以下是一些常见的设计模式，可以用来代替if-else语句： 1. 工厂模式（Factory Pattern）：通过工厂方法创建对象，而不是使用条件语句来直接创建对象。这样可以避免在代码中使用大量的if-else语句，同时也可以很方便地添加新的对象类型。 2. 状态模式（State Pattern）：将复杂的状态判断逻辑封装到不同的状态类中，避免在代码中使用大量的if-else语句。可以很方便地添加新的状态类型，也可以方便地维护和扩展状态的行为。 3. 策略模式（Strategy Pattern）：将不同的算法封装到不同的策略类中，通过选择不同的策略类来实现不同的行为。这样可以避免在代码中使用复杂的if-else语句，同时也可以很方便地添加新的算法类型。 4. 观察者模式（Observer Pattern）：将一个对象的状态变化通知给多个观察者对象，避免在代码中使用大量的if-else语句。可以很方便地添加新的观察者对象，也可以方便地维护和扩展观察者的行为。 5. 责任链模式（Chain of Responsibility Pattern）：将多个处理对象组成一个链，每个处理对象都可以处理请求，如果一个对象不能处理请求，则将请求传递给下一个处理对象。这样可以避免在代码中使用大量的if-else语句，同时也可以很方便地添加新的处理对象。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值