Java中的责任链模式

当应有几个处理器来执行某项操作并为这些处理器定义特定顺序时，就需要采用责任链设计模式。 在运行时处理器顺序的可变性也很重要。模式的UML表示如下：

处理程序定义处理器对象的一般结构。 这里的“ HandleRequest”是抽象处理器方法。 处理程序还具有自己的类型引用，该引用表示下一个处理程序。 为此，应定义一个公共的“ setNextHandler”方法，并且该处理程序恰好是一个抽象类。 ConcreteHandler定义处理器的不同表示形式。 最后，客户负责创建所需的处理程序（处理器）并定义它们之间的链顺序。
通常，此模式可能存在两种不同的实现方式。 差异与“链路由业务逻辑的位置”有关。 链路由业务逻辑可以在Handler抽象类或ConcreteHandler类中，或在两者中。 下面将给出前两种方法的样本：

1.“处理程序”具有链路由业务逻辑：

public abstract class Processor {
    protected Processor next;
    protected int threshold;
    public void setNextProcessor(Processor p) {
        next = p;
    }
    public void process(String data, int value) {
        if (value <= threshold) {
            process(data);
        }
        if (next != null) {
            next.message(data, threshold);
        }
    }
    abstract protected void processData(String data);
}
public class ProcessorA extends Processor {

    public ProcessorA (int threshold) {
        this.threshold = threshold;
    }
    protected void processData(String data) {
        System.out.println("Processing with A: " + data);
    }
}
public class ProcessorB extends Processor {

    public ProcessorB (int threshold) {
        this.threshold = threshold;
    }
    protected void writeMessage(String data) {
        System.err.println("Processing with B: " + data);
    }
}
public class Client {
    public static void main(String[] args) {
        Processor p, p1, p2;
        p1 = p = new ProcessorA(2);
        p2 = new ProcessorB(1);
        p1.setNextProcessor(p2);
        // Handled by ProcessorA
        p.process("data1", 2);
        // Handled by ProcessorA and ProcessorB
        p.process("data2", 1);
    }
}

2.'ConcreteHandler'具有链路由业务逻辑：

public abstract class Processor {
    protected Processor next;
    protected int threshold;
    public void setNextProcessor(Processor p) {
        next = p;
    }
    abstract protected void processData(String data);
}
public class ProcessorA extends Processor {

    public ProcessorA (int threshold) {
        this.threshold = threshold;
    }
    protected void processData(String data, int value) {
        System.out.println("Processing with A: " + data);
        if (value >= threshold && next != null) {
            next.processData(data, value);
        }
    }
}
public class ProcessorB extends Processor {

    public ProcessorB (int threshold) {
        this.threshold = threshold;
    }
    protected void processData(String data, int value) {
        System.out.println("Processing with B: " + data);
        if (value >= threshold && next != null) {
            next.processData(data, value);
        }
    }
}
public class Client {
    public static void main(String[] args) {
        Processor p, p1, p2;
        p1 = p = new ProcessorA(2);
        p2 = new ProcessorB(1);
        p1.setNextProcessor(p2);
        // Handled by ProcessorA
        p.processData("data1", 1);
        // Handled by ProcessorA and ProcessorB
        p.processData("data2", 2);
    }
}

参考：来自Java的JCG合作伙伴 Cagdas Basaraner在CodeBuild博客上使用Java实现的“责任链”模式的2种实现 。

翻译自: https://www.javacodegeeks.com/2012/06/chain-of-responsibility-pattern-in-java.html