依赖注入学习

1.介绍

依赖注入（Dependency Injection, DI）是一种软件设计模式，用于实现类与其依赖项之间的解耦。它的核心思想是，将类所依赖的对象通过外部注入的方式传递给它，而不是在类内部自行创建依赖对象。通过这种方式，代码变得更加灵活、可维护，并且有助于提高可测试性。

在面向对象编程中，类通常依赖于其他类来完成工作。例如，类 A 可能需要调用类 B 来执行一些功能。如果类 A 在内部直接创建类 B 的实例，那么这两者之间便紧密耦合，难以在不修改类 A 的情况下替换或测试类 B。

依赖注入 通过将依赖项（如类 B）从外部传递给类 A，可以解除两者之间的直接依赖。类 A 不再负责创建依赖项，而是依赖于外部提供的依赖项。

2.常见方式

2.1 构造函数注入具体类

// 具体的类
class Service {
public:
    void execute() {
        std::cout << "Executing service..." << std::endl;
    }
};

class Client {
private:
    Service* service;
public:
    // 通过构造函数注入依赖项
    Client(Service* s) : service(s) {}

    void doWork() {
        service->execute();
    }
};

int main() {
    Service s;
    Client c(&s);  // 注入依赖
    c.doWork();    // 使用注入的依赖
    return 0;
}

2.2 构造函数注入抽象类

// 抽象类，接口。
class IService {
public:
    virtual void execute() = 0;
};

class Service : public IService {
public:
    void execute() override {
        std::cout << "Executing service..." << std::endl;
    }
};

class Client {
private:
    IService* service; // 抽象类，
public:
    void setService(IService* s) {
        service = s;
    }

    void doWork() {
        service->execute();
    }
};

int main() {
    Service s;
    Client c;
    c.setService(&s);  // 注入实现接口的依赖
    c.doWork();
    return 0;
}

2.3 set函数注入

class Client {
private:
    Service* service;
public:
    void setService(Service* s) {
        service = s;
    }

    void doWork() {
        service->execute();
    }
};

int main() {
    Service s;
    Client c;
    c.setService(&s);  // 通过 setter 方法注入依赖
    c.doWork();
    return 0;
}

允许依赖在对象创建之后设置。