1. 定义
使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。
责任链模式的重点是在“链”上，由一条链去处理相似的请求在链中决定谁来处理这个请求，并返回相应的结果。
责任链模式
2. 使用场景
- 多个对象可以处理同一个请求，但是具体由哪个对象处理需要在运行时动态决定。
- 在处理对象不明确的前提下，向多个对象提交一个请求。
- 需要动态指定一组对象来处理请求。
3. 实现
抽象处理者：
/**
* 抽象处理者
* 抽象的处理者实现三个职责：
* 1. 定义一个对外开放的请求的处理方法handleMessage模板方法（final）
* 2. 定义一个链的编排方法setNext，设置下一个处理者
* 3. 定义了具体的请求者必须实现的两个方法：定义自己能够处理的级别getHandlerLevel和具体的处理任务doSomething方法
*/
public abstract class Handler {
private Handler mNextHandler;
public final Response handleRequest(Request request) {
Response response;
//判断是否是自己的处理级别
if (request.getRequestLevel() == this.getHandlerLevel()) {
response = this.doSomething(request);
} else if (this.mNextHandler != null) {
//不属于自己的处理级别，交给下一个处理
response = this.mNextHandler.handleRequest(request);
} else {
//没有适当的处理者,业务自行处理
response = new Response("没有适当的处理者");
}
return response;
}
public void setNextHandler(Handler nextHandler) {
this.mNextHandler = nextHandler;
}
protected abstract int getHandlerLevel();
protected abstract Response doSomething(Request request);
}
具体处理者：
public class ConcreteHandler1 extends Handler {
@Override
protected int getHandlerLevel() {
return 1;
}
@Override
protected Response doSomething(Request request) {
return new Response(this.getClass().getSimpleName() + "处理了" + request.getRequest());
}
}
public class ConcreteHandler2 extends Handler {
@Override
protected int getHandlerLevel() {
return 2;
}
@Override
protected Response doSomething(Request request) {
return new Response(this.getClass().getSimpleName() + "处理了" + request.getRequest());
}
}
public class ConcreteHandler3 extends Handler {
@Override
protected int getHandlerLevel() {
return 3;
}
@Override
protected Response doSomething(Request request) {
return new Response(this.getClass().getSimpleName() + "处理了" + request.getRequest());
}
}
相关框架代码：
/**
* 请求
*/
public class Request {
//请求等级
private int mRequestLevel;
//请求参数
private String mRequest;
public Request(int requestLevel, String request) {
this.mRequestLevel = requestLevel;
this.mRequest = request;
}
public int getRequestLevel() {
return this.mRequestLevel;
}
public String getRequest() {
return this.mRequest;
}
}
/**
* 相应
*/
public class Response {
//相应内容
private String mResult;
public Response(String result) {
this.mResult = result;
}
public String getReslust() {
return this.mResult;
}
}
场景类：
public class Client {
public static void main(String[] args) {
Handler handler1 = new ConcreteHandler1();
Handler handler2 = new ConcreteHandler2();
Handler handler3 = new ConcreteHandler3();
//动态生成处理者的责任链
handler1.setNextHandler(handler2);
handler2.setNextHandler(handler3);
//发送请求A
Response response1 = handler1.handleRequest(new Request(1, "请求A"));
System.out.println(response1.getReslust());
//发送请求B
Response response2 = handler1.handleRequest(new Request(2, "请求B"));
System.out.println(response2.getReslust());
//发送请求C
Response response3 = handler1.handleRequest(new Request(3, "请求C"));
System.out.println(response3.getReslust());
}
}
运行结果：
ConcreteHandler1处理了请求A
ConcreteHandler2处理了请求B
ConcreteHandler3处理了请求C
4. 优点
- 责任链模式非常显著的优点是将请求和处理分开。请求者可以不用知道是谁处理的，处理者可以不用知道请求的全貌。
- 请求和处理解耦，提高了系统的灵活性。
5. 缺点
- 性能问题。每个请求都是从链头遍历到链尾,特别是在链比较长的时候,性能是一个非常大的问题。（观察者模式也有类似问题）
- 调试不很方便。特别是链条比较长，环节比较多的时候，由于采用了类似递归的方式，调试的时候逻辑可能比较复杂。
