参考
- 《设计模式：可复用面向对象软件的基础 》5.1 Chain of responsibility 职责链 对象行为型模式
- 《Android源码设计模式解析与实战》第9章 使编程更有灵活性--责任链模式
意图
使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
适用场景
- 有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。
- 想在不明确指定接收者的情况下，像多个对象中的一个提交一个请求。
- 可处理一个请求的对象集合应被动态指定。
结构
- Handler 抽象处理角色，声明一个请求处理的方法，并在其中保持一个对下一个处理节点Handler对象的引用。
- ConcreteHandler 具体处理者角色，对请求进行处理，如果不能处理则将该请求转发给下一个节点上的处理对象。
进一步抽象
对于请求来说，其形式是固定的，就是一个字符串，而判断一个节点上的对象是否能够处理该请求的标志，则是该字符串是否与之匹配。然而在大多数情况下，责任链中的请求和对应的处理规则是不尽相同的，在这种情况下可以将请求进行抽象，使之对请求的处理规则也进行封装作为一个独立的对象。
代码实现
/**
* 抽象处理类
* @author newtrekWang
* @email wangjiaxing20160101@gmail.com
* @time 2018/8/19 0:18
*/
public abstract class AbstractHandler {
/**
* 下一节点上的处理者对象
*/
private AbstractHandler nextHandler;
/**
* 处理请求
* @param request
*/
public void handleRequest(AbstractRequest request){
if (getHandlerLevel() == request.getRequestLevel()){
handle(request);
}else {
if (nextHandler != null){
nextHandler.handleRequest(request);
}else {
System.out.println("所有对象都不能处理该请求");
}
}
}
/**
* 处理请求
* @param request 请求对象
*/
public abstract void handle(AbstractRequest request);
/**
* 每个处理者具体处理请求对象的实现
* @return 处理级别
*/
public abstract int getHandlerLevel();
/**
* 设置下一个处理者
* @param nextHandler
*/
public void setNextHandler(AbstractHandler nextHandler) {
this.nextHandler = nextHandler;
}
}
/**
* 抽象请求类
* @author newtrekWang
* @email wangjiaxing20160101@gmail.com
* @time 2018/8/19 0:20
*/
public abstract class AbstractRequest {
/**
* 要处理的内容对象
*/
private Object object;
/**
* 通过构造函数注入要处理的内容对象
* @param object 要处理的内容对象
*/
public AbstractRequest(Object object) {
this.object = object;
}
/**
* 获取要处理的内容对象
* @return 要处理的内容对象
*/
public Object getObject() {
return object;
}
/**
* 获取请求级别
* @return 请求级别
*/
public abstract int getRequestLevel();
}
**
* 具体处理者1
* @author newtrekWang
* @email wangjiaxing20160101@gmail.com
* @time 2018/8/19 0:33
*/
public class ConcretHandler1 extends AbstractHandler {
@Override
public void handle(AbstractRequest request) {
System.out.println("Handler1 handler request :"+request.getRequestLevel());
}
@Override
public int getHandlerLevel() {
return 1;
}
}
/**
* 具体处理者2
* @author newtrekWang
* @email wangjiaxing20160101@gmail.com
* @time 2018/8/19 0:33
*/
public class ConcretHandler2 extends AbstractHandler {
@Override
public void handle(AbstractRequest request) {
System.out.println("Handler2 handler request :"+request.getRequestLevel());
}
@Override
public int getHandlerLevel() {
return 2;
}
}
/**
* 具体处理者3
* @author newtrekWang
* @email wangjiaxing20160101@gmail.com
* @time 2018/8/19 0:33
*/
public class ConcretHandler3 extends AbstractHandler {
@Override
public void handle(AbstractRequest request) {
System.out.println("Handler3 handler request :"+request.getRequestLevel());
}
@Override
public int getHandlerLevel() {
return 3;
}
}
/**
* 具体请求者1
* @author newtrekWang
* @email wangjiaxing20160101@gmail.com
* @time 2018/8/19 0:36
*/
public class ConcretRequest1 extends AbstractRequest {
/**
* 通过构造函数注入要处理的内容对象
*
* @param object 要处理的内容对象
*/
public ConcretRequest1(Object object) {
super(object);
}
@Override
public int getRequestLevel() {
return 1;
}
}
**
* 具体请求者2
* @author newtrekWang
* @email wangjiaxing20160101@gmail.com
* @time 2018/8/19 0:36
*/
public class ConcretRequest2 extends AbstractRequest {
/**
* 通过构造函数注入要处理的内容对象
*
* @param object 要处理的内容对象
*/
public ConcretRequest2(Object object) {
super(object);
}
@Override
public int getRequestLevel() {
return 2;
}
}
**
* 具体请求者3
* @author newtrekWang
* @email wangjiaxing20160101@gmail.com
* @time 2018/8/19 0:36
*/
public class ConcretRequest3 extends AbstractRequest {
/**
* 通过构造函数注入要处理的内容对象
*
* @param object 要处理的内容对象
*/
public ConcretRequest3(Object object) {
super(object);
}
@Override
public int getRequestLevel() {
return 3;
}
}
public static void main(String[] args){
// 三个不同级别的请求
AbstractRequest request1 = new ConcretRequest1("request 1");
AbstractRequest request2 = new ConcretRequest2("request 2");
AbstractRequest request3 = new ConcretRequest3("request 3");
//三个不同级别的处理者
AbstractHandler handler1 = new ConcretHandler1();
AbstractHandler handler2 = new ConcretHandler2();
AbstractHandler handler3 = new ConcretHandler3();
// 设置处理者的链式关系
handler1.setNextHandler(handler2);
handler2.setNextHandler(handler3);
// 总是从链子的首端发起请求
handler1.handleRequest(request1);
handler1.handleRequest(request2);
handler1.handleRequest(request3);
}
输出结果：
Handler1 handler request :1
Handler2 handler request :2
Handler3 handler request :3
优点
对请求者和处理者关系解耦，提高代码的灵活性。
缺点
如果处理者太多，那么遍历必定会影响性能。
应用例子1 Android 的触摸事件传递与分发机制
应用例子2 利用有序广播实现责任链事件处理
Android种的BroastCast分为两种，一种时普通广播，另一种是有序广播。普通广播是异步的，发出时可以被所有的接收者收到。而有序广播是根据优先级一次传播的，直到有接收者将其终止或者所有接收者都不终止它。有序广播的这一特性与我们的责任链模式很相近，我们可以轻松地实现一种全局的责任链事件处理。
