设计模式十四（责任链模式）

最新推荐文章于 2024-04-24 12:10:22 发布

搬运Gong

最新推荐文章于 2024-04-24 12:10:22 发布

阅读量357

点赞数 1

分类专栏：设计模式文章标签：设计模式 chain

本文链接：https://blog.csdn.net/qq_20315217/article/details/117196409

版权

设计模式专栏收录该内容

15 篇文章 0 订阅

订阅专栏

责任链模式

定义

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

责任链在生活中的应用场景

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

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

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

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

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

责任链模式的本质是解耦请求与处理，让请求在处理链中能进行传递与被处理。

案例-利用责任链模式来进行数据校验拦截

我们经常在登录的时候，需要做一些列的数据校验来验证用户是否可以正常登录且权限是否满足等操作，代码如下：

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;
    }

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

像这种校验方式，相信很多同学都写过，那么我们使用责任链模式，来优化一下代码，如下：

/**
 * 定义责任链的抽象处理者
 */
public abstract class Handler {
	/**
	 * 内部维护好下一个执行的对象
	 */
	protected Handler next;
	
    public void next(Handler next){ this.next = next;}
	
    public abstract void doHandler(Member member);
}

定义责任链模式的具体执行者：

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 class Test {
    public static void main(String[] args) {
        MemberService memberService = new MemberService();
        memberService.login("chaogai","123456");
    }
}

结果如下：
在这里插入图片描述

案例改造-责任链模式与建造模式结合使用

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

	public abstract class Handler<T> {
    protected Handler next;
    private 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;
        }
    }
}

修改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));

        //用过Netty的人，肯定见过
    }

}

通过上面的改造，相信小伙伴们对责任链模式的理解更加深刻了，另外，通过两种模式的联合使用，可以发现，其实在实际的工作中，我们都是灵活使用设计模式来达到我们的整体设计，希望本篇文章可以帮到有需要的童鞋。

责任链模式在源码中的体现

首先来看看我们经常用到的 JDK 中的 Filter 类：
在这里插入图片描述这个 filter 接口的定义非常简单，相当于责任链模式中的抽象角色，那么它是如何形成一条责任链的呢？我们来看另外一个类，其实在 doFilter() 方法的最后一个参数我们已经看到了其类型是 FilterChain类，来看他的源码：
在这里插入图片描述
FilterChain中也定义了一个 doFilter方法，那么他们怎么串联成一个责任链呢？实际上 J2EE只是定义了规范，具体处理逻辑交由使用者自己来实现，我们来看一下spring 的实现MockFilterChain类：
它把链中的所有 filter 都放到了一个list 中，然后在调用 doFilter方法时循环迭代 list，也就说list 中的filter 会顺序执行。

责任链模式的优缺点

优点：

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

缺点：

责任链太长或者请求时间过长，会影响整体性能；
如果节点对象存在循环引用时，会造成死循环，导致系统崩溃；

搬运Gong

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
2
评论
设计模式十四（责任链模式）

责任链模式定义责任链模式，是将链中的每一个节点看做是一个对象，每个节点处理的请求均相同，且内部自动维护下一个节点对象。当一个请求，从链式的首端发出时，会沿着链的路径依次传递给每一个节点对象，直至有对象处理这个请求为止。属于行为模式。责任链在生活中的应用场景在日常生活中，责任链模式还是比较常见的，我们平时工作处理一些事务，往往是各个部门协作完成某一个任务。而每个部门都有各自的职责，因此，很多时候事情完成一半，便会转交给下一个部门，直到所有部门都过一遍之后事情才能完成（工作中的各种审批流程等）。责任链
复制链接

扫一扫