接下来我们将要谈谈责任链模式,有多个对象,每个对象持有对下一个对象的引用,这样就会形成一条链,请求在这条链上传递,直到某一对象决定处理该请求。但是发出者并不清楚到底最终那个对象会处理该请求,所以,责任链模式可以实现,在隐瞒客户端的情况下,对系统进行动态的调整。先看看关系图:
Abstracthandler类提供了get和set方法,方便MyHandle类设置和修改引用对象,MyHandle类是核心,实例化后生成一系列相互持有的对象,构成一条链。
- public interface Handler {
- public void operator();
- }
- public abstract class AbstractHandler {
- private Handler handler;
- public Handler getHandler() {
- return handler;
- }
- public void setHandler(Handler handler) {
- this.handler = handler;
- }
- }
- public class MyHandler extends AbstractHandler implements Handler {
- private String name;
- public MyHandler(String name) {
- this.name = name;
- }
- @Override
- public void operator() {
- System.out.println(name+"deal!");
- if(getHandler()!=null){
- getHandler().operator();
- }
- }
- }
- public class Test {
- public static void main(String[] args) {
- MyHandler h1 = new MyHandler("h1");
- MyHandler h2 = new MyHandler("h2");
- MyHandler h3 = new MyHandler("h3");
- h1.setHandler(h2);
- h2.setHandler(h3);
- h1.operator();
- }
- }
输出:
h1deal!
h2deal!
h3deal!
此处强调一点就是,链接上的请求可以是一条链,可以是一个树,还可以是一个环,模式本身不约束这个,需要我们自己去实现,同时,在一个时刻,命令只允许由一个对象传给另一个对象,而不允许传给多个对象。
====================================================================
下面是另外一个例子:
public class Test { public static void main(String[] args) { String pass1 = "123456"; String pass2 = "123456"; String personId = "123456227890125678"; String email = "chmask@163.com"; register(pass1, pass2, personId, email); } public static void register(String pass1, String pass2, String personId, String email) { Filter f1 = new PasswordFilter1(); Filter f2 = new PasswordFilter2(); Filter f3 = new PersonIdFilter(); Filter f4 = new EmailFilter(); f1.setNext(f2); f2.setNext(f3); f3.setNext(f4); System.out.println(f1.doFilter(pass1, pass2, personId, email)); } } abstract class Filter { Filter next = null; public Filter getNext() { return next; } public void setNext(Filter next) { this.next = next; } public String doFilter(String pass1, String pass2, String personId, String email) { if (next == null) return "成功"; else return next.doFilter(pass1, pass2, personId, email); } } class PasswordFilter1 extends Filter { public String doFilter(String pass1, String pass2, String personId, String email) { if (!(pass1.equals(pass2))) return "两次密码输入不一致"; else return super.doFilter(pass1, pass2, personId, email); } } class PasswordFilter2 extends Filter { public String doFilter(String pass1, String pass2, String personId, String email) { if (pass1.length() != 6) return "密码长度必须为6"; else return super.doFilter(pass1, pass2, personId, email); } } class PersonIdFilter extends Filter { public String doFilter(String pass1, String pass2, String personId, String email) { if (personId.length() != 15 && personId.length() != 18) return "身份证号码非法"; else return super.doFilter(pass1, pass2, personId, email); } } class EmailFilter extends Filter { public String doFilter(String pass1, String pass2, String personId, String email) { int i1 = email.indexOf("@"); int i2 = email.indexOf("."); if (i1 == -1 || i2 == -1 || i2 - i1 <= 1 || i1 == 0 || i2 == email.length() - 1) return "email非法"; else return super.doFilter(pass1, pass2, personId, email); } }
下面使用了一个责任链模式的最简单的实现。
责任链模式涉及到的角色如下所示:
● 抽象处理者(Handler)角色:定义出一个处理请求的接口。如果需要,接口可以定义 出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。上图中Handler类的聚合关系给出了具体子类对下家的引用,抽象方法handleRequest()规范了子类处理请求的操作。
● 具体处理者(ConcreteHandler)角色:具体处理者接到请求后,可以选择将请求处理掉,或者将请求传给下家。由于具体处理者持有对下家的引用,因此,如果需要,具体处理者可以访问下家。
源代码
抽象处理者角色
public abstract class Handler { /** * 持有后继的责任对象 */ protected Handler successor; /** * 示意处理请求的方法,虽然这个示意方法是没有传入参数的 * 但实际是可以传入参数的,根据具体需要来选择是否传递参数 */ public abstract void handleRequest(); /** * 取值方法 */ public Handler getSuccessor() { return successor; } /** * 赋值方法,设置后继的责任对象 */ public void setSuccessor(Handler successor) { this.successor = successor; } }
具体处理者角色
public class ConcreteHandler extends Handler { /** * 处理方法,调用此方法处理请求 */ @Override public void handleRequest() { /** * 判断是否有后继的责任对象 * 如果有,就转发请求给后继的责任对象 * 如果没有,则处理请求 */ if(getSuccessor() != null) { System.out.println("放过请求"); getSuccessor().handleRequest(); }else { System.out.println("处理请求"); } } }
客户端类
public class Client { public static void main(String[] args) { //组装责任链 Handler handler1 = new ConcreteHandler(); Handler handler2 = new ConcreteHandler(); handler1.setSuccessor(handler2); //提交请求 handler1.handleRequest(); } }
地组合职责链,实现不同的功能要求了。
public abstract class Handler { /** * 持有下一个处理请求的对象 */ protected Handler successor = null; /** * 取值方法 */ public Handler getSuccessor() { return successor; } /** * 设置下一个处理请求的对象 */ public void setSuccessor(Handler successor) { this.successor = successor; } /** * 处理聚餐费用的申请 * @param user 申请人 * @param fee 申请的钱数 * @return 成功或失败的具体通知 */ public abstract String handleFeeRequest(String user , double fee); } public class ProjectManager extends Handler { @Override public String handleFeeRequest(String user, double fee) { String str = ""; //项目经理权限比较小,只能在500以内 if(fee < 500) { //为了测试,简单点,只同意张三的请求 if("张三".equals(user)) { str = "成功:项目经理同意【" + user + "】的聚餐费用,金额为" + fee + "元"; }else { //其他人一律不同意 str = "失败:项目经理不同意【" + user + "】的聚餐费用,金额为" + fee + "元"; } }else { //超过500,继续传递给级别更高的人处理 if(getSuccessor() != null) { return getSuccessor().handleFeeRequest(user, fee); } } return str; } } public class DeptManager extends Handler { @Override public String handleFeeRequest(String user, double fee) { String str = ""; //部门经理的权限只能在1000以内 if(fee < 1000) { //为了测试,简单点,只同意张三的请求 if("张三".equals(user)) { str = "成功:部门经理同意【" + user + "】的聚餐费用,金额为" + fee + "元"; }else { //其他人一律不同意 str = "失败:部门经理不同意【" + user + "】的聚餐费用,金额为" + fee + "元"; } }else { //超过1000,继续传递给级别更高的人处理 if(getSuccessor() != null) { return getSuccessor().handleFeeRequest(user, fee); } } return str; } } public class GeneralManager extends Handler { @Override public String handleFeeRequest(String user, double fee) { String str = ""; //总经理的权限很大,只要请求到了这里,他都可以处理 if(fee >= 1000) { //为了测试,简单点,只同意张三的请求 if("张三".equals(user)) { str = "成功:总经理同意【" + user + "】的聚餐费用,金额为" + fee + "元"; }else { //其他人一律不同意 str = "失败:总经理不同意【" + user + "】的聚餐费用,金额为" + fee + "元"; } }else { //如果还有后继的处理对象,继续传递 if(getSuccessor() != null) { return getSuccessor().handleFeeRequest(user, fee); } } return str; } } public class Client { public static void main(String[] args) { //先要组装责任链 Handler h1 = new GeneralManager(); Handler h2 = new DeptManager(); Handler h3 = new ProjectManager(); h3.setSuccessor(h2); h2.setSuccessor(h1); //开始测试 String test1 = h3.handleFeeRequest("张三", 300); System.out.println("test1 = " + test1); String test2 = h3.handleFeeRequest("李四", 300); System.out.println("test2 = " + test2); System.out.println("---------------------------------------"); String test3 = h3.handleFeeRequest("张三", 700); System.out.println("test3 = " + test3); String test4 = h3.handleFeeRequest("李四", 700); System.out.println("test4 = " + test4); System.out.println("---------------------------------------"); String test5 = h3.handleFeeRequest("张三", 1500); System.out.println("test5 = " + test5); String test6 = h3.handleFeeRequest("李四", 1500); System.out.println("test6 = " + test6); } }
运行结果如下所示:
相关推荐
在这个`chain-of-responsibility-demo`中,我们可以预期找到一个实际应用了责任链模式的代码示例。通常,它会包含以下关键组件: 1. **Handler**(处理器):这是责任链中的基本单元,每个处理器都实现了处理请求的...
责任链(Chain of Responsibility)模式的定义:为了避免请求发送者与多个请求处理者耦合在一起,于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链;当有请求发生时,可将请求沿着这条链传递...
责任链模式(Chain of Responsibility Pattern)是一种行为型设计模式,它允许将请求的发送者和接收者解耦。通过将请求沿着处理链传递,直到有对象处理该请求为止,这种模式避免了请求发送者与具体处理者之间的紧...
C#面向对象设计模式 (行为型模式) Chain Of Responsibility 职责链模式 视频讲座下载
Chain of Responsibility模式是GOF(GoF,Gang of Four)在他们的经典著作《设计模式:可复用面向对象软件的基础》中提出的23种设计模式之一,属于行为模式类别。这个模式的主要目的是允许在对象之间传递请求,同时...
责任链模式(Chain of Responsibility)是一种行为设计模式,它允许将请求沿着处理者对象的链进行传递,直到某个对象能够处理这个请求。这种模式的主要优点是解耦了发送者和接收者之间的关系,使得系统更加灵活,...
职责链模式(Chain of Responsibility)是一种行为型设计模式,它允许将请求沿着处理者对象的链进行传递,直到某个对象能够处理这个请求。在C#中,职责链模式的应用可以帮助我们构建灵活、可扩展的系统,减少对象...
在 Java 开发中,责任链模式是一种重要的行为设计模式,它可以解耦请求的发送者和接收者,使多个对象都有机会处理请求。本文将详细介绍责任链模式的意图、解释、编程示例、适用场景、实际应用、优点和权衡。同时,还...
责任链(Chain of Responsibility)模式是一种行为设计模式,它允许我们向对象链中传递请求,让每个对象决定是否处理这个请求。在Java中,这种模式常用于事件处理、日志系统或者权限控制等场景,其核心思想是将处理...
### C#面向对象设计模式纵横谈(14):Chain of Responsibility 职责链模式(行为型模式) #### 概述 在本篇文章中,我们将深入探讨C#中的Chain of Responsibility(职责链)模式,这是行为型设计模式的一种。虽然标题...
**Java设计模式——责任链(Chain of Responsibility)** 在软件工程中,设计模式是一种解决常见问题的可重用解决方案。责任链模式是行为设计模式之一,它的主要思想是将请求的发送者和接收者解耦,通过将多个处理...
职责链模式(Chain of Responsibility)是一种行为型设计模式,它允许你将请求沿着处理者对象的链进行传递,直到某个对象处理该请求。在C#编程中,职责链模式能够帮助我们实现一种松耦合的架构,使得请求的发送者和...
职责链模式(Chain of Responsibility Pattern)是一种行为设计模式,它允许将请求的发送者和接收者解耦,使得多个对象都有可能处理一个请求,而无需显式指定接收者。在这个模式中,请求沿着一个处理者链进行传递,...
Chain of Responsibility(责任链)模式是一种行为设计模式,它允许将请求沿着处理者对象的链进行发送,每个对象都可以处理请求或将其传递给链中的下一个对象。这种模式常用于事件处理或者命令的执行流程,使得多个...
本篇将探讨两种重要的行为设计模式:责任链模式(Chain of Responsibility Pattern)和状态模式(State Pattern)。 **责任链模式**是一种使多个对象都有机会处理请求的模式,避免请求发送者与接收者之间的耦合。在...
责任链模式(Chain of Responsibility Pattern)是一种常见的行为模式。 使多个对象都有处理请求的机会,从而避免了请求的发送者和接收者之间的耦合关系。将这些对象串成一条链,并沿着这条链一直传递该请求,直到有...
责任链模式(Chain of Responsibility Pattern)是一种行为设计模式,它使你能在不明确指定接收者的情况下,将请求沿着处理者对象的链式结构进行传递。每个处理者对象都包含对下一个处理者的引用,如果某个处理者...
责任链模式(Chain of Responsibility Pattern)是一种行为设计模式,它允许将请求沿着处理链进行传递,直到有一个处理程序处理它为止。在 Java 中实现责任链模式通常需要以下几个步骤: 定义处理器接口 首先,...
责任链模式(Chain of Responsibility)是一种行为设计模式,它允许我们向多个对象中的一个发送请求,而无需指定接收者是谁。这种模式的核心思想是将处理请求的对象形成一条链,请求在链上的对象间传递,直到被某个...