1、定义
一个请求沿着一条“链”传递，直到该“链”上的某个处理者处理它为止。实际上就是一个递归。
2、介绍
- 责任链模式属于行为型模式。
- 多个对象中，每个对象都持有下一个对象的引用，这就构成了链这种结构。
- 一个请求通过链的头部，一直往下传递到链上的每一个结点，直到有某个结点对这个请求做出处理为止，这就是责任链模式。
- 责任链模式一般分为处理者与请求者。具体的处理者分别处理请求者的行为。
3、UML类图
角色说明：
- Handler（抽象处理者）：抽象类或者接口,定义处理请求的方法以及持有下一个Handler的引用.
- ConcreteHandler1,ConcreteHandler2（具体处理者）：实现抽象处理类,对请求进行处理,如果不处理则转发给下一个处理者.
- Client (客户端):即要使用责任链模式的地方。
4、实现
抽象类
public abstract class AbstractHandler {
/**
* 下一个节点
*/
protected AbstractHandler nextHandler;
/**
* 处理时间
*
* @param request 条件
* @return
*/
public abstract String handlerRequest(String request);
}
实现类
public class Handler1 extends AbstractHandler{
@Override
public String handlerRequest(String request) {
if (request.equals("handler1")){
return "handler1";
} else {
return "handler1 + " + nextHandler.handlerRequest(request);
}
}
}
public class Handler2 extends AbstractHandler{
@Override
public String handlerRequest(String request) {
if (request.equals("handler2")){
return "handler2";
} else {
return "handler2 + " + nextHandler.handlerRequest(request);
}
}
}
执行类
public class MainTest {
public static void main(String[] args) {
AbstractHandler handler1 = new Handler1();
AbstractHandler handler2 = new Handler2();
handler1.nextHandler = handler2;
System.out.println(handler1.handlerRequest("handler2"));
}
}
5、另一种实现方式
以送快递为例，单个快递员只负责某个片区的快递，若某个快递目的地不属于当前的片区，则交给下一个快递员来处理，直到有人处理为止。
创建抽象处理者
public abstract class AbstractHandler {
/**
* 下一节点上的处理者对象
*/
protected 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;
}
}
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();
}
创建具体处理者类
public class ConductHandler1 extends AbstractHandler {
@Override
public void handle(AbstractRequest request) {
System.out.println("Handler1 handler request :"+request.getRequestLevel());
}
@Override
public int getHandlerLevel() {
return 1;
}
}
public class ConductHandler2 extends AbstractHandler {
@Override
public void handle(AbstractRequest request) {
System.out.println("Handler2 handler request :"+request.getRequestLevel());
}
@Override
public int getHandlerLevel() {
return 2;
}
}
public class ConductRequest1 extends AbstractRequest {
/**
* 通过构造函数注入要处理的内容对象
*
* @param object 要处理的内容对象
*/
public ConductRequest1(Object object) {
super(object);
}
@Override
public int getRequestLevel() {
return 1;
}
}
public class ConductRequest2 extends AbstractRequest{
/**
* 通过构造函数注入要处理的内容对象
*
* @param object 要处理的内容对象
*/
public ConductRequest2(Object object) {
super(object);
}
@Override
public int getRequestLevel() {
return 2;
}
}
客户端测试
public class TextMan {
public static void main(String[] argc){
//不同级别的请求
AbstractRequest request1 = new ConductRequest1("request 1");
AbstractRequest request2 = new ConductRequest2("request 2");
//不同级别的处理者
AbstractHandler handler1 = new ConductHandler1();
AbstractHandler handler2 = new ConductHandler2();
// 设置处理者的链式关系
handler1.setNextHandler(handler2);
// 总是从链子的首端发起请求
handler1.handleRequest(request1);
handler1.handleRequest(request2);
}
}
6、应用场景
多个对象处理同一请求时，但是具体由哪个对象去处理需要运行时做判断。
具体处理者不明确的情况下，向这组对象提交了一个请求。
7. 优点
代码的解耦，请求者与处理者的隔离分开。
易于扩展，新增处理者往链上加结点即可。
8、缺点
责任链过长的话，或者链上的结点判断处理时间太长的话会影响性能，特别是递归循环的时候。
请求有可能遍历完链都得不到处理。
9. Android中的源码分析
Android中的事件分发机制就是类似于责任链模式，关于事件分发机制，这里先不详述了，先占个坑，后面另起文章说明。
另外，OKhttp中对请求的处理也是用到了责任链模式，有兴趣的可以去看下OKhttp的源码。后面有时间也会对OKhttp的源码进行分析。
9.1、模仿OkHttp实现一个拦截器
接口类
public interface Interceptor {
String intercept(Chain chain);
interface Chain {
String request();
String proceed(String request);
}
}
工具类
public class RealInterceptorChain implements Interceptor.Chain {
private List<Interceptor> interceptors;
private String request;
private int index;
public RealInterceptorChain(List<Interceptor> interceptors, String request, int index) {
this.interceptors = interceptors;
this.request = request;
this.index = index;
}
@Override
public String request() {
return request;
}
@Override
public String proceed(String request) {
RealInterceptorChain next = new RealInterceptorChain(interceptors, request, index + 1);
Interceptor interceptor = interceptors.get(index);
String response = interceptor.intercept(next);
return response;
}
}
实现接口类
public class HandlerInterceptor1 implements Interceptor {
@Override
public String intercept(Chain chain) {
String request = chain.request();
request = request + " ==> HandlerInterceptor1";
String response = chain.proceed(request);
response = response + "HandlerInterceptor1 ==> ";
return response;
}
}
public class HandlerInterceptor2 implements Interceptor{
@Override
public String intercept(Chain chain) {
String request = chain.request();
request = request + " ==> HandlerInterceptor2";
String response = chain.proceed(request);
response = response + "HandlerInterceptor2 ==> ";
return response;
}
}
public class HandlerInterceptor3 implements Interceptor {
@Override
public String intercept(Chain chain) {
String request = chain.request();
System.out.println(request + " ==> HandlerInterceptor3");
return " HandlerInterceptor3 ==> ";
}
}
执行
public class MainTest {
public static void main(String[] args) {
List<Interceptor> interceptors = new ArrayList<>();
interceptors.add(new HandlerInterceptor1());
interceptors.add(new HandlerInterceptor2());
interceptors.add(new HandlerInterceptor3());
RealInterceptorChain chain = new RealInterceptorChain(interceptors,
"开始 ==> ", 0);
String response = chain.proceed("请求 ==> ");
System.out.println(response + "结束");
}
}
