责任链模式

责任链模式

定义

责任链模式是将链中每一个节点看做是一个对象，每个节点处理的请求均不同，且内部自动维护一个下一节点对象。当请求从链式的首端发出时，会沿着链的路径一次传递给每一个节点对象，知道没有对象处理为止。

//所有的责任链节点共有接口
public abstract class AbstractHandler<T> {
    protected AbstractHandler handler;
​
    private void next(AbstractHandler handler) {
        this.handler = handler;
    }
​
​
    abstract void doHandle(T t);
    //通过内部类builder来构建一个单向链表 也可以单独抽取出一个builder类，
    public static class Builder<T>{
        AbstractHandler<T> head = null;
        AbstractHandler<T> tail = null;
        public Builder addHandler(AbstractHandler<T> handler) {
            if(head==null) {
                head=tail=handler;
            }
            tail.next(handler);
            tail=handler;
            //这是构造器模式的一种体现，处理完操作然后返回自己，便于链式编程，快速构建对象
            return this;
        }
​
        public AbstractHandler<T> build(){
            return head;
        }
    }
}
//需要链式处理的对象
public class Member {
    private String name;
    private String password;
    private String roleName;
​
    public Member(String name, String password, String roleName) {
        this.name = name;
        this.password = password;
        this.roleName = roleName;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public String getPassword() {
        return password;
    }
​
    public void setPassword(String password) {
        this.password = password;
    }
​
    public String getRoleName() {
        return roleName;
    }
​
    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }
}
//验证参数的处理类
public class ValidateHandler extends AbstractHandler<Member> {
​
    @Override
    void doHandle(Member member) {
        if(member.getName() == null || "".equals(member.getName())) {
            System.out.println("用户名为空"); ;
            return;
        }
        if(handler!=null){
            //处理的结果可以通过方法形参传递给下一个handler，我们这里简单起见，处理结果就是member本身
            handler.doHandle(member);
        }
    }
}
//登录处理类
public class LoginHandler extends AbstractHandler<Member>{
    @Override
    void doHandle(Member member) {
        if("123".equals(member.getPassword())) {
            System.out.println("登录成功");
            member.setRoleName("admin");
            handler.doHandle(member);
        }
        if(handler!=null) {
            handler.doHandle(member);
        }
    }
}
//授权管理类
public class AuthorizationHandler extends AbstractHandler<Member>{
    @Override
    void doHandle(Member member) {
        if("admin".equals(member.getRoleName())) {
            System.out.println("你是管理员，放行");
        }else{
            System.out.println("你不是管理员没有权限操作");
        }
    }
}

优缺点

优点：

• 请求 和 处理实现解耦

• 每一个节点只负责处理自己的内容，然后交给下一个节点处理，满足开闭原则，便于扩展

• 链式编程风格，代码简洁，清晰

• 可以对节点进行灵活组装 新增 换位 删除节点都比较方便

缺点

• 如果链路过长，会影响程序的执行速度

• 如果存在节点循环引用 会导致程序死循环