责任链模式

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 注意事项

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

ChainOfResponsibilityPattern责任链模式