责任链模式

责任链模式的定义与特点

责任链（Chain of Responsibility）模式：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

责任链模式使用场景

1. 多个对象可以处理同一请求，但具体由哪个对象处理则在运行时动态决定。
2. 在请求处理者不明确的情况下向多个对象中的一个提交请求。
3. 可动态指定一组对象处理请求，或添加新的处理者。

责任链模式的结构与实现

/**
 * 抽象处理者，处理请示的类
 */
public abstract class Handler {
    /**
     * 下一节点的处理者
     */
    protected Handler successor;

    /**
     * 设置继任者
     *
     * @param successor 继任者
     */
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    /**
     * 处理请求的抽象方法
     *
     * @param condition 请求条件
     */
    public abstract void handleRequest(int condition);
}

ConcreteHandler 具体处理者类，处理它所负责的请求，可访问它的后继者，如果可处理改请求就处理，否则就将该请求转发给它的后继者。

/**
 * 具体处理者角色1，当请求数在 0 到 10 之间则有权处理，否则转移到下一位
 */
public class ConcreteHandler1 extends Handler {
    @Override
    public void handleRequest(int condition) {
        if (condition >= 0 && condition < 10) {
            // 0 到 10 处理此请求
            System.out.println("具体处理者1负责处理该请求！" + condition);
        } else {
            if (successor != null) {
                // 转移到下一位
                successor.handleRequest(condition);
            } else {
                System.out.println("没有人处理该请求！");
            }
        }
    }
}

/**
 * 具体处理者角色2，当请求数在 10 到 20 之间则有权处理，否则转移到下一位
 */
public class ConcreteHandler2 extends Handler {
    @Override
    public void handleRequest(int condition) {
        if (condition >= 10 && condition < 20) {
            // 0 到 10 处理此请求
            System.out.println("具体处理者2负责处理该请求！" + condition);
        } else {
            if (successor != null) {
                // 转移到下一位
                successor.handleRequest(condition);
            } else {
                System.out.println("没有人处理该请求！");
            }
        }
    }
}

/**
 * 具体处理者角色3，当请求数在 20 到 30 之间则有权处理，否则转移到下一位
 */
public class ConcreteHandler3 extends Handler {
    @Override
    public void handleRequest(int condition) {
        if (condition >= 20 && condition < 30) {
            // 0 到 10 处理此请求
            System.out.println("具体处理者3负责处理该请求！" + condition);
        } else {
            if (successor != null) {
                // 转移到下一位
                successor.handleRequest(condition);
            } else {
                System.out.println("没有人处理该请求！");
            }
        }
    }
}

/**
 * 客户端，向链上的具体处理者对象提交请求
 */
public class Client {
    public static void main(String[] args) {
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();

        // 设置职责链上家与下家
        handler1.setSuccessor(handler2);
        handler2.setSuccessor(handler3);

        int[] conditions = {2, 5, 14, 22, 18, 3, 27, 20, 33};

        // 循环给最小处理者提交请求，不同的数额由不同权限处理者处理
        for (int condition : conditions) {
            handler1.handleRequest(condition);
        }
    }
}

程序运行结果如下：

具体处理者1负责处理该请求！2
具体处理者1负责处理该请求！5
具体处理者2负责处理该请求！14
具体处理者3负责处理该请求！22
具体处理者2负责处理该请求！18
具体处理者1负责处理该请求！3
具体处理者3负责处理该请求！27
具体处理者3负责处理该请求！20
没有人处理该请求！