设计模式之责任链模式

责任链模式定义如下：
  Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it. 即：每个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。讲这些对象连城一条链，并沿着这些链传递该请求，直到对象处理为止。
  责任链模式的重点在“链”上，由一条链去处理相似的请求在链中决定谁来处理这个请求，并返回相应的结果。通用类图如下所示：

HandlerChain.jpg

责任链模式的核心在“链”上，链由多个ConcreteHandler组成，通用代码如下：

//处理者抽象类
public abstract class Handler{
    
    private Handler nextHandler;
    private int level;
    
    public final Response hanldRequest(Request request){
        Response response = null;
        //判断是否是自己的处理级别
        if(this.getHandlerLevel()==request.getLevel()){
            response = this.echo(request);
        }else if(this.nextHandler != null){
            response = this.nextHandler.hanldRequest(request);
        }else{
            System.out.println("no such request!");
            return response;
        }
        
        return response;
    }
    
    //设置下一个处理者
    public void setNextHandler(Handler nextHandler){
        this.nextHandler = nextHandler;
    }
    
    //设置请求级别
    public void setLevel(int level){
        this.level = level;
    }
    
    //获取当前处理者级别
    public  int getHandlerLevel(){
        return this.level;
    }
    
    //当前处理者必须实现的任务
    protected abstract Response echo(Request request);
}

//具体处理者1
public class Handler1 extends Handler{

    @Override
    protected Response echo(Request request) {
        System.out.println("Handler 1 echo!");
        return new Response("Handler 1 response!");
    }
}

//具体处理者2
public class Handler2 extends Handler{

    @Override
    protected Response echo(Request request) {
        System.out.println("Handler 2 echo!");
        return new Response("Handler 2 response!");
    }

}

//具体处理者3
public class Handler3 extends Handler{
    
    @Override
    protected Response echo(Request request) {
        System.out.println("Handler 3 echo!");
        return new Response("Handler 3 response!");
    }

}

//请求类
public class Request{
    private int level;
    private String requestContent;
    
    public Request(int level,String requestContent){
        this.level = level;
        this.requestContent = requestContent;
    }

    public int getLevel() {
        return level;
    }

    public String getRequestContent() {
        return requestContent;
    }

}

//相应类
public class Response{
    private String responseContent;

    public Response(String responseContent){
        this.responseContent = responseContent;
    }
    public String getResponseContent() {
        return responseContent;
    }

} 

//客户端
public class ChainClient{
    public static void main(String[] args) {
        
        Handler handler1 = new Handler1();
        Handler handler2 = new Handler2();
        Handler handler3 = new Handler3();
        
        handler1.setLevel(1);
        handler1.setNextHandler(handler2);
        
        handler2.setLevel(2);
        handler2.setNextHandler(handler3);
        
        handler3.setLevel(3);
        handler3.setNextHandler(null);
        
        Response response = handler1.hanldRequest(new Request(3,"request 3"));
    }
}

运行结果如下：

Handler 3 echo!

注意：在责任链模式中，一个请求发送到链中后，前一节点消费部分消息，然后交由后续节点继续使用，最终可以有处理结果也可以没有处理结果。

责任链模式的应用

责任链模式的优点

责任链模式非常显著的优点是将请求和处理分开。请求者可以不用知道是谁处理的，处理者可以不用知道请求的全貌，两者解耦，提高系统的灵活性。

责任链模式的缺点

责任链模式有两个非常显著的特征：一个是性能问题，每个请求都是从链头开始遍历，特别是当链特别长的时候，性能是一个非常大的问题。二是调试不方便，调试的时候逻辑了能比较复杂。

责任链模式的注意事项

责任链的长度需要控制，避免出现超长链的问题。一般的做法是在Handler中设置最大节点长度，然后在setNext中判断是否超过其阈值。

《注》以上内容总结自秦小波-《设计模式之禅》，仅为个人学习笔记。