责任链模式

1、基本概念

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

抽象处理类：抽象处理类中主要包含一个指向下一处理类的成员变量nextHandler和一个处理请求的方法handRequest，handRequest方法的主要主要思想是，如果满足处理的条件，则有本处理类来进行处理，否则由nextHandler来处理。

具体处理类：具体处理类主要是对具体的处理逻辑和处理的适用条件进行实现。

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

    public boolean above(Level level){
        if(this.level >= level.level){
            return true;
        }
        return false;
    }
}

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

    public Level getLevel(){
        return level;
    }
}

class Response {

}

abstract class Handler {
    //链式结构
    private Handler nextHandler;
    public final Response handleRequest(Request request){
        Response response = null;

        //逐级判断 直到找到处理的方法
      if(this.getHandlerLevel().above(request.getLevel())){
            response = this.response(request);
        }else{
            if(this.nextHandler != null){
                this.nextHandler.handleRequest(request);
            }else{
                System.out.println("-----没有合适的处理器-----");
            }
        }
        return response;
    }
    public void setNextHandler(Handler handler){
        this.nextHandler = handler;
    }
    protected abstract Level getHandlerLevel();
    public abstract Response response(Request request);
}

class ConcreteHandler1 extends Handler {
    protected Level getHandlerLevel() {
        return new Level(1);
    }
    public Response response(Request request) {
        System.out.println("-----请求由处理器1进行处理-----");
        return null;
    }
}

class ConcreteHandler2 extends Handler {
    protected Level getHandlerLevel() {
        return new Level(3);
    }
    public Response response(Request request) {
        System.out.println("-----请求由处理器2进行处理-----");
        return null;
    }
}

class ConcreteHandler3 extends Handler {
    protected Level getHandlerLevel() {
        return new Level(5);
    }
    public Response response(Request request) {
        System.out.println("-----请求由处理器3进行处理-----");
        return null;
    }
}

public class Test {
    public static void main(String[] args){
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();

        handler1.setNextHandler(handler2);
        handler2.setNextHandler(handler3);

        Response response = handler1.handleRequest(new Request(new Level(4)));
    }
}

优点：

将请求和处理分开，请求者可以不用知道谁处理，处理者也不用关心请求的全貌。两者解耦，提高系统灵活性

缺点：

性能问题：每个请求都是从头到尾，如果链太长，性能不会太好
调试不方便

参考：http://blog.youkuaiyun.com/zhengzhb/article/details/7568676