如何优化审批流（责任链模式结合建造者模式）

责任链适用于以下应用场景：
1、 多个对象可以处理同一请求，但具体由哪个对象处理则在运行时动态决定；
2、 在不明确指定接收者的情况下,向多个对象中的一个提交一个请求；
3、可动态指定一组对象处理请求。

常用实际场景：如审批流，
源码中使用责任链的场景：1、Netty中非常经典的串行化处理Pipeline就采用了责任链设计模式，2、Filter类
原始代码
用户信息

public class UserInfo {
    private String userName;
    private String roleName;
    private String phoneNum;
    private String code;
    public String getUserName() {
          return userName;
    }
    public void setUserName(String userName) {
          this.userName =userName;
    }
     public String getPhoneNum() {
           return phoneNum;
    }
     public void setPhoneNum(String phoneNum) {
          this.phoneNum =phoneNum;
    }
    public String getCode() {
          return code;
    }
    public void setCode(String code) {
        this.code =code;
    }
    public String getRoleName() {
          return roleName;
    }
     public void setRoleName(String roleName) {
          this.roleName =roleName;
    }
}

管理员登录模拟

public class LoginService {
    public void login(String phoneNum, String code){
        /***
         * 1、手机验证码校验
         */
        Boolean checkResult = codeCheck(phoneNum, code);
        if (!checkResult){
            System.out.println("手机验证码不正确！");
            return;
        }
        System.out.println("手机验证码没问题，继续执行...");
        /***
         * 2、用户是否存在
         */
        UserInfo userInfo = checkExists(phoneNum);
        if(null == userInfo){
            System.out.println("用户不存在");
            return;
        }
        System.out.println("用户存在，继续执行...");
        /***
         * 3、用户是否是管理员
         */
        if(!"管理员".equals(userInfo.getRoleName())){
            System.out.println("用户不是管理员，没有操作权限");
            return;
        }
        System.out.println("有权限操作");
    }
    private UserInfo checkExists(String phoneNum) {
        //默认存在
        UserInfo userInfo = new UserInfo();
        userInfo.setPhoneNum(phoneNum);
        userInfo.setRoleName("管理员");
        return userInfo;
    }
    private Boolean codeCheck(String phoneNum, String code) {
        if("6666".equals(code)){
            return true;
        }
        return false;
    }
}

测试

public class Test {
    public static void main(String[] args) {
        LoginService loginService = new LoginService();  loginService.login("18966669999","6666");
    }
}

执行结果：

QQ截图20200612112930.png QQ截图20200612113008.png

责任链模式优化后的代码
抽象处理者handler（定义一个请求处理的方法，并维护一个下一个处理节点Handler对象的 引用；）

public abstract class Handler {
    protected  Handler chain;
    public void next(Handler handler){
        this.chain = handler;
    }
    public abstract void doHandler(UserInfo userInfo);
}

具体处理者handler（对请求进行处理，如果不感兴趣，则进行转发。）

public class CodeCheckHandler extends Handler{
    @Override
    public void doHandler(UserInfo userInfo) {
        if (!"6666".equals(userInfo.getCode())){
            System.out.println("手机验证码不正确！");
            return;
        }
        System.out.println("手机验证码没问题，继续执行...");
        chain.doHandler(userInfo);
    }
}

public class CheckExistsHandler extends Handler{
    @Override
    public void doHandler(UserInfo userInfo) {
        //默认存在
        if(null == userInfo){
            System.out.println("用户不存在");
            return;
        }
        System.out.println("用户存在，继续执行...");
        userInfo.setRoleName("管理员");
        chain.doHandler(userInfo);
    }
}

public class AuthHandler extends Handler{
    @Override
    public void doHandler(UserInfo userInfo) {
        /***
         * 3、用户是否是管理员
         */
        if(!"管理员".equals(userInfo.getRoleName())){
            System.out.println("用户不是管理员，没有操作权限");
            return;
        }
        System.out.println("有权限操作");
    }
}

public class LoginService {
    public void login(String phoneNum, String code){
        UserInfo userInfo = new UserInfo();
        userInfo.setPhoneNum(phoneNum);
        userInfo.setCode(code);
                Handler codeCheckHandler = new CodeCheckHandler();
        Handler checkExistsHandler = new CheckExistsHandler();
        Handler authHandler = new AuthHandler();      codeCheckHandler.next(checkExistsHandler);       checkExistsHandler.next(authHandler);        codeCheckHandler.doHandler(userInfo);
    }
}

代码执行结果相同；

结合建造者模式继续优化（实现链式编程，让代码更优雅）

public abstract class Handler<E> {
    protected  Handler chain;
    public void next(Handler handler){
        this.chain = handler;
    }
    public abstract void doHandler(UserInfo userInfo);
    public static class Builder<E>{
        private Handler<E> head;
        private Handler<E> tail;
        public Builder<E> addHandler(Handler<E> handler){
            if (this.head == null){
                this.head = this.tail = handler;
                return this;
            }
            this.tail.next(handler);
            this.tail = handler;
            return this;
        }
        public Handler<E> build(){
            return this.head;
        }
    }
}

public class LoginService {
    public void login(String phoneNum, String code){
        UserInfo userInfo = new UserInfo();
        userInfo.setPhoneNum(phoneNum);
        userInfo.setCode(code);
        //链式编程
        Handler.Builder builder = new Handler.Builder();
        builder.addHandler(new CodeCheckHandler())
                .addHandler(new CheckExistsHandler())
                .addHandler(new AuthHandler());
        builder.build().doHandler(userInfo);
//        Handler codeCheckHandler = new CodeCheckHandler();
//        Handler checkExistsHandler = new CheckExistsHandler();
//        Handler authHandler = new AuthHandler();
//
//        codeCheckHandler.next(checkExistsHandler);
//        checkExistsHandler.next(authHandler);
//
//        codeCheckHandler.doHandler(userInfo);
    }
}

总结：责任链模式，符合单一职责原则，实现了解耦，客户只需将请求发送到链上即可，无需关心请求的具体内容 和处理细节，请求会自动进行传递直至有节点对象进行处理