责任链模式

简介

责任链模式是一种对象的行为模式。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链，请求在这个链上【传递】，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。

责任链模式屏蔽了请求的处理过程，你发起一个请求到底是谁处理的，这个你不用关心，只要你把请求抛给责任链的第一个处理者，最终会返回一个处理结果（当然也可以不做任何处理），作为请求者可以不用知道到底是需要谁来处理的，这是责任链模式的核心。

责任链就是从一个起点发起请求，然后沿着任务链依次传递给每一个节点上的对象，直到有一个节点处理这个请求为止。

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

现实中最适合责任链的应该就是部门领导之间的上报请求了。比如员工要申请一笔资金，会先向组长申请，额度如果在组长的范围内，组长就批了，组长权限不够就向主管申请，主管如果也额度不够就向经理申请。这就形成了个责任链。

组长，主管，经理。每个人都是责任链上的一个节点。一个请求被层层转达，直到被处理或没有一个人能处理。普通员工，就是那个申请的发起者，并不需要知道到底最后是谁审批的，他只要拿到钱就行了。这样就造成了请求者和处理者的解耦。

责任链有一个缺点是，大家在开发的时候要注意，调试不是很方便，特别是链条比较长，环节比较多的时候，由于采用了类似递归的方式，调试的时候逻辑可能比较复杂。

适用性

有多个对象可以处理一个请求，具体哪个对象处理该请求在运行时刻自动确定。
在请求的处理者不明确的情况下，向多个对象的一个提交请求。
需要动态指定一组对象处理请求。

角色

Handler：抽象处理者角色，声明一个处理请求的方法，并保持对下一个处理节点Handler对象的引用。
ConcreteHandler: 具体的处理者，对请求进行处理，如果不处理就讲请求转发给下一个节点上的处理对象。

作用：请求会被链上的对象处理，但是客户端不知道请求会被哪些对象处理
通过把请求从一个对象传递到链条中下一个对象的方式，直到请求被处理完毕，以实现对象间的解耦。

JDK中体现：ClassLoader的委托模型

简单版案例

抽象处理者：

1 public abstract class Handler {
2    protected Handler successor;
3    public abstract void handleRequest(String condition);
4 }

实际处理者1

public class ConcreteHandler1 extends Handler {@Overridepublic void handleRequest(String condition) {if ("ConcreteHandler1".equals(condition)){System.out.println("ConcreteHandler1 handled");}else {successor.handleRequest(condition);}}
}

实际处理者2

public class ConcreteHandler2 extends Handler {@Overridepublic 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 {@Overrideprotected int getHandleLevel() {return 1;}
@Overrideprotected void handle(AbstractRequest request) {System.out.println("Handler1处理了请求："+request.getRequestLevel());}
}public class Handler2 extends AbstractHandler {@Overrideprotected int getHandleLevel() {return 2;}
@Overrideprotected void handle(AbstractRequest request) {System.out.println("Handler2处理了请求："+request.getRequestLevel());}
}public class Handler3 extends AbstractHandler {@Overrideprotected int getHandleLevel() {return 3;}
@Overrideprotected 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);}
@Overridepublic int getRequestLevel() {return 1;}
}
public class Request2 extends AbstractRequest {public Request2(Object obj) {super(obj);}
@Overridepublic int getRequestLevel() {return 2;}
}
public class Request3 extends AbstractRequest {public Request3(Object obj) {super(obj);}
@Overridepublic 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 {@Overridepublic int getLimit() {return 5000;}
@Overridepublic void handle(int money) {System.out.println(money + "由组长批准");}
}public class Director extends Leader {@Overridepublic int getLimit() {return 10000;}
@Overridepublic void handle(int money) {System.out.println(money + "由主管批准");}
}public class Manager extends Leader {@Overridepublic int getLimit() {return 20000;}
@Overridepublic 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

转载于:https://www.cnblogs.com/baiqiantao/p/5417291.html

Chain of Responsibility 责任链模式 MD相关推荐

设计模式之略见一斑(Chain of Responsibility责任链模式)
设计模式写道面向对象开发人员通常希望明确和减少对象间的责任,从而降低对象之间的耦合程序.这样我们的系统更加容易修改,同时也可降低产生缺陷的风险.从某种程度上说,java语言本身能够帮助降低对象间的 ...
Chain of Responsibility -- 责任链模式
在软件构建构成中,一个请求可能被多个对象处理,但是每个请求在运行时只能有一个接收者,如果显示指定,将必不可少地带来请求发送者与接收者的紧密耦合.COR(Chain of Reposibility)设计 ...
设计模式（一）Chain Of Responsibility责任链模式
设计模式篇章,源于网课的学习,以及个人的整理在我们接收用户提交的字符时,常常会使用到过滤,在学习责任链模式前,我们是这样做的 1.定义一个类 public class MsgProcesser {S ...
Chain of Responsibility(责任链模式）行为型
责任链模式一.概述二.结构三.适用场景四.优缺点五.实例一.概述描述:如组长不能处理的金额,需要向经理请求,经理不能请求的需要向老板请求,这样就现成了一条链,每个级别都能处理这金额.而不 ...
22.Chain of Responsibility(职责链)模式
技术交流QQ群:1027579432,欢迎你的加入! 1.Chain of Responsibility(职责链)模式动机在软件构建过程中,一个请求可能被多个对象处理,但是每个请求在运行时只能有一个 ...
步步为营 .NET 设计模式学习笔记十九、Chain of Responsibility(职责链模式)
概述在软件构建过程中,一个请求可能被多个对象处理,但是每个请求在运行时只能有一个接受者,如果显示指定,将必不可少地带来请求发送者与接受者的紧耦合. 如何使请求的发送者不需要指定具体的接受者?让请求的 ...
职责链模式 php,php Chain of Responsibility 职责链模式
//被*攻击的接口 interface NuclearAttacked { //处理被*攻击的方法,参数为投放点的x和y坐标 public function NuclearAttacked($x, $ ...
乐在其中设计模式(C#) - 责任链模式(Chain of Responsibility Pattern)
原文:乐在其中设计模式(C#) - 责任链模式(Chain of Responsibility Pattern) [索引页] [源码下载] 乐在其中设计模式(C#) - 责任链模式(Chain of ...
设计模式：责任链模式（Chain of Responsibility）
欢迎支持笔者新作:<深入理解Kafka:核心设计与实践原理>和<RabbitMQ实战指南>,同时欢迎关注笔者的微信公众号:朱小厮的博客. 欢迎跳转到本文的原文链接:https: ...

Chain of Responsibility 责任链模式 MD

责任链模式

简介

简单版案例

复杂版案例

实际案例

Chain of Responsibility 责任链模式 MD相关推荐

最新文章

热门文章