责任链模式（设计模式）_csdn责任链

责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许多个对象有机会处理请求，从而避免请求的发送者和接收者之间的耦合。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

责任链模式的核心思想

责任链模式的核心思想是将处理请求的对象链成一个链条，让请求沿着链条传递，直到有对象处理它。这种模式可以动态地调整请求的处理顺序，并且增加新的处理对象时不需要修改已有的代码，符合开闭原则。

责任链模式的组成部分

Handler（处理者接口或抽象类）：定义一个处理请求的接口，并且通常包含一个指向下一个处理者的引用。
ConcreteHandler（具体处理者）：实现处理者接口，处理它所负责的请求，或者将请求传递给下一个处理者。
Client（客户端）：创建处理链，并向链上的处理者发送请求。

责任链模式的实现

下面是一个简单的责任链模式的实现示例，使用 Java 编写：

1. 定义处理者接口或抽象类
// 处理者接口
public abstract class Handler {
    protected Handler successor;

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    public abstract void handleRequest(String request);
}
2. 实现具体处理者
// 具体处理者1
public class ConcreteHandler1 extends Handler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("Request1")) {
            System.out.println("ConcreteHandler1 handled the request.");
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 具体处理者2
public class ConcreteHandler2 extends Handler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("Request2")) {
            System.out.println("ConcreteHandler2 handled the request.");
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 具体处理者3
public class ConcreteHandler3 extends Handler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("Request3")) {
            System.out.println("ConcreteHandler3 handled the request.");
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}
3. 客户端代码
public class ChainOfResponsibilityPatternDemo {
    public static void main(String[] args) {
        // 创建处理者
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();

        // 设置责任链
        handler1.setSuccessor(handler2);
        handler2.setSuccessor(handler3);

        // 测试请求
        handler1.handleRequest("Request1");
        handler1.handleRequest("Request2");
        handler1.handleRequest("Request3");
        handler1.handleRequest("UnknownRequest");
    }
}
运行结果
ConcreteHandler1 handled the request.
ConcreteHandler2 handled the request.
ConcreteHandler3 handled the request.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

责任链模式总结

责任链模式通过将请求的发送者和接收者解耦，使得多个对象都有机会处理这个请求。请求沿着处理链传递，直到有一个对象处理它为止。这样，责任链模式提供了一种灵活的方式来处理请求。
责任链模式的优缺点
优点：
降低耦合度。一个对象无需知道是哪个对象处理其请求。
增强了系统的可扩展性。可以通过增加新的处理者来扩展系统。
提供了一种灵活的方式来处理请求。
缺点：
不能保证每个请求一定会被处理。请求可能会传递到链的末端而没有处理者处理它。
可能会影响性能，特别是当链条过长时，每个请求都需要从链头遍历到链尾。

应用场景

责任链模式适用于以下场景：
有多个对象可以处理某个请求，但具体处理者在运行时动态确定。
希望将请求的发送者和接收者解耦。
可以动态地指定处理请求的顺序。
通过责任链模式，可以灵活地组织请求的处理过程，提高系统的可维护性和扩展性。
责任链模式的应用场景非常广泛，包括但不限于：
1.用户认证和授权：将用户的认证和授权环节抽象成一个个的处理器，并按照顺序组成一个责任链。当用户发送请求时，责任链中的处理器依次进行认证和授权操作。
2.日志记录：将日志记录的逻辑封装到多个处理器中，并按照一定的顺序组成一个责任链。当需要记录日志时，请求会沿着责任链传递，每个处理器都可以选择是否记录日志以及记录的方式和内容。
3.异常处理：将不同类型的异常处理逻辑分别封装到不同的处理器中，并按照一定的顺序组成一个责任链。当系统出现异常时，请求会沿着责任链传递，每个处理器都可以选择是否处理该异常以及如何处理。
4.数据校验：将不同类型的校验逻辑封装到不同的处理器中，并按照一定的顺序组成一个责任链。当用户输入数据时，请求会沿着责任链传递，每个处理器都可以选择是否校验该数据以及如何校验。
5.请求过滤：将不同类型的过滤逻辑封装到不同的处理器中，并按照一定的顺序组成一个责任链。当请求到达时，请求会沿着责任链传递，每个处理器都可以选择是否过滤该请求以及如何过滤。