【校招VIP】ChainOfResponsibility责任链模式

转载声明：文章来源https://www.cnblogs.com/jeff-chang/p/13556562.html

1.定义

为请求创建一个接收者对象的链，使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之前的耦合关系。

责任链模式通常有5个角色。责任链模式的重点在链上，由一条多个接收者对象组成的链去处理相似的请求，并且返回相似的结果。

Level类：请求和处理的等级

public enum Level {

ONE(0), TWO(1), THREE(2), FOUR(3);

private final int level;

public int getLevel() {
return this.level;
}

Level(int level) {
this.level = level;
}

public static Level valueOf(int level) {
for (Level levelEnum : Level.values()) {
if (levelEnum.level == level) {
return levelEnum;
}
}

return null;
}
}

Request类：定义相似的请求

public class Request {

/** 请求的等级 **/
private Level level;

public Level getLevel() {
return level;
}

/**
* 设置请求等级
* @param level
*/
public Request(Level level) {
this.level = level;
}
}

Response类：定义接收者处理请求后返回的数据

public class Response {

/** 接收者请求的处理结果 **/
private String message;

public String getMessage() {
return message;
}

public void setMessage(String message) {
this.message = message;
}

public Response(String message) {
this.message = message;
}
}

AbstractHandler抽象处理者

3要素：

定义唯一对外开放的请求处理方法handle
定义链的编排方法setNextHandler
定义请求者必须实现的两个方法getHandlerLevel和echo

public abstract class AbstractHandler {

/** 定义下一个处理者 **/
private AbstractHandler nextHandler;

/**
* 设置下一个处理者
* @param nextHandler
*/
public void setNextHandler(AbstractHandler nextHandler) {
this.nextHandler = nextHandler;
}

/**
* 获取处理者的等级
**/
protected abstract Level getHandlerLevel();

/**
* 处理者实现处理任务
* @param request
* @return
*/
protected abstract Response echo(Request request);

/**
* 请求处理方法
* @param request
* @return
*/
public final Response handle(Request request) {
Response response = null;

// 比较请求等级与自身等级是否匹配
if (request != null && this.getHandlerLevel().name().equals(request.getLevel().name())) {
response = this.echo(request);
} else {
// 是否有下一个处理者
if (this.nextHandler != null) {
response = this.nextHandler.handle(request);
} else {
response = new Response("没有找到合适的处理者，业务自行处理");
}
}

return response;
}
}

具体处理者

public class HandlerOne extends AbstractHandler {

@Override
protected Level getHandlerLevel() {
return Level.valueOf(0);
}

@Override
protected Response echo(Request request) {
return new Response("处理结果一");
}
}

public class HandlerTwo extends AbstractHandler {

@Override
protected Level getHandlerLevel() {
return Level.valueOf(1);
}

@Override
protected Response echo(Request request) {
return new Response("处理结果二");
}
}

public class HandlerThree extends AbstractHandler {

@Override
protected Level getHandlerLevel() {
return Level.valueOf(2);
}

@Override
protected Response echo(Request request) {
return new Response("处理结果三");
}
}

场景类

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 responseOne = handlerOne.handle(new Request(Level.valueOf(2)));
System.out.println(responseOne.getMessage());

Response responseTwo = handlerOne.handle(new Request(Level.valueOf(3)));
System.out.println(responseTwo.getMessage());
}
}

2.应用

2.1 优点

将请求及处理过程分离开，两者解耦，提高系统的灵活性。

2.2 缺点

性能问题：每一个请求都是从链头遍历到链尾，当链长度较大时，影响性能。
不方便调试：当链长度较大时，采用了类似递归的实现方式，增加逻辑的复杂度。

2.3 注意事项
使用责任链模式应尽量避免超长链，需要对链中的节点数量做限制。一般做法为在处理者中设置一个最大节点数量，在设置下一个处理者的时候判断是否已经超过设置的阈值，超过则不允许该链的建立，避免无意中破坏系统的性能。