09-责任链模式-C语言实现

责任链模式：Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request.Chain the receiving objects and pass the request along the chain until an object handles it.（使多个对象都有机会处理请求， 从而避免了请求的发送者和接受者之间的耦合关系。 将这些对象连成一条链， 并沿着这条链传递该请求， 直到有对象处理它为止。 ）

UML图：

代码实现：

#include <stdio.h>
#include <stdlib.h>

// 定义请求结构体
typedef struct {
    int amount;
} Request;

// 定义处理对象结构体
typedef struct Handler {
    void (*handleRequest)(struct Handler* handler, Request* request);
    struct Handler* nextHandler;
} Handler;

// 处理对象1
void handler1_handleRequest(Handler* handler, Request* request) {
    if (request->amount <= 100) {
        printf("Handler 1 handles the request.\n");
    } else if (handler->nextHandler != NULL) {
        handler->nextHandler->handleRequest(handler->nextHandler, request);
    }
}

// 处理对象2
void handler2_handleRequest(Handler* handler, Request* request) {
    if (request->amount > 100 && request->amount <= 500) {
        printf("Handler 2 handles the request.\n");
    } else if (handler->nextHandler != NULL) {
        handler->nextHandler->handleRequest(handler->nextHandler, request);
    }
}

// 处理对象3
void handler3_handleRequest(Handler* handler, Request* request) {
    if (request->amount > 500) {
        printf("Handler 3 handles the request.\n");
    } else if (handler->nextHandler != NULL) {
        handler->nextHandler->handleRequest(handler->nextHandler, request);
    }
}

int main() {
    // 创建处理对象
    Handler* handler1 = (Handler*)malloc(sizeof(Handler));
    Handler* handler2 = (Handler*)malloc(sizeof(Handler));
    Handler* handler3 = (Handler*)malloc(sizeof(Handler));

    // 设置处理函数和下一个处理对象
    handler1->handleRequest = handler1_handleRequest;
    handler1->nextHandler = handler2;

    handler2->handleRequest = handler2_handleRequest;
    handler2->nextHandler = handler3;

    handler3->handleRequest = handler3_handleRequest;
    handler3->nextHandler = NULL;

    // 创建请求
    Request request1 = {50};
    Request request2 = {200};
    Request request3 = {1000};

    // 处理请求
    handler1->handleRequest(handler1, &request1);
    handler1->handleRequest(handler1, &request2);
    handler1->handleRequest(handler1, &request3);

    // 释放内存
    free(handler1);
    free(handler2);
    free(handler3);

    return 0;
}

此示例实现了一个简单的责任链模式，有三个处理对象（handler1、handler2和handler3），每个处理对象都可以选择处理请求或将其传递给下一个处理对象。每个处理对象都具有一个处理请求的函数指针，并且可以通过nextHandler字段连接到下一个处理对象。

责任链模式的优点：

1. 解耦：责任链模式使得请求的发送者和接收者之间解耦，发送者无需知道请求将由哪个接收者处理，接收者也无需知道请求的发送者是谁。
2. 灵活性：可以动态地添加、移除或重新排列处理对象，以满足不同的需求和情况。
3. 可扩展性：可以很容易地添加新的处理对象，而无需修改现有的代码。

责任链模式的缺点：

1. 不能保证请求一定会被处理：如果没有合适的处理对象处理请求，请求可能会到达链的末尾而无法得到处理。
2. 性能影响：由于请求需要通过整个链进行传递，可能会在一些场景下造成性能损失。
3. 可能导致系统复杂化：当责任链过长或过于复杂时，可能会增加代码的理解和维护难度。

应用场景：

1. 请求处理：当一个请求需要经过多个处理对象进行处理时，可以使用责任链模式。每个处理对象都有自己的处理逻辑，并可以选择将请求传递给下一个处理对象或者终止处理。

2. 日志记录：在日志记录系统中，可以使用责任链模式来实现不同级别的日志记录。例如，可以定义一个处理对象链，其中包含了不同级别的日志处理对象，从低级别到高级别。每个处理对象根据自己的级别来判断是否要处理该日志消息。

3. 身份认证：在身份认证系统中，可以使用责任链模式来验证用户的身份。可以创建一个处理对象链，其中包含了不同的身份验证处理对象，如用户名密码验证、二次验证等。每个处理对象根据自己的验证规则来判断是否通过验证，如果验证失败，则可以选择终止验证或将请求传递给下一个处理对象。

4. 缓存处理：在缓存系统中，可以使用责任链模式来处理缓存。可以创建一个处理对象链，其中包含了多个缓存处理对象，如本地缓存、分布式缓存等。每个处理对象根据自己的策略来判断是否有缓存可用，如果有，则返回缓存数据，否则将请求传递给下一个处理对象。

5. 错误处理：在错误处理系统中，可以使用责任链模式来处理不同类型的错误。可以创建一个处理对象链，其中包含了多个错误处理对象，如日志记录、发送错误报告等。每个处理对象根据自己的处理逻辑来判断是否能够处理该错误，如果不能，则将错误传递给下一个处理对象。

6. 版本号处理