责任链模式

设计模式-责任链模式

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

算法结构

如上图，AbstractHandler定义了抽象方法handle()，具体的handle()业务逻辑交给子类HandlerA、HandlerB、HandlerC去实现，在AbstractHandler中的next字段可以将具体的Handler链接成一条链，具体的请求经过这条链可以得到相应的处理。

算法举例

模拟柜台处理问题，咨询业务有几个柜台，每个柜台只能处理特定编号的问题，如果处理不了则转向下一个柜台

涉及类的关系可以表示如下：

首先定义问题类

public class Trouble {
    private int number;

    public Trouble(int number) {
        this.number = number;
    }

    public int getNumber() {
        return number;
    }

    @Override
    public String toString() {
        return "[Trouble- " + number + "]";
    }
}

接着，定义一个抽像的业务处理支持类AbstractSupport

public abstract class AbstractSupport {
    /**
     * 支持人名
     */
    private String name;
    /**
     * 下一个支持的柜员
     */
    private AbstractSupport next;

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

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

    public 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 + " can't be resolved by " + this + ".");
    }

    public final void support(Trouble trouble) {
        if (resolve(trouble)) { // 解决问题
            done(trouble); // 完结
        } else if (next != null) { // 该柜员无法解决
            next.support(trouble); // 下一个柜员处理
        } else { // 问题解决不了
            fail(trouble); 
        }
    }

    @Override
    public String toString() {
        return "[" + name + "]";
    }

}

继承该抽象类，增加几个柜台

（1）、有限编号范围处理柜台

public class LimitSupport extends AbstractSupport {
    private int limit;

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

    @Override
    public boolean resolve(Trouble trouble) {
        return trouble.getNumber() < limit;
    }
}

（2）、特定编号问题处理柜台

public class SpecialSupport extends AbstractSupport {
    private int number;

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

    @Override
    public boolean resolve(Trouble trouble) {
        return trouble.getNumber() == number;
    }
}

（3）、奇数问题处理柜台

public class OddSupport extends AbstractSupport {
    public OddSupport(String name) {
        super(name);
    }

    @Override
    public boolean resolve(Trouble trouble) {
        return trouble.getNumber() % 2 == 1;
    }
}

（4）、不处理任何问题的柜台

public class NoSupport extends AbstractSupport {
    public NoSupport(String name) {
        super(name);
    }

    @Override
    public boolean resolve(Trouble trouble) {
        return false;
    }
}

定义客户端，将柜台链接成处理链

public class Chain {
    public static void main(String[] args) {
        AbstractSupport alice = new NoSupport("Alice");
        AbstractSupport bob = new LimitSupport("Bob", 3);
        AbstractSupport charlie = new SpecialSupport("Charlie", 5);
        AbstractSupport diana = new LimitSupport("Diana", 8);
        AbstractSupport elmo = new OddSupport("Elmo");
        AbstractSupport fred = new LimitSupport("Fred", 10);
        alice.setNext(bob).setNext(charlie).setNext(diana).setNext(elmo).setNext(fred);
        for (int i = 0; i < 20; i++) {
            alice.support(new Trouble(i));
        }
    }
}

运行结果：

[Trouble- 0] is resolved by [Bob].
[Trouble- 1] is resolved by [Bob].
[Trouble- 2] is resolved by [Bob].
[Trouble- 3] is resolved by [Diana].
[Trouble- 4] is resolved by [Diana].
[Trouble- 5] is resolved by [Charlie].
[Trouble- 6] is resolved by [Diana].
[Trouble- 7] is resolved by [Diana].
[Trouble- 8] is resolved by [Fred].
[Trouble- 9] is resolved by [Elmo].
[Trouble- 10] can't be resolved by [Fred].
[Trouble- 11] is resolved by [Elmo].
[Trouble- 12] can't be resolved by [Fred].
[Trouble- 13] is resolved by [Elmo].
[Trouble- 14] can't be resolved by [Fred].

相关参考

【设计模式】之责任链模式
责任链模式（职责链模式）详解