介绍:使多个对象都有机会处理请求,避免请求者和发送者之间的耦合关系,将这些对象连成一条链,沿着链处理请求,知道有对象处理它为止。
场景:当我第一眼看到责任链模式的时候,我就想到了J2EE中的拦截器/过滤器。后来,自行百度了一下,更加证明了我的想法。此模式通过一种链式结构来处理请求,当业务发生变动时,我们可以像配置web.xml中的拦截器一样,删除或者调整拦截器的位置,也就是责任链中处理者的位置,达到不同的处理结果。
一、请求
请求者基类
public abstract class BaseRequest {
private Object obj;// 处理对象
public BaseRequest(Object obj) {
this.obj = obj;
}
/**
* 获取处理的内容对象
*/
public Object getContent() {
return obj;
}
/**
* 获取请求级别
*/
public abstract int getRequestLevel();
}
三个具体实现的请求
public class Request1 extends BaseRequest {
public Request1(Object obj) {
super(obj);
}
@Override
public int getRequestLevel() {
return 1;
}
}
public class Request2 extends BaseRequest{
public Request2(Object obj) {
super(obj);
}
@Override
public int getRequestLevel() {
return 2;
}
}
public class Request3 extends BaseRequest {
public Request3(Object obj) {
super(obj);
}
@Override
public int getRequestLevel() {
return 3;
}
}
二、处理者
处理者基类
public abstract class BaseHandler {
protected BaseHandler nextHandler;// 下一个处理者
/**
* 处理请求
*/
public final void handleRequest(BaseRequest request) {
// 判断当前处理者对象的处理级别是否与请求者的处理级别一致
if (getHandleLevel() == request.getRequestLevel()) {
// 如果等级一致,则处理请求
handle(request);
} else {
if (nextHandler != null) {
// 如果等级不一致,且下面还有处理者,则交给下面处理者处理
nextHandler.handleRequest(request);
} else {
// 当所有处理者都不能处理
System.out.println("All of handler can not do it");
}
}
}
/**
* 获取处理者对象的处理级别
*/
protected abstract int getHandleLevel();
/**
* 每个处理者对象的具体处理方式
*/
protected abstract void handle(BaseRequest request);
}
三个具体处理者
public class Handler1 extends BaseHandler {
@Override
protected int getHandleLevel() {
return 1;
}
@Override
protected void handle(BaseRequest request) {
System.out.println("Handler1 handle request:" + request.getRequestLevel());
}
}
public class Handler2 extends BaseHandler {
@Override
protected int getHandleLevel() {
return 2;
}
@Override
protected void handle(BaseRequest request) {
System.out.println("Handler2 handle request:" + request.getRequestLevel());
}
}
public class Handler3 extends BaseHandler {
@Override
protected int getHandleLevel() {
return 3;
}
@Override
protected void handle(BaseRequest request) {
System.out.println("Handler3 handle request:" + request.getRequestLevel());
}
}
三、客户端调用
// 构造3个处理者
BaseHandler h1 = new Handler1();
BaseHandler h2 = new Handler2();
BaseHandler h3 = new Handler3();
// 设置处理者之间的责任链关系
h1.nextHandler = h2;
h2.nextHandler = h3;
// 构造3个请求者
BaseRequest r1 = new Request1("obj1");
BaseRequest r2 = new Request2("obj2");
BaseRequest r3 = new Request3("obj3");
h1.handleRequest(r1);
h1.handleRequest(r2);
h1.handleRequest(r3);
输出
Handler1 handle request:1
Handler2 handle request:2
Handler3 handle request:3
总结:可见,责任链中的3种处理者,通过根据请求的等级来决定自己是否处理。如果我们需要修改责任链中的结构,只需要将链条指向改变就行。
更多模式:一天一个设计模式—分类与六大原则