C++职责链模式在企业级审批流程中的建模实践-源码库

C++职责链模式在企业级审批流程中的建模实践：从理论到落地的完整指南

作为一名在企业级系统开发领域摸爬滚打多年的开发者，我深刻体会到审批流程建模的复杂性。今天我想和大家分享如何运用C++职责链模式来优雅地解决这个问题。记得去年我们重构公司OA系统时，正是职责链模式让我们从繁琐的if-else嵌套中解脱出来，实现了审批流程的可配置化和灵活扩展。

职责链模式的核心思想

职责链模式的核心在于将请求的发送者和接收者解耦，让多个对象都有机会处理请求。这些对象连接成一条链，请求沿着链传递，直到有对象处理它为止。在企业审批场景中，这完美契合了”逐级审批”的业务逻辑。

让我先展示一个基础的责任链实现框架：


// 审批请求类
class ApprovalRequest {
public:
    string applicant;      // 申请人
    double amount;         // 金额
    string content;        // 申请内容
    int level;            // 当前审批级别
    
    ApprovalRequest(const string& app, double amt, const string& cnt)
        : applicant(app), amount(amt), content(cnt), level(0) {}
};

// 抽象审批者
class Approver {
protected:
    Approver* nextApprover;  // 下一级审批者
    string name;            // 审批者姓名
    double approvalLimit;   // 审批权限金额

public:
    Approver(const string& n, double limit) 
        : name(n), approvalLimit(limit), nextApprover(nullptr) {}
    
    virtual ~Approver() = default;
    
    // 设置下一级审批者
    void setNext(Approver* next) {
        nextApprover = next;
    }
    
    // 处理审批请求
    virtual void processRequest(ApprovalRequest& request) = 0;
};

具体审批者的实现

在实际项目中，我们通常会实现不同级别的审批者。让我以部门经理、总监和总经理三级审批为例：


// 部门经理审批者
class Manager : public Approver {
public:
    Manager(const string& name) : Approver(name, 5000.0) {}
    
    void processRequest(ApprovalRequest& request) override {
        if (request.amount <= approvalLimit) {
            cout << "经理" << name << "审批通过申请：" << request.content << endl;
            request.level = 1;
        } else if (nextApprover != nullptr) {
            cout << "经理" << name << "无权限审批，转交上级" << endl;
            nextApprover->processRequest(request);
        } else {
            cout << "申请无法处理，需要更高级别审批" << endl;
        }
    }
};

// 总监审批者
class Director : public Approver {
public:
    Director(const string& name) : Approver(name, 20000.0) {}
    
    void processRequest(ApprovalRequest& request) override {
        if (request.amount <= approvalLimit) {
            cout << "总监" << name << "审批通过申请：" << request.content << endl;
            request.level = 2;
        } else if (nextApprover != nullptr) {
            cout << "总监" << name << "无权限审批，转交上级" << endl;
            nextApprover->processRequest(request);
        } else {
            cout << "申请无法处理，需要更高级别审批" << endl;
        }
    }
};

// 总经理审批者
class GeneralManager : public Approver {
public:
    GeneralManager(const string& name) : Approver(name, 100000.0) {}
    
    void processRequest(ApprovalRequest& request) override {
        if (request.amount <= approvalLimit) {
            cout << "总经理" << name << "审批通过申请：" << request.content << endl;
            request.level = 3;
        } else {
            cout << "金额过大，需要董事会审批" << endl;
        }
    }
};

构建审批链的实战技巧

在真实项目中，审批链的构建往往需要从配置文件中动态加载。这里我分享一个实用的构建方法：


class ApprovalChainBuilder {
public:
    static Approver* buildChainFromConfig(const vector>& config) {
        if (config.empty()) return nullptr;
        
        Approver* head = nullptr;
        Approver* current = nullptr;
        
        for (const auto& item : config) {
            Approver* approver = createApproverByLimit(item.first, item.second);
            
            if (!head) {
                head = approver;
                current = head;
            } else {
                current->setNext(approver);
                current = approver;
            }
        }
        
        return head;
    }
    
private:
    static Approver* createApproverByLimit(const string& name, double limit) {
        // 根据金额限制创建不同级别的审批者
        if (limit <= 5000) {
            return new Manager(name);
        } else if (limit <= 20000) {
            return new Director(name);
        } else {
            return new GeneralManager(name);
        }
    }
};

完整的使用示例

让我们来看一个完整的使用场景，这里模拟了一个费用报销的审批流程：


int main() {
    // 构建审批链：张经理(5000) -> 李总监(20000) -> 王总(100000)
    Manager* manager = new Manager("张三");
    Director* director = new Director("李四");
    GeneralManager* gm = new GeneralManager("王五");
    
    manager->setNext(director);
    director->setNext(gm);
    
    // 测试不同金额的申请
    vector requests = {
        ApprovalRequest("员工A", 3000.0, "差旅费报销"),
        ApprovalRequest("员工B", 8000.0, "设备采购"),
        ApprovalRequest("员工C", 50000.0, "项目预算")
    };
    
    cout << "=== 开始审批流程 ===" << endl;
    for (auto& request : requests) {
        cout << "n处理申请：" << request.content 
             << "，金额：" << request.amount << endl;
        manager->processRequest(request);
    }
    
    // 释放资源
    delete manager;
    delete director;
    delete gm;
    
    return 0;
}

实战中的踩坑与优化

在实际项目中，我们遇到了一些值得注意的问题：

1. 内存管理问题：原始指针容易造成内存泄漏，建议使用智能指针：


class SafeApprover {
private:
    shared_ptr nextApprover;
    
public:
    void setNext(shared_ptr next) {
        nextApprover = next;
    }
    
    // 其他方法保持不变
};

2. 审批流程中断：有时候需要支持"任意一级审批通过即可"的场景，我们通过引入审批策略模式来解决：


class ApprovalStrategy {
public:
    virtual bool shouldContinue(bool currentApproved) = 0;
    virtual ~ApprovalStrategy() = default;
};

class StrictChainStrategy : public ApprovalStrategy {
    // 严格链式：必须逐级审批
};

class AnyApprovalStrategy : public ApprovalStrategy {
    // 任意审批：只要有一级通过即可
};

扩展功能：审批状态追踪

在企业级应用中，审批状态的实时追踪至关重要。我们通过观察者模式实现了这一功能：


class ApprovalObserver {
public:
    virtual void onApprovalProgress(const string& applicant, 
                                   int currentLevel, 
                                   const string& approver) = 0;
    virtual ~ApprovalObserver() = default;
};

class NotificationService : public ApprovalObserver {
public:
    void onApprovalProgress(const string& applicant, 
                           int currentLevel, 
                           const string& approver) override {
        cout << "通知：" << applicant << "的申请已到达第" 
             << currentLevel << "级审批，当前审批人：" << approver << endl;
    }
};