当前位置：首页 > news >正文

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

news 2025/6/6 15:04:43

依赖注入（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 注入	可选依赖，运行时可变依赖	灵活性高	需检查 `nullptr`
接口注入	框架要求标准化注入	统一依赖管理	代码稍冗余
智能指针管理	需要控制生命周期的依赖	避免内存泄漏	可能引入不必要的共享所有权
DI 容器	大型项目，自动依赖管理	减少样板代码	学习成本高