设计模式-责任链模式

定义
责任链模式(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 语句的时候做一些操作
    ● 有多个对象可以处理同一个请求，具体哪个对象处理该请求待运行时刻再确定，客户端只需将请求提交到链上，而无须关心请求的处理对象是谁以及它是如何处理的
    ● 在不明确指定接收者的情况下，向多个对象中的一个提交一个请求
    ● 可动态指定一组对象处理请求，客户端可以动态创建职责链来处理请求，还可以改变链中处理者之间的先后次序

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