设计模式 _第十招式_责任链模式

短命女 2022-04-06 16:44 156阅读 0赞

## 一、定义 ##

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

## 二、代码演示 ##

2.1 通用类图  
责任链模式的重点是在“链”上，由一条链去处理相似的请求在链中决定谁来处理这个请求，并返回结果。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTE4MTQ5_size_16_color_FFFFFF_t_70]  
2.3 主要类

1.  Handler“链”的抽象类
2.  ConcreteHandler，多个组成“链”  
    2.4 Handler“链”的抽象类

**
     3. @description 抽象处理者
     */
    public abstract  class Handler {
        private Handler nextHandler ;
        //每个处理者必须对请求做出处理
        public  final Response handleMessage(Request request){
            Response response = null ;
            if (this.getHandlerLevel().equals(request.requestLevel)){
                response = this.echo(request);
            }else {//不属于自己的处理级别
                   //判断是否有下一个处理者
                if(this.nextHandler !=null){
                    response = this.nextHandler.handleMessage(request);
                }else {
                    //没有适当的处理者业务执行处理
                    System.out.println("no_nextHandler undo erveyThing");
                }
            }
            return  response ;
        }
        //设置下一个处理者是谁
        public  void setNext(Handler _handler){
            this.nextHandler = _handler ;
        }
        //每个处理者都有一个处理级别
        protected abstract String getHandlerLevel();
        //每个处理者必须实现处理任务
        protected  abstract  Response echo(Request request);
    }

抽象的处理者有三个职责：

1.  定义一个请求的处理方法handleMessage，唯一对外开放的方法；
2.  定义链的编排方法setNext，设置下一个处理者；
3.  定义具体的请求者必须实现的两个方法：定义自己能够处理的级别getHandlerLevel和具体的处理任务echo；  
    2.5 具体处理者

/**
     * @description 具体处理者
     */
    public class ConcreteHandler1 extends Handler {
    
        //定义自己的处理逻辑
        @Override
        protected Response echo(Request request) {
            //完成处理逻辑
            System.out.println("ConcreteHandler1_echo doing!");
            return null;
        }
    
        //设置自己的处理级别
        @Override
        protected String getHandlerLevel(){
            //设置自己的处理级别
            return  "1";
        }
    }

/**
     * @description 具体处理者
     */
    public class ConcreteHandler2 extends Handler {
    
        //定义自己的处理逻辑
        @Override
        protected Response echo(Request request) {
            //完成处理逻辑
            System.out.println("ConcreteHandler2_echo doing!");
            return null;
        }
    
        //设置自己的处理级别
        @Override
        protected String getHandlerLevel(){
            //设置自己的处理级别
            return  "2";
        }
    }

/**
     * @description 具体处理者
     */
    public class ConcreteHandler3 extends Handler {
    
        //定义自己的处理逻辑
        @Override
        protected Response echo(Request request) {
            System.out.println("ConcreteHandler3_echo doing!");
            //完成处理逻辑
            return null;
        }
    
        //设置自己的处理级别
        @Override
        protected String getHandlerLevel(){
            //设置自己的处理级别
            return  "3";
        }
    }

2.6 模式的中框架代码

/**
     * @description 请求对象
      */
    public class Request {
        String requestLevel;
    
    
        public  Request(String level){
            this.requestLevel = level;
        }
        public String getRequestLevel() {
            return requestLevel;
        }
    
        public void setRequestLevel(String requestLevel) {
            this.requestLevel = requestLevel;
        }
    }

/**
     * @description 结果类
     */
    public class Response {
        boolean  result ;
    
        public boolean isResult() {
            return result;
        }
    
        public void setResult(boolean result) {
            this.result = result;
        }
    }

2.7 场景类

/**
     * @description 场景类
     */
    public class Client {
        public  static void main(String args[]){
            //声明所有节点
            Handler  handler1 = new ConcreteHandler1();
            Handler  handler2 = new ConcreteHandler1();
            Handler  handler3 = new ConcreteHandler1();
            //设置链条顺序 1 > 2 > 3
            handler1.setNext(handler2);
            handler2.setNext(handler3);
            //提交请求返回结果
            String level = "1";
            Response response = handler1.handleMessage(new Request(level));
        }
    }

2.8 执行结果

ConcreteHandler1_echo doing!

## 三、优点 ##

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

## 四、缺点 ##

4.1 性能问题，每个请求都是从链头遍历到链尾，特别是链比较长的时候，性能是一个非常大的问题。  
4.2 调用很不方便，特别是链条比较长的时候，由于采用了递归的方式，调用的时候逻辑可能比较复杂。

## 五、应用场景 ##

通用源代码中Handler是抽象类，融合了模版方法模式，哥个实现类只需要关注自己的业务，子类创建非常简单，创建链也比较灵活。 建在使用在入口可统一，类别比较清晰的业务中， 比如：人民币、美元、英镑 等区分业务类型。

## 六、注意事项 ##

链中地点数量需要控制，避免出现超长链的情况，一般做法是在Handler中设置一个最大节点数量，在setNext方法中判断师傅已经超过阀值，超过则不允许链建立。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2OTE4MTQ5_size_16_color_FFFFFF_t_70]: /images/20220406/cd0486233cac45969e30716f9c64732b.png