Java设计模式之-责任链模式（Chain of Respons

责任链算是比较简单的一种模式，它需要做到两点：

1. 请求者和响应者的分离，请求只要发出即可，不需要制定具体由谁相应；
2. 多个潜在响应者排成链状尝试对请求进行处理；

这一条链则成为了我们所说的责任链，请求在链上流动，当该请求与链上某个节点匹配时，该节点即会做出处理。我们可以拿在机场取行李来举例，说明应该如何实现这一模式。

我们先定义一个抽象的Traveller类，来表示需要拿行李的旅行者。我们用setNext来将一个个旅行者连接起来，作为责任链处理行李箱。然后依次调用每个旅行者的tryTakeBag方法尝试拿走这个包。而isMine方法由每一个实现类来定义，表示如何确定是自己的旅行箱：

public abstract class AbstractTraveller {

    private String name;
    private AbstractTraveller nextItem;

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

    public AbstractTraveller setNext(AbstractTraveller t) {
        nextItem = t;
        return nextItem;
    }

    public boolean tryTakeBag(AbstractBag bag) {
        if (isMine(bag) == true) {
            return true;
        } else {
            if (nextItem != null) {
                return nextItem.tryTakeBag(bag);
            } else {
                return false;
            }
        }
    }

    public String getName() {
        return name;
    }

    public abstract boolean isMine(AbstractBag bag);
}

然后我们来定义三个旅行者，请注意，他们需要拿的不是一个箱子，而是一类箱子。具体是哪一类，他们在格子的isMine方法中定义了：

// 只拿编号为1、2、3的箱子
public class Traveller1to3 extends AbstractTraveller {
    public Traveller1to3(String name) {
        super(name);
    }

    @Override
    public boolean isMine(AbstractBag bag) {
        if (bag.getId() >= 1 && bag.getId() <= 3) {
            System.out.println(getName() + " catchs bag no. " + bag.getId());
            return true;
        }
        return false;
    }
}

//只拿编号为偶数的箱子
public class TravellerEven extends AbstractTraveller {
    public TravellerEven(String name) {
        super(name);
    }

    @Override
    public boolean isMine(AbstractBag bag) {
        if (bag.getId() % 2 == 0) {
            System.out.println(getName() + " catchs bag no. " + bag.getId());
            return true;
        }
        return false;
    }
}

//只拿编号为9的箱子
public class Traveller9 extends AbstractTraveller {
    public Traveller9(String name) {
        super(name);
    }

    @Override
    public boolean isMine(AbstractBag bag) {
        if(bag.getId() == 9){
            System.out.println(getName() + " catchs bag no. " + bag.getId());
            return true;
        }
        return false;
    }
}

而TravelBag类比较简单，这里就不再展示。我们直接看一下在Main方法中如何定义这个链并使用：

public static void main(String[] args) {
    AbstractTraveller chain = new Traveller1to3("123");
    chain.setNext(new TravellerEven("468")).setNext(new Traveller9("Only 9"));
    Random r = new Random();
    for (int i = 0; i < 10; ++i) {
        int id = r.nextInt(9) + 1;
        if (!chain.tryTakeBag(new TravelBag(id))) {
            System.out.println("Bag no. " + id + " remains.");
        }
    }
}

我们使用一个随机数来产生箱子，如果某个箱子被拿到了，就在Traveller内部打印一句话，如果没有人拿，就把false吐出来，在main方法中对false进行处理。
最后我们得到这种输出：

123 catchs bag no. 1
123 catchs bag no. 2
Bag no. 7 remains.
468 catchs bag no. 4
468 catchs bag no. 6
123 catchs bag no. 3
Bag no. 5 remains.
Bag no. 5 remains.
468 catchs bag no. 8
123 catchs bag no. 3

其实大家可以看到，责任链模式其实用到了递归的思想，一层一层传下去，直到请求得到了处理。那么按照所有递归都能用迭代替换的思想，责任链模式其实也可以在一个循环中完成，只要使用Composite模式将请求在所有项中遍历一遍即可，这里就不再进行示例了。

另外如果一个请求需要链上的所有节点都对其进行处理，从而完成整个业务，这样的链也可以成为功能链。其实如果我们把功能链旋转90°，使其成为垂直的过程式方法，其实就是一个功能复杂但完整的中介者模式。