责任链模式解析-优快云博客

本文链接：https://blog.youkuaiyun.com/starexplode/article/details/83662005

责任链模式

Avoid coupling the sender of a request to its receiver by giving more than one objecta chance to handler the request. Chain the receiving objects and pass the request along the chain until an object handlers it.(使多个对象都有机会处理请求，从而避免了请求发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，知道所有对象处理完为止)

责任链模式的重点在“链”上，由这一条链去处理相似的请求，并返回相应的结果。其通用的类图如下所示：
责任链模式通用类图

责任链模式的核心在“链”上，“链”是有多个处理者ConcreteHandler组成的，我们首先来看抽象Handler类，如下所示：

public abstract class Handler {
    
    private Handler nextHandler;
    
    public final Response handlerMessage(Request request) {
        Response response = null;
        // 判断自己的处理级别
        if (this.getHandlerLevel().equals(request.getRequestLevel())) {
            response = this.echo(request);
        } else {
            // 不属于自己的处理级别
            // 判断是否有下一个处理者
            if (this.nextHandler != null) {
                response = this.nextHandler.handlerMessage(request);
            } else {
                // 没有适当的处理者，业务自行处理
            }
        }
        return response;
    }

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

    /**
     * 每一个处理者都有一个处理级别
     * @return
     */
    protected abstract Level getHandlerLevel();

    /**
     * 每一个处理者都必须实现处理任务
     * @param request
     * @return
     */
    protected abstract Response echo(Request request);

}

抽象的处理者实现三个职责：

定义一个请求处理的方法handelMessage，唯一对外开放的方法
定义一个链的编排方法setNext，设置下一个处理者。
定义了具体的请求者必须实现两个方法：
- 定义自己的处理级别getHandlerLevel
- 具体的处理任务echo

下面定义了三个具体的处理者，以便组成一个链，代码如下：

public class ConcreteHandler1 extends Handler {
    /**
     * 定义自己的处理级别
     * @return
     */
    @Override
    public Level getHandlerLevel() {
        return null;
    }

    /**
     * 定义自己的处理逻辑
     * @param request
     * @return
     */
    @Override
    public Response echo(Request request) {
        return null;
    }

}

public class ConcreteHandler2 extends Handler {
    /**
     * 定义自己的处理级别
     * @return
     */
    @Override
    public Level getHandlerLevel() {
        return null;
    }

    /**
     * 定义自己的处理逻辑
     * @param request
     * @return
     */
    @Override
    public Response echo(Request request) {
        return null;
    }

}

public class ConcreteHandler3 extends Handler {
    /**
     * 定义自己的处理级别
     * @return
     */
    @Override
    public Level getHandlerLevel() {
        return null;
    }

    /**
     * 定义自己的处理逻辑
     * @param request
     * @return
     */
    @Override
    public Response echo(Request request) {
        return null;
    }
}

在处理者中涉及了三个类：Level类负责定义请求和处理的级别，Request负责封装请求，Response负责封装返回链中的结果，三个类根据需要的业务产生。

模式中的其他一些代码：

public class Request {
    private Level level;

    public Request(Level level) {
        this.level = level;
    }

    public Level getRequestLevel() {
        return level;
    }

    public Level getLevel() {
        return level;
    }

    public void setLevel(Level level) {
        this.level = level;
    }
}

public class Response {
}

public class Level {
    private int level;

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

    public int getLevel() {
        return level;
    }

    public void setLevel(int level) {
        this.level = level;
    }
}

在场景类或高层类中对链进行组装，并传递请求，返回结果，如下所示：

public class Client {
    public static void main(String[] args) {
        // 声明所有的处理节点
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler1();
        Handler handler3 = new ConcreteHandler1();

        // 设置链中处理阶段1-->2-->3
        handler1.setNextHandler(handler2);
        handler2.setNextHandler(handler3);
        // 提交请求，返回结果
        Response response = handler1.handlerMessage(new Request(new Level(2)));
    }
}