依赖后端CPU信息选策略的负载均衡器设计模式求解

问题描述 #

我正在实现一款负载均衡器，需要依据特定逻辑选择均衡策略。原代码结构如下：

class LoadBalancer{
public: 
    bool get_backend_cpu_info(){
        // 复杂逻辑，需要访问成员变量backends
    } 
    static void create(){ 
        if (get_backend_cpu_info()){ 
            LoadBalancerCPU.choose_backend(); 
        } else {
            LoadBalancerRoundRobin.choose_backend(); 
        }
    } 
    void choose_backend(){
        // 逻辑取决于负载均衡器类型
    }
private: 
    vector<backends> b;
};

核心矛盾在于：

• 若用虚函数实现运行时多态，需要先创建LoadBalancer对象才能调用get_backend_cpu_info()，但该方法的结果又决定了应该创建哪种类型的负载均衡器实例。
• 普通工厂方法也存在同样问题：get_backend_cpu_info()依赖类成员backends，无法在对象创建前执行判断。

解决方案：分离策略与后端信息，提前获取决策依据 #

可以采用策略模式结合后端信息预加载的思路，将负载均衡策略与负载均衡器的后端管理职责分离，同时把决策所需的后端CPU信息从LoadBalancer类中解耦出来，先获取信息再创建对应策略的负载均衡器。

具体实现步骤 #

1. 定义负载均衡策略的抽象接口，封装choose_backend逻辑
2. 实现两种具体策略：基于CPU的策略和轮询策略
3. 单独提取后端信息获取逻辑，在创建负载均衡器前完成决策
4. 让LoadBalancer持有具体策略对象，实现职责分离

C++代码示例 #

#include <vector>
#include <memory>

// 假设的后端类型定义
struct Backend {
    int id;
    float cpu_usage;
};

// 负载均衡策略抽象接口
class LoadBalanceStrategy {
public:
    virtual ~LoadBalanceStrategy() = default;
    virtual Backend choose_backend(const std::vector<Backend>& backends) = 0;
};

// 基于CPU使用率的策略实现
class CPUBasedStrategy : public LoadBalanceStrategy {
public:
    Backend choose_backend(const std::vector<Backend>& backends) override {
        // 选择CPU使用率最低的后端
        Backend selected = backends[0];
        for (const auto& be : backends) {
            if (be.cpu_usage < selected.cpu_usage) {
                selected = be;
            }
        }
        return selected;
    }
};

// 轮询策略实现
class RoundRobinStrategy : public LoadBalanceStrategy {
public:
    Backend choose_backend(const std::vector<Backend>& backends) override {
        // 简单轮询逻辑
        Backend selected = backends[current_index];
        current_index = (current_index + 1) % backends.size();
        return selected;
    }
private:
    int current_index = 0;
};

// 后端信息管理工具类，负责获取CPU信息
class BackendInfoManager {
public:
    static bool is_cpu_info_available(const std::vector<Backend>& backends) {
        // 模拟复杂的CPU信息获取逻辑，比如检查所有后端是否能返回有效CPU数据
        for (const auto& be : backends) {
            if (be.cpu_usage < 0) { // 假设负数表示无法获取CPU信息
                return false;
            }
        }
        return true;
    }
};

// 重构后的负载均衡器
class LoadBalancer {
public:
    // 工厂方法：先根据后端信息选择策略，再创建负载均衡器
    static LoadBalancer create(const std::vector<Backend>& backends) {
        std::unique_ptr<LoadBalanceStrategy> strategy;
        if (BackendInfoManager::is_cpu_info_available(backends)) {
            strategy = std::make_unique<CPUBasedStrategy>();
        } else {
            strategy = std::make_unique<RoundRobinStrategy>();
        }
        return LoadBalancer(backends, std::move(strategy));
    }

    // 调用策略选择后端
    Backend choose_backend() {
        return strategy->choose_backend(backends);
    }

private:
    std::vector<Backend> backends;
    std::unique_ptr<LoadBalanceStrategy> strategy;

    // 私有构造函数，仅通过create方法创建实例
    LoadBalancer(const std::vector<Backend>& be, std::unique_ptr<LoadBalanceStrategy> st)
        : backends(be), strategy(std::move(st)) {}
};

方案优势 #

• 职责分离：后端信息管理、负载均衡策略、负载均衡器核心逻辑各自独立，易于扩展和维护
• 解决决策时机矛盾：在创建LoadBalancer前，通过独立的BackendInfoManager获取后端CPU信息，避免了"先创建对象才能判断策略"的死循环
• 扩展性强：新增负载均衡策略时，只需实现LoadBalanceStrategy接口，无需修改LoadBalancer核心代码

内容的提问来源于stack exchange，提问作者Yufei Zheng