11-责任链模式

责任链模式

一、定义

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

责任链的通用类

责任链模式的核心在“链”上，“链”是由多个处理者ConcreteHandler组成

责任链的通用源码

1. 抽象处理者

   public abstract class Handler {
       private Handler nextHandler;
       
       //每个处理者都必须对请求做出处理
        public final Response handleMessage(Request request){
           Response response = null;
           //判断是否是自己的处理级别
           if(this.getHandlerLevel().equals(request.getRequestLevel())){
           	response = this.echo(request);
           }else{ //不属于自己的处理级别
               //判断是否有下一个处理者
               if(this.nextHandler != null){
                   response = this.nextHandler.handleMessage(request);
               }else{
                   //没有适当的处理者，业务自行处理
               }
       	}
       	return response;
       }
       
       //设置下一个处理者是谁
       public void setNext(Handler _handler){
       	this.nextHandler = _handler;
       }
       
       //每个处理者都有一个处理级别
       protected abstract Level getHandlerLevel();
       
       //每个处理者都必须实现处理任务
       protected abstract Response echo(Request request);
   }
   

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

   • 一是定义一个请求的处理方法handleMessage，唯一对外开
     放的方法；
   • 二是定义一个链的编排方法setNext，设置下一个处理者；
   • 三是定义了具体的请求者必须实现的两个方法：
     • 定义自己能够处理的级别getHandlerLevel
     • 具体的子类的处理任务echo

2. 具体处理者

   public class ConcreteHandler1 extends Handler {
       //定义自己的处理逻辑
       
       protected Response echo(Request request) {
           //完成处理逻辑
           return null;
        }
       
       //设置自己的处理级别
       protected Level getHandlerLevel() {
           //设置自己的处理级别
           return null;
       }
   }
   

   public class ConcreteHandler2 extends Handler {
       //定义自己的处理逻辑
       protected Response echo(Request request) {
           //完成处理逻辑
           return null;
       }
       //设置自己的处理级别
       protected Level getHandlerLevel() {
           //设置自己的处理级别
           return null;
       }
   }
   

   在处理者中涉及三个类：

   • Level类负责定义请求和处理级别，
   • Request类负责封装请求，
   • Response负责封装链中返回的结果

   该三个类都需要根据业务产生

3. 场景类

   public class Client {
       public static void main(String[] args) {
           //声明所有的处理节点
           Handler handler1 = new ConcreteHandler1();
           Handler handler2 = new ConcreteHandler2();
           Handler handler3 = new ConcreteHandler3();
           //设置链中的阶段顺序1-->2-->3
           handler1.setNext(handler2);
           handler2.setNext(handler3);
           //提交请求，返回结果
           Response response = handler1.handlerMessage(new Request());
       }
   }
   

二、责任链模式的优点

• 将请求跟处理分开。

  请求者可以不用知道是谁处理的，处理者可以不同这道请求的全貌，两者解耦，提高系统的灵活性

三、责任链模式的缺点

• 性能问题

  每个请求都是从链头遍历到链尾，特别是在比链比较长的时候，性能会是一个非常大的问题

• 调试不方便

  当链条比较长，环节比较多时，由于采用了类似递归的方式，调试的时候逻辑可能比较复杂

注意，链接中节点数量需要控制，避免出现超长链的情况，一般的做法是在Handler中设置一个最大节点数量，在setNext中判断是否超过其阈值，以此决定是否允许该链建立