设计模式-责任链模式

发布于 2022-8-5 17:42
浏览
0收藏

定义
责任链模式(Chain of Responsibility Pattern):避免请求发送者与接收者耦合在一起,让多个对象都有可能接收请求,将这些对象连接成一条链,并且沿着这条链传递请求,直到有对象处理它为止。职责链模式是一种对象行为型模式。

用通俗的话就是推卸责任某件事,我们去解决,找到A,结果A踢皮球,说这不关我的事,去找B解决,然后我们就去找B,结果B也说,这跟我没关系,快去找C,就这样,我们就被踢来踢去,这就是责任链模式的思想。

 

角色
Handler(抽象处理者):它定义了处理请求的接口、一般设计成抽象类,持有一个处理器的引用,如果自己无法处理请求,则转给下一个处理器。因此在抽象处理者中定义了一个抽象处理者类型的对象,作为其对下家的引用。通过该引用,处理者可以连成一条链。

ConcreteHandler(具体处理者):它是抽象处理者的子类,可以处理用户请求,在具体处理者类中实现了抽象处理者中定义的抽象请求处理方法,在处理请求之前需要进行判断,看是否有相应的处理权限,如果可以处理请求就处理它,否则将请求转发给后继者;在具体处理者中可以访问链中下一个对象,以便请求的转发。

 

纯责任链模式
 ● 一个具体处理对象只能选择选择其中一个处理器:要么承担全部责任,要么把处理责任推给下家,不允许出现某个处理器处理了部分又继续向下传递。
 ● 一个请求必须被某一个处理者对象所接收,不能出现某个请求未被任何一个处理者对象处理的情况


 不纯的责任链模式
 ● 允许某个请求被一个具体处理器处理后再向下传递
 ● 一个具体处理器处理完某请求后还可以继续处理该请求。
 ● 一个请求最终可以不被任何处理器所处理。


代码示例
纯责任链模式
现在模拟一个场景请求,当数字符合奇数、指定数字、某个下限等可处理,否则就处理失败。

首先我们定义抽象处理器,以及处理方法模板,定义了当前请求哪些可以处理,不能处理就转给next。

package com.zero.headfirst.chain.support;

import java.util.Objects;

/**
 * 抽象处理器:定义了抽象请求处理方法,持有一个抽象处理器的引用,用于生成一条处理链
 */
publicabstractclass AbstractSupport {
    private String name;
    private AbstractSupport next;

    /**
     * 定义处理请求的算法模板
     */
    public final void process(NumberData numberData) {
        if (resolve(numberData)) {
            done(numberData);
        } elseif (Objects.nonNull(next)) {
            next.process(numberData);
        } else {
            fail(numberData);
        }
    }

    /**
     * 无法处理
     * @param numberData
     */
    protected  void fail(NumberData numberData) {
        System.out.println(numberData + " cannot be resolved.");
    }

    /**
     * 成功处理
     * @param numberData
     */
    protected void done(NumberData numberData) {
        System.out.println(numberData + " is resolved by " + this + ".");
    }

    /**
     * 判断是否能处理,子类重写
     * @param numberData
     * @return
     */
    protected abstract boolean resolve(NumberData numberData);

    public AbstractSupport setNext(AbstractSupport next) {
        this.next = next;
        return next;
    }

    public AbstractSupport(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return"AbstractSupport{" +
                "name='" + name + '\'' +
                '}';
    }
}

然后定义我们的具体处理器,NoSupport 是一个永远不解决,只管推卸责任的类。

package com.zero.headfirst.chain.support;

/**
 * 永远不解决,返回false
 */
publicclass NoSupport extends AbstractSupport {
    public NoSupport(String name) {
        super(name);
    }

    @Override
    protected boolean resolve(NumberData numberData) {
        returnfalse;
    }
}

LimitSupport 解决指定范围的请求

package com.zero.headfirst.chain.support;

/**
 * 解决指定区间
 */
publicclass LimitSupport extends AbstractSupport {

    private Integer limit;

    public LimitSupport(String name, Integer limit) {
        super(name);
        this.limit = limit;
    }

    @Override
    protected boolean resolve(NumberData numberData) {
        return numberData.getNumber() < limit;
    }
}

OddSupport 类,解决奇数的问题

package com.zero.headfirst.chain.support;

/**
 * 奇数处理
 */
publicclass OddSupport extends AbstractSupport {
    public OddSupport(String name) {
        super(name);
    }

    @Override
    protected boolean resolve(NumberData numberData) {
        return numberData.getNumber() % 2 == 1;
    }
}

SpecialSupport 指定数字处理器

package com.zero.headfirst.chain.support;

/**
 * 指定数字特殊处理
 */
publicclass SpecialSupport extends AbstractSupport {
   private Integer number;

    public SpecialSupport(String name, Integer number) {
        super(name);
        this.number = number;
    }

    @Override
    protected boolean resolve(NumberData numberData) {
        return numberData.getNumber().equals(number);
    }
}

