定义

使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合。将这些对象连成一个链，并沿着这条链传递该请求，直到有对象处理它为止。

UML类图

责任链模式.png

责任链模式的角色

AbstractRequest

抽象请求类，封装请求的公有方法。
ConcreteRequest

具体请求类，实现抽象请求并实现自己的逻辑，如请求级别等。
AbstractHandler

抽象处理类，持有下一个处理类的引用，判断是否可以处理当前请求或者继续分发请求。
ConcreteHandler

具体处理类，实现处理请求的具体逻辑。

示例

责任链模式的示例代码，简单的判断当前处理类和请求类是否为同一级别，如果是则处理，否则继续分发到下一个处理类处理。

/**
 * 抽象请求类
 */
public abstract class AbstractRequest {

    private String content;

    public AbstractRequest(String content){
        this.content = content;
    }

    public String getContent() {
        return content;
    }

    abstract int requestLevel();
}

/**
 * 具体请求类
 */
public class ConcreteRequest1 extends AbstractRequest {

    public ConcreteRequest1(String content) {
        super(content);
    }

    @Override
    int requestLevel() {
        return 1;
    }
}

/**
 * 抽象处理类
 */
public abstract class AbstractHandler {

    public AbstractHandler nextHandler;
    private void handleRequest(AbstractRequest request){
        if (request.requestLevel()== handleLevel()){
            handle(request);
        }else {
            if (null!=nextHandler){
                nextHandler.handleRequest(request);
            }
        }
    }
    abstract int handleLevel();
    abstract void handle(AbstractRequest request);
}

/**
 * 具体处理类
 */
public class ConcreteHandler1 extends AbstractHandler {

    @Override
    int handleLevel() {
        return 1;
    }

    @Override
    void handle(AbstractRequest request) {
        System.out.println(this.getClass().getName() +"处理了"+request.getClass().getName()+"请求，"+"内容为"+request.getContent());
    }
}

public class ConcreteHandler2 extends AbstractHandler {

    @Override
    int handleLevel() {
        return 2;
    }

    @Override
    void handle(AbstractRequest request) {
        System.out.println(this.getClass().getName() +"处理了"+request.getClass().getName()+"请求，"+"内容为"+request.getContent());
    }
}

/**
 * 客户端类
 */
public class Client {
    public static void main(String[] args) {
        ConcreteRequest1 request1 = new ConcreteRequest1("request1 content");

        ConcreteHandler1 handler1 = new ConcreteHandler1();
        ConcreteHandler2 handler2 = new ConcreteHandler2();
        //构建责任链
        handler1.nextHandler = handler2;
        handler2.nextHandler = handler1;
        //从handler1开始处理request1请求
        handler1.handle(request1);
    }
}
>>
chain.ConcreteHandler1处理了chain.ConcreteRequest1请求，内容为request1 content