设计模式之责任链模式

责任链模式:

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

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

责任链模式的应用场景:

  在日常生活中责任链模式还是比较常见的,我们平时工作处理一些事务,往往是各部门协同合作的完成某一个任务。而每个部门都有各自的职责,因此,很多时候事情完成一半,便会转交给下一个部门,直到所有部门都过一遍之后事情才能完成。

  责任链模式主要是解耦了请求与处理,客户只需将请求发送到链上即可,无需关心请求的具体内容和处理细节,请求会自动进行传递直至有节点对象进行处理。适用于以下应用场景:

  • 多个对象可以处理同一请求,但具体由哪个对象处理则在运行时动态决定;
  • 在不明确指定接收者的情况下,向多个对象中的一个提交一个请求;
  • 可动态指定一组对象处理请求。

责任链模式主要包含两种角色:

  • 抽象处理者(Handler) :定义一个请求处理的方法, 并维护一个下一个处理节点Handler对象的引用;
  • 具体处理者(Concrete Handler) :对请求进行处理, 如果不感兴趣, 则进行转发。

  责任链模式的本质是解耦请求与处理,让请求在处理链中能进行传递与被处理;理解责任链模式应当理解的是其模式(道)而不是其具体实现(术),责任链模式的独到之处是其将节点处理者组合成了链式结构,并允许节点自身决定是否进行请求处理或转发,相当于让请求流动了起来。

利用责任链模式进行数据校验拦截:

  首先, 创建一个实体类Member:

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

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

    public String getLoginName() {
        return loginName;
    }

    public void setLoginName(String loginName) {
        this.loginName = loginName;
    }

    public String getLoginPass() {
        return loginPass;
    }

    public void setLoginPass(String loginPass) {
        this.loginPass = loginPass;
    }

    public String getRoleName() {
        return roleName;
    }

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

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

  然后我们来看一段经常出现的代码:

public class MemberService {

    public void login(String loginName, String loginPass) {
        if (StringUtils.isEmpty(loginName) ||
                StringUtils.isEmpty(loginPass)) {
            System.out.println("用户名和密码为空");
            return;
        }
        System.out.println("用户名和密码不为空,可以往下执行");

        Member member = checkExists(loginName, loginPass);
        if (null == member) {
            System.out.println("用户不存在");
            return;
        }
        System.out.println("登录成功!");

        if (!"管理员".equals(member.getRoleName())) {
            System.out.println("您不是管理员,没有操作权限");
            return;
        }
        System.out.println("允许操作");

    }

    private Member checkExists(String loginName, String loginPass) {
        Member member = new Member(loginName, loginPass);
        member.setRoleName("管理员");
        return member;
    }
}

  请问各位小伙伴,你们是不是经常这么干?上面的代码中,主要功能是做了登录前的数据验证,然后,判断逻辑是有先后顺序的。首先做非空判断,然后检查账号是否有效,最终获得用户角色。然后根据用户角色所拥有的权限再匹配是否有操作权限。那么这样的检验性代码一般都是必不可少的,但是写在具体的业务代码又显得代码非常臃肿,因此我们可以用责任链模式,将这些检查步骤串联起来,而且不影响代码美观。可以使得我们在编码时可以更加专注于某一个具体的业务逻辑处理。

  下面我们用责任链模式来优化一下代码, 首先创建一个Handler类:

public abstract class Handler {
    //下一个调用链
    protected Handler next;

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

    public abstract void doHandler(Member member);

}

  然后编写链路的3种实现:

public class ValidateHandler extends Handler {

