设计模式（Java）—Chain of Responsibility模式
职责链模式（Chain of Responsibility）：使多个对象都有机会处理同一个请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
示例程序
类图
Trouble类
问题生成类。
package Chain;
//问题类，通过暴露问题标号使得解决问题的类判断是否有能力处理
public class Trouble {
private int number;
public Trouble(int number) {
// TODO Auto-generated constructor stub
this.number = number;
}
public int getNumber(){
return number;
}
//重写toString方法
public String toString(){
return "[Trouble"+number+"]";
}
}
通过getNumber方法获取问题编号。
Support类
该类是用来解决问题的类。它是责任链上的对象。
package Chain;
//解决问题的抽象类
public abstract class Support {
private String name;
private Support next;
public Support(String name) {
// TODO Auto-generated constructor stub
this.name = name;
}
public String getName(){
return name;
}
//当前处理者不具备处理能力时，设置下一个处理问题的解决类
public Support setNext(Support next){
this.next = next;
return next;
}
//当前处理者解决问题的方法，要么可以解决，要么设置下一个处理者
public final void support(Trouble trouble){
if(resolve(trouble)){
done(trouble);
}else if(next!=null) {
next.support(trouble);
}else {
fail(trouble);
}
}
//具体解决问题的抽象方法，由子类实现
protected abstract boolean resolve(Trouble trouble);
protected void done(Trouble trouble){
System.out.println(trouble + " is solved by "+this.getName()+".");
}
protected void fail(Trouble trouble){
System.out.println(trouble + " cannot be resolved");
}
}
next字段中指定了要推卸给的对象，可以通过setNext方法设定。resolve是抽象方法，需要其子类实现，如果resolve返回true则表明问题已处理，如果resolve返回false则表明当前处理者处理不了，需要传递给责任链上的下一位处理者进行处理。
注：support方法调用了抽象方法resolve，因此它属于模板模式。
NoSupport类
该类是Support类的子类。
package Chain;
//该类永远不处理问题，一直将问题交给别人处理
public class NoSupport extends Support {
public NoSupport(String name) {
// TODO Auto-generated constructor stub
super(name);
}
//所以处理方法只返回false
@Override
protected boolean resolve(Trouble trouble) {
// TODO Auto-generated method stub
return false;
}
}
LimitSupport类
该类解决编号小于limit值的问题。
package Chain;
//对问题编号要求一定范围的问题进行处理
public class LimitSupport extends Support {
private int limit;
public LimitSupport(String name,int limit) {
// TODO Auto-generated constructor stub
super(name);
this.limit = limit;
}
//获取问题编号，判断问题是否可以被处理
@Override
protected boolean resolve(Trouble trouble) {
// TODO Auto-generated method stub
if(trouble.getNumber()<limit){
return true;
}else {
return false;
}
}
}
OddSupport类
解决奇数编号的问题。
package Chain;
//只能处理问题编号为奇数的问题
public class OddSupport extends Support {
public OddSupport(String name) {
// TODO Auto-generated constructor stub
super(name);
}
@Override
protected boolean resolve(Trouble trouble) {
// TODO Auto-generated method stub
if(trouble.getNumber()%2==1){
return true;
}else{
return false;
}
}
}
SpecialSupport类
解决指定编号的问题。
package Chain;
//只能处理特定编号的问题
public class SpecialSupport extends Support {
private int number;
public SpecialSupport(String name,int number) {
// TODO Auto-generated constructor stub
super(name);
this.number = number;
}
@Override
protected boolean resolve(Trouble trouble) {
// TODO Auto-generated method stub
if(trouble.getNumber() == number){
return true;
}else {
return false;
}
}
}
Main类
package Chain;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
//产生一系列处理者，并设置处理责任链
Support A = new NoSupport("A");
Support B = new LimitSupport("B", 100);
Support C = new SpecialSupport("C", 428);
Support D = new LimitSupport("D", 200);
Support E = new OddSupport("E");
Support F = new LimitSupport("F", 300);
A.setNext(B).setNext(C).setNext(D).setNext(E).setNext(F);
//产生问题，并将问题交给处理者处理，处理者依据责任链处理问题
for(int i=0;i<500;i+=33){
A.support(new Trouble(i));
}
}
}
责任链模式弱化了发出请求的人和处理请求的人之间关系，请求会在责任链中传播，直到某个具体处理类处理了该请求。
责任链模式可以使每个对象更加专注于自己的工作，即每个具体处理类对象都专注于自己所负责的处理，当自己无法处理时，具体处理类将会将问题转交给责任链的下行处理类对象，这样每个具体处理类角色就只能处理它应该负责的请求了。