最后我们定义一个客户端去组装我们的责任链,将所有的处理器连在一起,并且模拟请求

package com.zero.headfirst.chain.support;

publicclass ChainTest {
    public static void main(String[] args) {
        AbstractSupport alice = new NoSupport("Alice");
        AbstractSupport jams = new OddSupport("jams");
        AbstractSupport bob = new LimitSupport("Bob", 100);
        AbstractSupport charlie = new SpecialSupport("Charlie", 429);

        //定义责任链
        alice.setNext(jams).setNext(bob).setNext(charlie);
        for (int i = 0; i < 500; i += 33) {
            alice.process(new NumberData(i));
        }
    }
}

我们的打印结果:除了我们定义处理器能处理的数字可以处理完成,其他数字无法处理。

NumberData{number=0} is resolved by AbstractSupport{name='Bob'}.
NumberData{number=33} is resolved by AbstractSupport{name='jams'}.
NumberData{number=66} is resolved by AbstractSupport{name='Bob'}.
NumberData{number=99} is resolved by AbstractSupport{name='jams'}.
NumberData{number=132} cannot be resolved.
NumberData{number=165} is resolved by AbstractSupport{name='jams'}.
NumberData{number=198} cannot be resolved.
NumberData{number=231} is resolved by AbstractSupport{name='jams'}.
NumberData{number=264} cannot be resolved.
NumberData{number=297} is resolved by AbstractSupport{name='jams'}.
NumberData{number=330} cannot be resolved.
NumberData{number=363} is resolved by AbstractSupport{name='jams'}.
NumberData{number=396} cannot be resolved.
NumberData{number=429} is resolved by AbstractSupport{name='jams'}.
NumberData{number=462} cannot be resolved.
NumberData{number=495} is resolved by AbstractSupport{name='jams'}.

不纯的责任链模式
比如说公司请假需要审批,举个不恰当的例子,如果请假小于3天,主管审批;4-10天的, 经理审批;11-30天的,总经理审批;超过30天的,不批准等等。这就得一步步去判断, 如果撇开设计模式不看的话,那么我们可以使用if…else…把它解决了,但是问题可想而知, 实际中的复杂程度远远超过这个例子的。

现在我们用责任链设计模式解决,将每种角色连接起来处理请假数据流。

 

抽象处理器

package com.zero.design.actions.dutychain;

/**
 * 责任链抽象类,包含核心处理方法,以及后继责任处理器设置.由不同的处理器继承
 */
publicabstractclass AbstractLeaderHandler {

    protected String handlerName;

    /**
     * 责任链上的后继对象,即这个对象无法处理,就转移给下一个Leader
     */
    protected AbstractLeaderHandler nextLeaderHandler;

    public AbstractLeaderHandler(String handlerName) {
        this.handlerName = handlerName;
    }

    /**
     * 处理请求的核心的业务方法
     * 需要不同继承该类的处理器自己实现
     * @param request
     */
    public abstract void handleRequest(LeaveRequest request);

    /**
     * 设定责任链上的后继对象
     * @param nextLeaderHandler
     */
    public AbstractLeaderHandler setNextLeaderHandler(AbstractLeaderHandler nextLeaderHandler) {
        this.nextLeaderHandler = nextLeaderHandler;
        return nextLeaderHandler;
    }
}

具体处理器-主任处理器
负责处理 3 天以下的假期,大于三天的递交给主管

package com.zero.design.actions.dutychain;

/**
 * 主任处理器,继承抽象处理器接口,处理相应业务或设置下一个处理器
 */
publicclass DirectorHandler extends AbstractLeaderHandler {


    public DirectorHandler(String handlerName) {
        super(handlerName);
    }

    @Override
    public void handleRequest(LeaveRequest request) {
        int days = request.getLeaveDays(); //获取请假天数
        String name = request.getName(); //获取请假人姓名
        String reason = request.getReason(); // 获取请假理由

        if (days <= 3) {
            //如果满足3天内的要求,主任直接审批
            System.out.println("员工" + name + "请假" + days + "天,理由:" + reason);
            System.out.println("主任" + this.handlerName + "审批通过");
        } else {
            System.out.println("请假天数过多,主任" + this.handlerName + "处理结束,还要交给经理处理");
            if(this.nextLeaderHandler != null) {
                //否则,如果链上存在下一个Leader,就让他处理
                this.nextLeaderHandler.handleRequest(request);
            }
        }
    }
}

经理处理器
处理小于10天的假期,大于10则递交给总办

package com.zero.design.actions.dutychain;

/**
 * 经理处理器
 */