    @Override
    public void doHandler(Member member) {
        if (StringUtils.isEmpty(member.getLoginName()) ||
                StringUtils.isEmpty(member.getLoginPass())) {
            System.out.println("用户名和密码为空");
            return;
        }
        System.out.println("用户名和密码不为空,可以往下执行");
        next.doHandler(member);
    }
}
public class LoginHandler extends Handler {
    @Override
    public void doHandler(Member member) {
        System.out.println("登录成功!");
        member.setRoleName("管理员");
        next.doHandler(member);
    }
}
public class AuthHandler extends Handler {
    @Override
    public void doHandler(Member member) {
        if (!"管理员".equals(member.getRoleName())) {
            System.out.println("您不是管理员,没有操作权限");
            return;
        }
        System.out.println("允许操作");
    }
}

  接下来修改 MemberService 使他们形成一条链路:

public class MemberService {

    public void login(String loginName,String loginPass){
        Handler validateHandler = new ValidateHandler();
        Handler loginHandler = new LoginHandler();
        Handler authHandler = new AuthHandler();

        validateHandler.next(loginHandler);
        loginHandler.next(authHandler);

        validateHandler.doHandler(new Member(loginName,loginPass));

    }

    public static void main(String[] args) {
        MemberService memberService = new MemberService();
        memberService.login("wuzz","666");
    }
}

  其实我们平时使用的很多权限校验框架都是运用这样一个原理,将各个维度的权限处理解耦之后再串联起来, 各自只处理各自相关的职责。如果职责与自己不相关则抛给链上的下一个Handler, 俗称踢皮球。

责任链模式和建造者模式结合使用:

  因为责任链模式具备链式结构,而上面代码中,我们看到,负责组装链式结构的角色是 Member Service, 当链式结构较长时, Member Service的工作会非常繁琐, 并且Member Service代码相对臃肿, 且后续更改处理者或消息类型时, 都必须在Member Service中进行修改, 不符合开闭原则。产生这些问题的原因就是因为链式结构的组装过于复杂,而对于复杂结构的创建,很自然我们就会想到建造者模式, 使用建造者模式, 我们完全可以对Member Service指定的处理节点对象进行自动链式组装,客户只需指定处理节点对象,其他任何事情都无需关心,并且客户指定的处理节点对象顺序不同, 构造出来的链式结构也随之不同。我们来改造一下, 修改Handler的代码:

public abstract class Handler<T> {
    protected Handler next;

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

    public abstract void doHandler(Member member);

    public static class Builder<T> {
        private Handler<T> head;
        private Handler<T> tail;

        public Builder<T> addHandler(Handler handler) {
//            do {
            if (this.head == null) {
                this.head = this.tail = handler;
                return this;
            }
            this.tail.next(handler);
            this.tail = handler;
//            }while (false);//真正框架中,如果是双向链表,会判断是否已经到了尾部
            return this;
        }

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

    }
}

  因为建造者模式要构建的是节点处理者, 因此我们把Builder作为Handler的静态内部类, 并且因为客户端无需进行链式组装, 因此我们还可以把链式组装方法next() 方法设置为private, 使Handler更加高内聚。

  然后修改 MemberService 类:

public class MemberService {

    public void login(String loginName, String loginPass) {

        Handler.Builder builder = new Handler.Builder();

        builder.addHandler(new ValidateHandler())
                .addHandler(new LoginHandler())
                .addHandler(new AuthHandler());

        builder.build().doHandler(new Member(loginName, loginPass));

    }

    public static void main(String[] args) {
        MemberService memberService = new MemberService();
        memberService.login("wuzz", "666");
    }
}

优点:

  • 将请求与处理解耦;
  • 请求处理者(节点对象)只需关注自己感兴趣的请求进行处理即可,对于不感兴趣的请求,直接转发给下一级节点对象;
  • 具备链式传递处理请求功能,请求发送者无需知晓链路结构,只需等待请求处理结果;
  • 链路结构灵活,可以通过改变链路结构动态地新增或删减责任;
  • 易于扩展新的请求处理类(节点),符合开闭原则。

缺点:

  • 责任链太长或者处理时间过长,会影响整体性能
  • 如果节点对象存在循环引用时,会造成死循环,导致系统崩溃;
发布了159 篇原创文章 · 获赞 23 · 访问量 10万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 书香水墨 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览