责任链模式(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].
【设计模式】之责任链模式
责任链模式(职责链模式)详解