16【责任链设计模式模式】

文章目录

• ​​十六、责任链设计模式模式​​

• ​​16.1 责任链设计模式简介​​

• ​​16.1.1 责任链设计模式概述​​
• ​​16.1.2 责任链设计模式的UML类图​​

• ​​16.2 责任链设计模式的实现​​

• ​​16.2.1 具体实现​​
• ​​16.2.2 使用建造者设计模式改造​​

• ​​16.3 责任链设计模式的优缺点​​

十六、责任链设计模式模式

16.1 责任链设计模式简介

16.1.1 责任链设计模式概述

责任链设计模式（Chain of Responsibility Pattern）：将处理一个问题分为多个步骤来分别处理，这样有利于各个功能的解耦，分出来的多个步骤称为链路节点，多个节点形成一条链路；当一个请求发送时，首先经过链路的首端处理，一直沿着链路继续往下处理；

责任链的核心在于各功能独立、解耦；

例如在公司中，我们完成某项业务操作需要多部门审批才能成功，这单独的部门就可以看做独立的链路，每个部门审批的内容不一样，这就相当于每个功能的作用不一样；当所有的部门都审批完成了，就相当于整个链路执行完毕。功能也都处理完毕了；

16.1.2 责任链设计模式的UML类图

策略设计模式中主要包含2个角色：

• 抽象处理者（Handler）：定义一个处理请求的接口，并维护一个用于处理下一个功能的节点；
• 具体处理者（Concrete Handler）：实现抽象处理者的方法

16.2 责任链设计模式的实现

16.2.1 具体实现

【案例】

我们在完成一个登录案例中，经常需要进行各种验证，例如验证码校验、用户名密码校验、权限校验等等；我们可以利用责任链来优化各个功能，将各个功能解耦到具体的节点中。各个节点相互独立；

【没有采用责任链设计模式的写法】：

package com.pattern.demo01_责任链设计模式的实现;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo01_没有采用责任链 {
    public static void main(String[] args) {
        LoginInfo loginInfo = new LoginInfo("admin", "123", "root");

        if ("".equals(loginInfo.getUsername()) || "".equals(loginInfo.getPassword())) {
            System.out.println("用户名密码为空！");
            return;
        }

        if (!"admin".equals(loginInfo.getUsername()) || !"123".equals(loginInfo.getPassword())) {
            System.out.println("用户名或密码错误！");
            return;
        }

        if ("root".equals(loginInfo.getAuthInfo())) {

            System.out.println("欢迎您！超级管理员！");
        } else {
            System.out.println("欢迎登录！普通用户！");
        }
    }
}

【使用责任链设计模式优化】

首先定义一个信息封装的实体类：

package com.pattern.demo01_责任链设计模式的实现;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class LoginInfo {
    private String username;
    private String password;
    private String authInfo;

}

• 1）定义抽象处理者（Handler）：

package com.pattern.demo01_责任链设计模式的实现;

/**
 * @author lscl
 * @version 1.0
 * @intro: 抽象处理者
 */
public abstract class Handler {

    // 包含具体的处理者
    protected Handler chain;

    public void next(Handler handler){
        this.chain=handler;
    }

    public abstract void doHandler(LoginInfo loginInfo);
}

• 2）具体处理者-1（Concrete Handler）

package com.pattern.demo01_责任链设计模式的实现;


/**
 * @author lscl
 * @version 1.0
 * @intro: 用于校验的链路节点
 */
public class ValidateHandler extends Handler {
    @Override
    public void doHandler(LoginInfo loginInfo) {
        if (!"".equals(loginInfo.getPassword()) && !"".equals(loginInfo.getUsername())) {

            System.out.println("校验成功！");
            // 继续进行下一个链路节点的执行
            chain.doHandler(loginInfo);
            return;
        }
        System.out.println("用户名或密码为空！");
    }
}

• 3）具体处理者2：

package com.pattern.demo01_责任链设计模式的实现;

/**
 * @author lscl
 * @version 1.0
 * @intro: 用于登录的链路节点
 */
public class LoginHandler extends Handler {
    @Override
    public void doHandler(LoginInfo loginInfo) {

        // 模拟去数据库中查询用户密码
        if ("admin".equals(loginInfo.getUsername()) && "123".equals(loginInfo.getPassword())) {
            System.out.println("登录成功！");

            // 继续进行下一个链路节点的执行
            chain.doHandler(loginInfo);
            return;
        }
    }
}

• 4）具体处理者3：

package com.pattern.demo01_责任链设计模式的实现;

/**
 * @author lscl
 * @version 1.0
 * @intro: 用于认证的链路节点
 */
public class AuthenticationHandler extends Handler {
    @Override
    public void doHandler(LoginInfo loginInfo) {
        String authInfo = loginInfo.getAuthInfo();

        if ("root".equals(authInfo)) {
            System.out.println("欢迎您！超级管理员！");
        } else {
            System.out.println("欢迎登录！普通用户！");
        }
    }
}

• 测试代码：

package com.pattern.demo01_责任链设计模式的实现;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public class Demo02_采用责任链设计模式 {
    public static void main(String[] args) {
        LoginInfo loginInfo = new LoginInfo("admin", "123", "root");

        Handler validateHandler=new ValidateHandler();
        Handler loginHandler=new LoginHandler();
        Handler authenticationHandler=new AuthenticationHandler();

        validateHandler.next(loginHandler);
        loginHandler.next(authenticationHandler);

        validateHandler.doHandler(loginInfo);
    }
}

• 执行结果：

16.2.2 使用建造者设计模式改造

因为责任链模式具备链式编程结构，当链式结构比较长时，使用责任链将会变得比较繁琐，对于这种情况，我们可以采用之前学习过的建造者设计模式来进行改造；

• 对抽象处理者进行改造：

package com.pattern.demo01_责任链设计模式的实现;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
public abstract class Handler {

    protected Handler chain;

    public void next(Handler handler) {
        this.chain = handler;
    }

    public abstract void doHandler(LoginInfo loginInfo);

    // 链路的建造者类
    public static class Builder {

        private Handler head;
        private Handler tail;

        public Builder addHandler(Handler handler) {

            if (this.head == null) {
                // 说明当前链路只有一个节点
                this.head = this.tail = handler;
                return this;
            }

            // 该链路存在多个节点,前面一个链路节点的next(下一个链路节点)设置为当前的handler
            this.tail.next(handler);
            
            // 将末尾的节点设置当前handler
            this.tail = handler;

            return this;
        }

        public Handler build() {
            return this.head;
        }
    }
}

16.3 责任链设计模式的优缺点

• 优点：

• 1）各功能模块的解耦
• 2）处理节点只需要关注自己感兴趣的请求即可，对于不感兴趣的请求可以直接转发给下一个节点
• 3）调用链路结构灵活，用户可以随意改变调用链路的顺序，或者对调用链路进行增减；
• 4）可以很方便的扩展新的链路，符合开闭原则

• 缺点：

• 1）如果某一个调用链路处理时间过长，那么将会影响整个链路的处理性能