这篇博客我们来介绍一下责任链模式（Chain-of-responsibility Pattern），责任联模式又称为职责链模式，是行为型设计模式之一。顾名思义，责任链模式中存在一个链式结构，多个节点首尾相连，每个节点都可以被拆开再连接，因此，链式结构具有很好的灵活性。将这样一种结构应用于编程领域，将每一个节点看作是一个对象，每一个对象拥有不同的处理逻辑，将一个请求从链式的首段发出，沿着链的路径依次传递给每一个节点对象，直至有对象处理这个请求为止，这就是责任链或者职责链的通俗定义。
转载请注明出处：http://blog.csdn.net/self_study/article/details/52012370。
PS：对技术感兴趣的同鞋加群544645972一起交流。
设计模式总目录
特点
使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系，将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。
责任链模式的使用场景：
- 多个对象可以处理统一请求，但具体由哪个对象处理则在运行时动态决定；
- 在请求处理者不明确的情况下向多个对象中的一个提交一个请求；
- 需要动态指定一组对象处理请求。
UML类图
责任链模式的 uml 图如下所示：
责任链模式有两大角色：
- Handler：抽象处理者角色，声明一个请求处理的方法，并在其中保持对下一个处理节点 Hanlder 对象的引用；
- ConcreteHandler：
- 具体处理者角色，对请求进行处理，如果不能处理则将该请求转发给下一个节点上的处理对象。
AbstractHandler.class
public abstract class AbstractHandler {
protected AbstractHandler nextHandler;
public final void handleRequest(AbstractRequest request) {
if (getHandlerLevel() == request.getLevel()) {
handle(request);
} else {
if (nextHandler != null) {
nextHandler.handleRequest(request);
} else {
System.out.print("there is no handler that can handle this request");
}
}
}
protected abstract int getHandlerLevel();
protected abstract void handle(AbstractRequest request);
}ConcreteHandler1.class
public class ConcreteHandler1 extends AbstractHandler{
@Override
protected int getHandlerLevel() {
return 1;
}
@Override
protected void handle(AbstractRequest request) {
System.out.print("ConcreteHandler1 handle this request : " + request.getContent() + "\n");
}
}ConcreteHandler2.class
public class ConcreteHandler2 extends AbstractHandler{
@Override
protected int getHandlerLevel() {
return 2;
}
@Override
protected void handle(AbstractRequest request) {
System.out.print("ConcreteHandler2 handle this request : " + request.getContent() + "\n");
}
}然后是请求角色：
AbstractRequest.class
public abstract class AbstractRequest {
private Object object;
public AbstractRequest(Object object) {
this.object = object;
}
public Object getContent() {
return object;
}
public abstract int getLevel();
}ConcreteRequest1.class
public class ConcreteRequest1 extends AbstractRequest{
public ConcreteRequest1(Object object) {
super(object);
}
@Override
public int getLevel() {
return 1;
}
}ConcreteRequest2.class
public class ConcreteRequest2 extends AbstractRequest{
public ConcreteRequest2(Object object) {
super(object);
}
@Override
public int getLevel() {
return 2;
}
}最后客户端测试代码：
public class Client {
public static void main(String[] args) {
AbstractHandler handler1 = new ConcreteHandler1();
AbstractHandler handler2 = new ConcreteHandler2();
handler1.nextHandler = handler2;
AbstractRequest request1 = new ConcreteRequest1("request1");
AbstractRequest request2 = new ConcreteRequest2("request2");
handler1.handleRequest(request1);
handler1.handleRequest(request2);
}
}结果如下：
示例与源码
其实责任链模式在实际项目过程中遇到的非常多，Android 和 Java 源码也一样，举几个简单的例子：
- ViewGroup 和 View 中 touch 事件的分发，子 View 的 onTouchEvent 返回 true 代码消费该事件并不再传递，false 代表不消费并且传递到父 ViewGroup 去处理，这些树形结构的子 View 就是责任链上一个个处理对象；
- OrderedBroadcast，广播的每一个接收者按照优先级依次接受消息，如果处理完成之后可以调用 abortBroadcast 终止广播，不是自己处理的就可以传递给下一个处理者；
- try-catch语句，每一个 catch 根据 Exception 类型进行匹配，形成一个责任链，如果有一个 catch 语句与该 Exception 符合，这个 Exception 就交由给它进行处理，之后所有 catch 语句都不会再次执行。
我们这就以 wiki 上的代码为例：每个人都有一个支出审批的额度，超过审批额度之后将会传递给下一个审批人，直到最后：
审批人相关类
public abstract class PurchasePower {
protected static final double BASE = 500;
protected PurchasePower successor;
abstract protected double getAllowable();
abstract protected String getRole();
public void setSuccessor(PurchasePower successor) {
this.successor = successor;
}
public void processRequest(PurchaseRequest request){
if (request.getAmount() < this.getAllowable()) {
System.out.println(this.getRole() + " will approve $" + request.getAmount());
} else if (successor != null) {
successor.processRequest(request);
}
}
}public class ManagerPPower extends PurchasePower {
protected int getAllowable(){
return BASE*10;
}
protected String getRole(){
return "Manager";
}
}
public class DirectorPPower extends PurchasePower {
protected int getAllowable(){
return BASE*20;
}
protected String getRole(){
return "Director";
}
}
public class VicePresidentPPower extends PurchasePower {
protected int getAllowable(){
return BASE*40;
}
protected String getRole(){
return "Vice President";
}
}
public class PresidentPPower extends PurchasePower {
protected int getAllowable(){
return BASE*60;
}
protected String getRole(){
return "President";
}
}审批类
public class PurchaseRequest {
private double amount;
private String purpose;
public PurchaseRequest(double amount, String purpose) {
this.amount = amount;
this.purpose = purpose;
}
public double getAmount() {
return amount;
}
public void setAmount(double amt) {
amount = amt;
}
public String getPurpose() {
return purpose;
}
public void setPurpose(String reason) {
purpose = reason;
}
}最后是客户端的测试代码：
public class CheckAuthority {
public static void main(String[] args) {
ManagerPPower manager = new ManagerPPower();
DirectorPPower director = new DirectorPPower();
VicePresidentPPower vp = new VicePresidentPPower();
PresidentPPower president = new PresidentPPower();
manager.setSuccessor(director);
director.setSuccessor(vp);
vp.setSuccessor(president);
// Press Ctrl+C to end.
try {
while (true) {
System.out.println("Enter the amount to check who should approve your expenditure.");
System.out.print(">");
double d = Double.parseDouble(new BufferedReader(new InputStreamReader(System.in)).readLine());
manager.processRequest(new PurchaseRequest(d, "General"));
}
} catch(Exception e) {
System.exit(1);
}
}
}代码简洁明了，都应该能看懂。
总结
责任链模式的优点显而易见，可以对请求者和处理者关系解耦，提高代码的灵活性，通过改变链内的成员或调动他们的次序，允许你动态地新增或者删除职责；但是责任链模式最大的缺点在于对链中请求处理者的遍历，如果处理者太多那么必定会影响性能，特别是在一些递归调用中，而且不容易观察运行时的特征，有碍于除错。
很多资料中会介绍纯和不纯的责任链模式，在标准的责任链模式中，责任链上的一个节点只允许有两个行为：处理或者推给下个节点处理，而不允许处理完之后又推给下个节点，前者被很多资料称为纯的责任链模式，而后者被称为不纯的责任链模式。其实在实际的系统里，纯的责任链很难找到。如果坚持责任链不纯便不是责任链模式，那么责任链模式便不会有太大意义了。
源码下载
https://github.com/zhaozepeng/Design-Patterns/tree/master/ChainOfResponsibilityPattern
引用
https://en.wikipedia.org/wiki/Chain-of-responsibility_pattern
http://blog.csdn.net/jason0539/article/details/45091639
扫一扫
228
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
