介绍：使多个对象都有机会处理请求，避免请求者和发送者之间的耦合关系，将这些对象连成一条链，沿着链处理请求，知道有对象处理它为止。

场景：此模式通过一种链式结构来处理请求，当业务发生变动时，我们可以像配置web.xml中的拦截器一样，删除或者调整拦截器的位置，也就是责任链中处理者的位置，达到不同的处理结果。

1.请求

请求者基类

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;
    }
}

2.处理者

处理者基类

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.客户端调用

// 构造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种处理者，通过根据请求的等级来决定自己是否处理。如果我们需要修改责任链中的结构，只需要将链条指向改变就行。