publicclass ManagerHandler extends AbstractLeaderHandler {

    public ManagerHandler(String handlerName) {
        super(handlerName);
    }

    @Override
    public void handleRequest(LeaveRequest request) {
        int days = request.getLeaveDays(); //获取请假天数
        String name = request.getName(); //获取请假人姓名
        String reason = request.getReason(); // 获取请假理由

        if(days <= 10) { //如果满足10天内的要求,经理直接审批
            System.out.println("员工" + name + "请假" + days + "天,理由:" + reason);
            System.out.println("经理" + this.handlerName + "审批通过");
        } else {
            System.out.println("请假天数过多,经理" + this.handlerName + "处理结束,交给总办处理");
            if(this.nextLeaderHandler != null) { //否则,如果链上存在下一个Leader,就让他处理
                this.nextLeaderHandler.handleRequest(request);
            }
        }
    }
}

总办处理器
处理大于 10 天假期的请求

package com.zero.design.actions.dutychain;

/**
 * 总办处理器
 */
publicclass GeneralManagerHandler extends AbstractLeaderHandler {

    public GeneralManagerHandler(String handlerName) {
        super(handlerName);
    }

    @Override
    public void handleRequest(LeaveRequest request) {
        int days = request.getLeaveDays(); //获取请假天数
        String name = request.getName(); //获取请假人姓名
        String reason = request.getReason(); // 获取请假理由

        if(days <= 30) { //如果满足10天内的要求,经理直接审批
            System.out.println("员工" + name + "请假" + days + "天,理由:" + reason);
            System.out.println("总办" + this.handlerName + "审批通过");
        } else {
            System.out.println("请假天数过多,总办" + this.handlerName + "没法处理");
            if(this.nextLeaderHandler != null) { //否则,如果链上存在下一个Leader,就让他处理
                this.nextLeaderHandler.handleRequest(request);
            } else {
                System.out.println("请假不成功");
            }
        }
    }
}

客户端角色
声明一条处理链,模拟请假数据流

package com.zero.design.actions.dutychain;

/**
 * 模拟请求:
 * 他们处理请求的条件是不同的,而且只要不是自己处理范围之内的,就会将请求传给链上的下一位来处理
 */
publicclass Client {

    public static void main(String[] args) {
        //初始化责任链,应该使用单例
        AbstractLeaderHandler directorHandler = new DirectorHandler("张胜男");
        AbstractLeaderHandler managerHandler = new ManagerHandler("李四");
        AbstractLeaderHandler generalManagerHndler = new GeneralManagerHandler("赵王");

        //组织好责任对象关系
        directorHandler.setNextLeaderHandler(managerHandler).setNextLeaderHandler(generalManagerHndler);
        //开始请假操作
        LeaveRequest request = new LeaveRequest("倪升武", 15, "在家睡觉");
        directorHandler.handleRequest(request);
    }
}

最后我们看打印结果

请假天数过多,主任张胜男处理结束,还要交给经理处理
请假天数过多,经理李四处理结束,交给总办处理
员工倪升武请假15天,理由:在家睡觉
总办赵王审批通过

总结
责任链模式的优点
 ● 对象仅需知道该请求会被处理即可,且链中的对象不需要知道链的结构,由客户端负责链的创建,降低了系统的耦合度
 ● 请求处理对象仅需维持一个指向其后继者的引用,而不需要维持它对所有的候选处理者的引用,可简化对象的相互连接
 ● 在给对象分派职责时,职责链可以给我们更多的灵活性,可以在运行时对该链进行动态的增删改,改变处理一个请求的职责
 ● 新增一个新的具体请求处理者时无须修改原有代码,只需要在客户端重新建链即可,符合 "开闭原则"


缺点
 ● 一个请求可能因职责链没有被正确配置而得不到处理
 ● 对于比较长的职责链,请求的处理可能涉及到多个处理对象,系统性能将受到一定影响,且不方便调试
 ● 可能因为职责链创建不当,造成循环调用,导致系统陷入死循环


使用场景

  1. Netty 中的 Pipeline 和 ChannelHandler 通过责任链设计模式来组织代码逻辑
  2. Tomcat 过滤器中的责任链模式。
  3. Mybatis 中的 Plugin 机制使用了责任链模式,配置各种官方或者自定义的 Plugin,与 Filter 类似,可以在执行 Sql 语句的时候做一些操作
     ● 有多个对象可以处理同一个请求,具体哪个对象处理该请求待运行时刻再确定,客户端只需将请求提交到链上,而无须关心请求的处理对象是谁以及它是如何处理的
     ● 在不明确指定接收者的情况下,向多个对象中的一个提交一个请求
     ● 可动态指定一组对象处理请求,客户端可以动态创建职责链来处理请求,还可以改变链中处理者之间的先后次序

 

 

 

 

文章转载自公众号:码哥字节

已于2022-8-5 17:42:56修改
收藏
回复
举报
回复
添加资源
添加资源将有机会获得更多曝光,你也可以直接关联已上传资源 去关联
    相关推荐