设计模式（十四）Chain of Responsibility模式

　　Chain of Responsibility模式就是当外部请求程序进行某个处理，但程序暂时无法直接决定由哪个对象负责处理时，就需要推卸责任。也就是说，当一个人被要求做什么事时，如果他可以做就自己做，如果不能做就转给下一个人，以此类推。

　　下面是示例程序的类图。

　　

　　下面是示例程序代码。

package bigjunoba.bjtu.handler;

public class Trouble {

    private int number;

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

    public int getNumber() {
        return number;
    }
    
    public String toString() {
        return "[Trouble " + number + "]"; 
    }
    
}

　　Trouble类是表示发生的问题的类，number作为问题编号，通过getNumber方法得到问题编号。

package bigjunoba.bjtu.handler;

public abstract class Support {

    private String name;
    private Support next;
    
    public Support(String name) {
        super();
        this.name = 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);
        }
    }
    
    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 resolved.");
    }
    
}

　　Support类是用来解决问题的抽象类，它是职责链上的对象。next字段保存了要推卸给的对象，即Support类的实例，可以通过setNext方法设定该对象。resolve方法如果返回true，则表示问题已经被处理，如果返回false，则表示问题还没有被处理。support方法调用resolve方法，如果解决了问题，那么就调用done方法，如果否则将问题交给下一个对象，如果到最后一个对象仍然没有人处理，那么就调用fail方法。这里注意的是support方法调用抽象resolve方法，这属于Template Method模式。

package bigjunoba.bjtu.concretehandler;

import bigjunoba.bjtu.handler.Support;
import bigjunoba.bjtu.handler.Trouble;

public class NoSupport extends Support{

    public NoSupport(String name) {
        super(name);
    }

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

package bigjunoba.bjtu.concretehandler;

import bigjunoba.bjtu.handler.Support;
import bigjunoba.bjtu.handler.Trouble;

public class OddSupport extends Support {

    public OddSupport(String name) {
        super(name);
    }

    @Override
    protected boolean resolve(Trouble trouble) {
        if (trouble.getNumber() % 2 == 1) {
            return true;
        } else {
            return false;
        }
    }
    
}

package bigjunoba.bjtu.concretehandler;

import bigjunoba.bjtu.handler.Support;
import bigjunoba.bjtu.handler.Trouble;

public class SpecilaSupport extends Support{

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

    @Override
    protected boolean resolve(Trouble trouble) {
        if (trouble.getNumber() == number) {
            return true;
        } else {
            return false;
        }
    }
}

package bigjunoba.bjtu.concretehandler;

import bigjunoba.bjtu.handler.Support;
import bigjunoba.bjtu.handler.Trouble;

public class LimitSupport extends Support{
    
    private int limit;

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

    @Override
    protected boolean resolve(Trouble trouble) {
        if (trouble.getNumber() < limit) {
            return true;
        } else {
            return false;
        }
    }
    
}

　　这四种类Support类的子类不难理解。NoSupport类永远不解决问题；LimitSupport类只解决编号小于limit值的问题；OddSupport类只解决奇数编号问题；SpecialSupport类只解决特定编号的问题。

package bigjunoba.bjtu.test;

import bigjunoba.bjtu.concretehandler.LimitSupport;
import bigjunoba.bjtu.concretehandler.NoSupport;
import bigjunoba.bjtu.concretehandler.OddSupport;
import bigjunoba.bjtu.concretehandler.SpecilaSupport;
import bigjunoba.bjtu.handler.Support;
import bigjunoba.bjtu.handler.Trouble;

public class Main {

    public static void main(String[] args) {
        Support lian1 = new NoSupport("LianOne");
        Support lian2 = new LimitSupport("LianTwo", 100);
        Support lian3 = new SpecilaSupport("LianThree", 429);
        Support lian4 = new LimitSupport("LianFour", 200);
        Support lian5 = new OddSupport("LianFive");
        Support lian6 = new LimitSupport("LianSix", 300);
        //形成职责链
        lian1.setNext(lian2).setNext(lian3).setNext(lian4).setNext(lian5).setNext(lian6);
        //制造各种问题
        for (int i = 0; i < 500; i += 33) {
            lian1.support(new Trouble(i));
        }
    }
    
}

　　Main类首先生成了6个解决问题的实例，虽然都是Support类型的，但实际上由于Support类是抽象类，因此这些实例分别是四个不同的子类的实例。然后形成了职责链，接着制造问题进行处理。

[Trouble 0] is resolved by [LianTwo].
[Trouble 33] is resolved by [LianTwo].
[Trouble 66] is resolved by [LianTwo].
[Trouble 99] is resolved by [LianTwo].
[Trouble 132] is resolved by [LianFour].
[Trouble 165] is resolved by [LianFour].
[Trouble 198] is resolved by [LianFour].
[Trouble 231] is resolved by [LianFive].
[Trouble 264] is resolved by [LianSix].
[Trouble 297] is resolved by [LianFive].
[Trouble 330] cannot be resolved.
[Trouble 363] is resolved by [LianFive].
[Trouble 396] cannot be resolved.
[Trouble 429] is resolved by [LianThree].
[Trouble 462] cannot be resolved.
[Trouble 495] is resolved by [LianFive].

 　　根据输出结果来举一个例子具体分析一下这个过程。假设问题编号是429，那么可以这样来分析，首先创建了一个Trouble实例，并且把问题编号number设置为429，然后这个429问题实例传递给support方法，并用lian1来调用这个方法。主要分析的是调用方法的过程：先调用NoSupport类的resolve方法，结果返回false，然后next字段保存的是lian2，不为空，因此要执行lian2的support方法...以此类推，最后发现lian1，2都解决不了，最后交给了3，3可以解决，程序结束。这里的思想是用到了递归。

　　有一个时序图也可以用来帮助理解。

　　下面是Chain of Responsibility模式的类图。

 　　这里对类图不做过多解释，通过示例程序对这一模式理解应该很到位。