设计模式-责任链模式

责任链模式

责任链模式，是将链中每一节点看作是一个对象每个节点处理的请求均不同，且内部自动维护一个下一节点对象。当一个请求从链式的首段发出时，会沿着链的路劲依次传递给每一个节点对象，直到有对象处理这个请求为止。属于行为型模式。

角色：

抽象处理者（Handler）：定义一个处理请求的方法，并维护一个下一个处理节点Handler对象的引用；
具体处理者（ConcreteHandler）：对请求进行处理，如果不感兴趣，则进行转发。

责任链模式的本质是解耦请求和处理，让请求在处理链中进行传递和被处理。责任链模式的独到之处是将节点处理者组合成了链式结构，并允许节点自身决定是否进行请求处理或转发，相当于让请求流动了起来。

下面以登录请求进行举例，与建造者模式相结合：
先定义一个类，用来存储用户信息

package com.jdwa.chainofresposibility;

public class Member {
    private String loginName;
    private String loginPwd;
    private String roleName;

    public Member(String loginName, String loginPwd) {
        this.loginName = loginName;
        this.loginPwd = loginPwd;
    }

    public String getLoginName() {
        return loginName;
    }

    public String getLoginPwd() {
        return loginPwd;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    @Override
    public String toString() {
        return "Member{" +
                "loginName='" + loginName + '\'' +
                ", loginPwd='" + loginPwd + '\'' +
                ", roleName='" + roleName + '\'' +
                '}';
    }
}

定义抽象处理者：

package com.jdwa.chainofresposibility;

public abstract class Handler<T> {

    //链路的下一个节点
    protected Handler chain;

    //设置下一个节点
    public void next(Handler handler){
        this.chain = handler;
    }

    //当前节点处理逻辑
    public abstract void doHandler(Member member);

    //内部类，实现建造者
    public static class Builder<T> {
        private Handler<T> head;//链路头部
        private Handler<T> tail;//链路尾部

        public Builder<T> addHandler(Handler<T> handler){
            if (this.head == null){//为空
                this.head = this.tail = handler;
                return this;
            }
            this.tail.next(handler);//尾部追加,与前一个节点关联
            this.tail = handler;//设置新的尾部
            return this;
        }
        
        public Handler<T> build(){
            return this.head;
        }
    }
}

定义校验，登录，检查权限三个具体处理者，三个具体处理者均是抽象处理者的子类：
校验

package com.jdwa.chainofresposibility;

import org.springframework.util.StringUtils;

public class ValidateHandler extends Handler{
    @Override
    public void doHandler(Member member) {
        if (StringUtils.isEmpty(member.getLoginName())||StringUtils.isEmpty(member.getLoginPwd())){
            System.out.println("用户名或密码为空！");
            return;
        }
        System.out.println("用户名和密码校验成功，可以往下执行");
        chain.doHandler(member);
    }
}

登录

package com.jdwa.chainofresposibility;

public class LoginHandler extends Handler{
    @Override
    public void doHandler(Member member) {
        System.out.println("登录成功");
        member.setRoleName("admin");
        chain.doHandler(member);
    }
}

检查权限

package com.jdwa.chainofresposibility;

public class AuthHandler extends Handler{
    @Override
    public void doHandler(Member member) {
        if (!"admin".equals(member.getRoleName())){
            System.out.println("权限不足，无法操作！");
            return;
        }
        System.out.println("成功，可以查看主页");
    }
}

调用者：

package com.jdwa.chainofresposibility;

public class MemberService {
    
    public void login(String loginName,String loginPwd){
        Handler.Builder builder = new Handler.Builder();
        builder.addHandler(new ValidateHandler())
                .addHandler(new LoginHandler())
                .addHandler(new AuthHandler());
        
        builder.build().doHandler(new Member(loginName,loginPwd));
    }
}

测试：

package com.jdwa.chainofresposibility;

public class Client {
    public static void main(String[] args) {
        MemberService service = new MemberService();
        service.login("czz","123");
    }
}

结果：

用户名和密码校验成功，可以往下执行
登录成功
成功，可以查看主页

欢迎大家留言，以便于后面的人更快解决问题！另外亦欢迎大家可以关注我的微信公众号，方便利用零碎时间互相交流。共勉！