十四、 Chain of Responsibility 模式 —— 推卸责任

Author：Gorit
Date：2021年11月8日
Refer：《图解设计模式》

14.1 Chain of Responsibility

“推卸责任” 这个词句听起来像是贬义词，但是有的时候确实需要“推卸责任”的情况。

举个例子：
当外部程序进行某项处理时，但内部程序暂时不知道由哪个对象负责处理，就需要推卸责任。

这样的话：

我们可以考虑 将多个对象组成一条职责链，然后按照它们在职责链上的顺序一个一个地找出到底应该由谁来负责处理

“责任链模式”可以弱化 “请求方”和 “处理方”之间的关联关系，让双方都可以成为可独立复用的组件。此外，程序还可以处理其他需求，如根据情况不同，负责处理的对象也会发生变化的这种需求

换个比较形象的说法：

当一个人被要求做什么事情呢，如果他自己做就自己做，如果不能做就将“要求”转给另一个人。下一个人要么自己做，要么不能做也同样给下一个人处理，这就是 “责任链模式”

14.2 示例程序

Trouble 类

package Responsibility;
/**
 * @Author Gorit
 * @Date 2021年11月9日
 * Border 和 Display 具有相同的属性和方法
 * display 代表被装饰物，也有可能是其他装饰物的边框
 **/
public class Trouble {
    private int number;     // 问题编号
    public Trouble(int number) {    // 生成问题
        this.number = number;
    }
    public int getNumber() {      // 获取问题编号
        return number;
    }
    public String toString() {      // 代表问题字符串
        return "{Trouble " + number + "}";
    }
}

Support 类

package Responsibility;
/**
 * @Author Gorit
 * @Date 2021/11/15
 * 用来解决问题的抽象类，它是职责链上的对象
 * next     字段中指定了要推卸给的对象，可以通过 setNext 方法设定该对象
 * resolve  该方法需要子类去实现的抽象方法。 resolve 返回 true 则表示被处理，反之
 * support  该方法会调用 resolve 方法，如果 resolve 方法返回 false，则 support 方法会将问题转交给下一个对象
 **/
public abstract class Support {
    private String name;    // 解决问题实例的名字
    private Support next;    // 要推卸给的对象, 类似于链表结构
    public Support(String name) {   // 生成问题的实例
        this.name = name;
    }
    public Support setNext(Support next) {      // 设置要推卸给的对象, 链式调用
        this.next = next;
        return next;
    }
    public final void support(Trouble trouble) {    // 解决问题的步骤
        if (resolve(trouble)) {     //      属于 Template Method
            done(trouble);
        } else if (next != null) {
            next.support(trouble);
        } else {
            fail(trouble);
        }
    }
    @Override
    public String toString() {      // 显示字符串
        return "{" + name +"}";
    }
    protected abstract boolean resolve(Trouble trouble);    // 解决问题的方法
    protected void done(Trouble trouble) {      // 解决
        System.out.println(trouble + " is resolved by " + this + ".");
    }
    protected void fail(Trouble trouble) {
        System.out.println(trouble + " cannot be resoled.");
    }
}

NotSupport

package Responsibility;
/**
 * @Author Gorit
 * @Date 2021/11/15
 * Support 的子类
 * 永不解决的类
 **/
public class NotSupport extends Support {
    public NotSupport(String name) {
        super(name);
    }
    protected boolean resolve(Trouble trouble) {    // 永远不解决
        return false;
    }
}

LimitSupport

package Responsibility;
/**
 * @Author Gorit
 * @Date 2021/11/15
 * 解决编号小于 limit 的问题
 * resolve 方法在判断编号小于 limit 值之后，只是返回 true，但实际上这里应该是解决问题的代码
 **/
public class LimitSupport extends Support {
    private int limit;
    public LimitSupport(String name, int limit) {
        super(name);
        this.limit = limit;
    }
    protected boolean resolve(Trouble trouble) {    // 解决问题的方法
        if (trouble.getNumber() < limit) {
            return true;
        } else {
            return false;
        }
    }
}

OddSupport

package Responsibility;
/**
 * @Author Gorit
 * @Date 2021/11/15
 * 解决奇数编号问题
 **/
public class OddSupport extends Support {
    public OddSupport(String name) {
        super(name);
    }
    protected boolean resolve(Trouble trouble) {
        if (trouble.getNumber() % 2 == 0) {
            return true;
        }
        return false;
    }
}

SpecialSupport

package Responsibility;
/**
 * @Author Gorit
 * @Date 2021/11/15
 * 只解决指定编号问题
 **/
public class SpecilSupport extends Support {
    private int number;
    public SpecilSupport(String name, int number) {     // 只能解决指定编号的问题
        super(name);
        this.number = number;
    }
    protected boolean resolve(Trouble trouble) {
        if (trouble.getNumber() == number) {
            return true;
        }
        return false;
    }
}

Main

package Responsibility;
/**
 * @Author Gorit
 * @Date 2021/11/15
 **/
public class Main {
    public static void main(String[] args) {
        Support alice = new NotSupport("Alice");
        Support bob = new LimitSupport("Bob", 100);
        Support charlie = new SpecilSupport("Charlie", 429);
        Support diana = new LimitSupport("Diana", 200);
        Support elmo = new OddSupport("elmo");
        Support fred = new LimitSupport("fred", 300);
        // 形成责任链
        alice.setNext(bob).setNext(charlie).setNext(diana).setNext(elmo).setNext(fred);
        for (int i = 0; i < 500; i += 33) {
            alice.support(new Trouble(i));
        }
    }
}

14.3 Chain of Responsibility 模式中登场的角色

一、Handler（处理者）

Handler 角色定义了处理请求的接口（API）。Handler 角色知道“下一个处理者”是谁，若自己无法处理请求，则将请求转给“下一个请求者”。然后依次类推，在本节中，Support 类扮演此角色。负责请求的是 Support 方法

二、ConcreateHandler（具体的处理者）

示例程序中：

• NotSupport
• LimitSupport
• OddSupport
• SpecialSupport

扮演此角色

三、Client 角色（请求者）

Client 角色是向第一个 ConcreateHandler 角色发送请求的角色。示例程序中由 Main 扮演此角色