定义：
- 使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。将这些对象形成一条链，并沿着这条链传递该请求，直到有对象处理它为止。
通用类图：
责任链模式通用类图
/*
* 定义抽象的处理类
* */
public abstract class Handler {
// 根据当前设置的相关等级做出对应的处理
private Handler nextHandler;
final Response handleMessage(Request request) {
Response response = null;
// 指定不同的判断条件
if (request.getLevel().equals(this.getHandlerLevel())) {
response = this.echo(request);
} else {
if (nextHandler != null) {
response = this.nextHandler.handleMessage(request);
} else {
}
}
return response;
}
public void setNextHandler(Handler handler) {
this.nextHandler = handler;
}
// 抽象出获取等级和处理相应的方法
abstract Level getHandlerLevel();
abstract Response echo(Request request);
}
/*
* 定义请求类
* */
public class Request {
Level getLevel() {
return null;
}
}
public class Response {
// 返回的相应数据
}
/*
* 定义一个请求和处理等级
* */
public class Level {
}
public class HandlerOne extends Handler {
@Override
Level getHandlerLevel() {
// TODO Auto-generated method stub
return null;
}
@Override
Response echo(Request request) {
// TODO Auto-generated method stub
return null;
}
}
public class HandlerThree extends Handler {
@Override
Level getHandlerLevel() {
// TODO Auto-generated method stub
return null;
}
@Override
Response echo(Request request) {
// TODO Auto-generated method stub
return null;
}
}
public class HandlerTwo extends Handler {
@Override
Level getHandlerLevel() {
// TODO Auto-generated method stub
return null;
}
@Override
Response echo(Request request) {
// TODO Auto-generated method stub
return null;
}
}
public class Client {
public static void main(String[] args) {
// 创建所有可能的处理节点
HandlerOne handlerOne = new HandlerOne();
HandlerTwo handlerTwo = new HandlerTwo();
HandlerThree handlerThree = new HandlerThree();
// 设置责任连的执行顺序
handlerOne.setNextHandler(handlerTwo);
handlerTwo.setNextHandler(handlerThree);
Response response = handlerOne.handleMessage(new Request());
}
}
优点：
- 将请求和处理分开，解除耦合提高系统的灵活性
缺点：
- 性能问题
- 调试不便，特别是责任连较长、环节较多，由于采用了类似递归的方法，调试逻辑较复杂。
注意事项：
- 需要控制链中节点的数量，避免出现超长链的情况，通常的做法是Handler中设置最大的节点数量，在setNext方法中判断是否已经超过阈值，避免降低系统性能。
