定义

责任链模式(ChainOfResponsibility)： 有多个对象，每个对象持有下一个对象的引用，形成一条链，请求在这条链上传递，直到某一对象决定处理该请求，但是发出者并不清楚最终哪个对象会处理该请求。

当你想要让一个以上的对象有机会能够处理某个请求的时候，就使用责任链模式。又称职责链。

如何使用责任链模式

责任链包含三个角色：

• Handler: 抽象处理者。定义了一个处理请求的方法。所有的处理者都必须实现该抽象类。
• ConcreteHandler: 具体处理者。处理它所负责的请求，同时也可以访问它的后继者。如果它能够处理该请求则处理，否则将请求传递到它的后继者。
• Client: 客户类。

示例代码

Handler: 抽象处理者。

public abstract class Chain {
    public static int One = 1;
    public static int Two = 2;
    public static int Three = 3;
    protected int Threshold;

    protected Chain next;

    public void setNext(Chain chain) {
        next = chain;
    }

    public void message(String msg, int priority) {
        // 如果优先级小于阈值则处理
        if (priority <= Threshold) {
            writeMessage(msg);
        }

        if (next != null) {
            next.message(msg, priority);
        }
    }

    abstract protected void writeMessage(String msg);
}

具体处理者

public class A extends Chain {
    public A(int threshold) {
        this.Threshold = threshold;
    }

    protected void writeMessage(String msg) {
        System.out.println("A: " + msg);
    }
}

public class B extends Chain {
    public B(int threshold) {
        this.Threshold = threshold;
    }

    protected void writeMessage(String msg) {
        System.out.println("B: " + msg);
    }
}

public class C extends Chain {
    public C(int threshold) {
        this.Threshold = threshold;
    }

    protected void writeMessage(String msg) {
        System.out.println("C: " + msg);
    }
}

测试，Client

public class Example {
    private static Chain createChain() {
        // 建立责任链
        Chain chain1 = new A(Chain.Three);

        Chain chain2 = new B(Chain.Two);
        chain1.setNext(chain2);

        Chain chain3 = new C(Chain.One);
        chain2.setNext(chain3);

        return chain1;
    }

    public static void main(String[] args) {

        Chain chain = createChain();

        chain.message("level 3", Chain.Three);

        chain.message("level 2", Chain.Two);

        chain.message("level 1", Chain.One);
    }
}

打印结果

A: level 3
A: level 2
B: level 2
A: level 1
B: level 1
C: level 1

优缺点

优点

1. 降低耦合度。它将请求的发送者和接受者解耦。

2. 简化了对象。使得对象不需要知道链的结构。

3. 增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。

4. 增加新的请求处理类很方便。

缺点

1. 不能保证请求一定被接收。

2. 系统性能将受到一定影响，而且在进行代码调试时不太方便；可能会造成循环调用。

3. 可能不容易观察运行时的特征，有碍于除错。

模式适用场景

1. 有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。
2. 在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。
3. 可动态指定一组对象处理请求。

参考

https://blog.csdn.net/chenssy/article/details/11881377
https://www.programcreek.com/2013/02/java-design-pattern-chain-of-responsibility