C++ 中的依赖注入（Dependency Injection）

依赖注入（DI）是一种实现低耦合的重要技术，它通过外部提供依赖对象，而不是在类内部直接创建。以下是 C++ 实现依赖注入的几种方式：

1. 构造函数注入（Constructor Injection）

最常用的 DI 方式，依赖通过构造函数传入。

// 依赖接口（抽象类）
class Logger {
public:
    virtual ~Logger() = default;
    virtual void log(const std::string& message) = 0;
};

// 具体实现：控制台日志
class ConsoleLogger : public Logger {
public:
    void log(const std::string& message) override {
        std::cout << "[LOG] " << message << std::endl;
    }
};

// 业务类（依赖 Logger）
class OrderService {
private:
    Logger& logger_;  // 依赖抽象，而非具体实现
public:
    // 通过构造函数注入依赖
    OrderService(Logger& logger) : logger_(logger) {}

    void processOrder() {
        logger_.log("Processing order...");
        // 业务逻辑...
    }
};

// 使用
int main() {
    ConsoleLogger consoleLogger;  // 依赖的具体实现
    OrderService orderService(consoleLogger);  // 注入依赖
    orderService.processOrder();
    return 0;
}

优点：

• 依赖关系清晰，强制要求提供依赖。
• 适合必须依赖的情况（如日志、数据库访问）。

2. Setter 方法注入（Setter Injection）

适用于可选依赖，或依赖可能在运行时变更的情况。

class OrderService {
private:
    Logger* logger_ = nullptr;  // 使用指针（或 std::optional）
public:
    // Setter 注入
    void setLogger(Logger& logger) {
        logger_ = &logger;
    }

    void processOrder() {
        if (logger_) {
            logger_->log("Processing order...");
        }
        // 业务逻辑...
    }
};

// 使用
int main() {
    ConsoleLogger consoleLogger;
    OrderService orderService;
    orderService.setLogger(consoleLogger);  // 动态注入依赖
    orderService.processOrder();
    return 0;
}

优点：

• 灵活性高，可在运行时更换依赖。
• 适用于插件式架构（如动态加载模块）。

缺点：

• 依赖可能为 nullptr，需额外检查。

3. 接口注入（Interface Injection）

通过接口定义依赖注入的契约（较少用，但某些框架支持）。

// 定义可注入 Logger 的接口
class LoggerAware {
public:
    virtual ~LoggerAware() = default;
    virtual void setLogger(Logger& logger) = 0;
};

// 业务类实现接口
class OrderService : public LoggerAware {
private:
    Logger* logger_ = nullptr;
public:
    void setLogger(Logger& logger) override {
        logger_ = &logger;
    }

    void processOrder() {
        if (logger_) {
            logger_->log("Processing order...");
        }
        // 业务逻辑...
    }
};

// 使用
int main() {
    ConsoleLogger consoleLogger;
    OrderService orderService;
    orderService.setLogger(consoleLogger);  // 通过接口注入
    orderService.processOrder();
    return 0;
}

适用场景：

• 某些 DI 框架（如 Boost.DI）可能要求接口注入。
• 适用于标准化依赖管理的复杂系统。

4. 使用智能指针（std::shared_ptr 或 std::unique_ptr）

适用于需要管理生命周期的依赖。

class OrderService {
private:
    std::shared_ptr<Logger> logger_;  // 使用智能指针
public:
    OrderService(std::shared_ptr<Logger> logger) : logger_(std::move(logger)) {}

    void processOrder() {
        if (logger_) {
            logger_->log("Processing order...");
        }
        // 业务逻辑...
    }
};

// 使用
int main() {
    auto logger = std::make_shared<ConsoleLogger>();
    OrderService orderService(logger);  // 注入智能指针
    orderService.processOrder();
    return 0;
}

优点：

• 自动管理内存，避免内存泄漏。
• 适用于跨线程共享依赖的情况。

5. 依赖注入容器（DI Container）

进阶用法：使用 IoC 容器自动管理依赖（如 Boost.DI）。

#include <boost/di.hpp>
namespace di = boost::di;

// 定义接口和实现
class Logger { public: virtual void log(const std::string&) = 0; };
class ConsoleLogger : public Logger { public: void log(const std::string& msg) override { std::cout << msg << std::endl; } };

// 业务类
class OrderService {
public:
    explicit OrderService(std::shared_ptr<Logger> logger) : logger_(logger) {}
    void processOrder() { logger_->log("Order processed!"); }
private:
    std::shared_ptr<Logger> logger_;
};

// 使用 DI 容器
int main() {
    auto injector = di::make_injector(
        di::bind<Logger>().to<ConsoleLogger>()  // 配置依赖关系
    );
    auto orderService = injector.create<std::shared_ptr<OrderService>>();  // 自动注入
    orderService->processOrder();
    return 0;
}

适用场景：

• 大型项目，依赖关系复杂。
• 需要自动依赖解析的情况。

总结：C++ 依赖注入的最佳实践

推荐选择：

• 大多数情况：优先使用构造函数注入（最清晰）。
• 可选依赖：使用 Setter 注入 或 std::optional。
• 复杂项目：考虑 DI 容器（如 Boost.DI）。