男女做的那个视频网站软广告经典案例

编程的法则 依赖倒置原则 （Dependency Inversion Principle）包括如何实践

flyfish

2017-07-19
2024-07-18

在软件工程中，存在着层次结构，其中上层的业务逻辑依赖于下层的实现细节。如果是直接的依赖关系可能会导致问题，因为较低层级的变化会影响到高层级的稳定性。
这就是依赖倒置原则发挥作用的地方，在软件设计中引入抽象作为中间层，让上层和下层都依赖于这个抽象，而不是彼此直接依赖。
这意味着，无论是在业务逻辑层还是数据访问层，都应该通过接口或抽象类来进行交互，而非具体的实现。这样一来，当需要更改或替换低层的具体实现时，不会对上层产生影响，因为它们只关心抽象的行为，而不在乎具体是如何完成的。
此外，依赖倒置原则还强调，抽象应该是稳定的，不应依赖于具体的实现细节；反之，具体的实现应该依赖于抽象。这样，即使底层实现发生变化，只要抽象不变，整个系统就能保持稳定。

上面的话总结原则的核心思想是：

1. 高层模块不应该依赖于低层模块。两者都应该依赖于抽象。

2. 抽象不应该依赖于细节。细节应该依赖于抽象。

高层模块不应该依赖于低层模块。两者都应该依赖于抽象。

高层模块 （High Level Modules）通常包含应用程序的业务逻辑或策略。它们决定了应用程序如何运作以及如何实现主要功能。而低层模块 （Low Level Modules）通常是实现具体功能的组件，例如数据库访问、网络通信、文件读写等。
在传统设计中，高层模块直接依赖于低层模块。这种设计的问题在于，如果低层模块发生改变，高层模块也必须相应地修改，导致系统的耦合度过高，不易于维护和扩展。
依赖抽象 意味着在高层模块和低层模块之间引入一个抽象层，通常是接口或抽象类。这样，高层模块和低层模块都依赖于这个抽象层，而不是直接依赖彼此的具体实现。

举例说明

假设有一个应用程序，它需要从不同的数据源读取数据并进行处理。数据源可以是文件、数据库或网络。

• 高层模块 ：负责处理数据的逻辑。

• 低层模块 ：实现具体的数据读取操作。

#include <iostream>
#include <string>// 抽象层
class DataReader {
public:virtual std::string readData() = 0;virtual ~DataReader() = default;
};class Writer {
public:virtual void write(const std::string& data) = 0;virtual ~Writer() = default;
};// 具体实现
class FileDataReader : public DataReader {
public:std::string readData() override {return "Data from file";}
};class DatabaseDataReader : public DataReader {
public:std::string readData() override {return "Data from database";}
};class NetworkDataReader : public DataReader {
public:std::string readData() override {return "Data from network";}
};class ConsoleWriter : public Writer {
public:void write(const std::string& data) override {std::cout << "Writing to console: " << data << std::endl;}
};class FileWriter : public Writer {
public:void write(const std::string& data) override {// 模拟写入文件std::cout << "Writing to file: " << data << std::endl;}
};// 高层模块
class DataProcessor {DataReader& reader;Writer& writer;
public:DataProcessor(DataReader& r, Writer& w) : reader(r), writer(w) {}void process() {std::string data = reader.readData();writer.write(data);}
};// 调用示例
int main() {FileDataReader fileReader;DatabaseDataReader dbReader;NetworkDataReader netReader;ConsoleWriter consoleWriter;FileWriter fileWriter;DataProcessor fileProcessor(fileReader, consoleWriter);DataProcessor dbProcessor(dbReader, fileWriter);DataProcessor netProcessor(netReader, consoleWriter);fileProcessor.process();dbProcessor.process();netProcessor.process();return 0;
}

解释

1. 抽象层 ：DataReader 和 Writer 是两个抽象类，定义了 readData 和 write 方法。

2. 具体实现 ：FileDataReader、DatabaseDataReader 和 NetworkDataReader 实现了 DataReader 接口。ConsoleWriter 和 FileWriter 实现了 Writer 接口。

3. 高层模块 ：DataProcessor 类依赖于 DataReader 和 Writer 接口，实现数据读取和写入的逻辑。

4. 调用示例 ：在 main 函数中，创建了不同的具体实现对象，并传递给 DataProcessor 类，分别模拟了从文件、数据库和网络读取数据并写入控制台或文件。

输出：

Writing to console: Data from file
Writing to file: Data from database
Writing to console: Data from network

在这种设计中，DataProcessor 类依赖于抽象的 DataReader 接口，而不是具体的 FileDataReader、DatabaseDataReader 或 NetworkDataReader 类。这样，如果我们需要添加新的数据源，只需要实现 DataReader 接口，而不需要修改 DataProcessor 类。

抽象不应该依赖于细节。细节应该依赖于抽象。

这条原则的意思是，抽象层应该保持独立，不受具体实现的影响。具体实现（低层模块）应该依赖于抽象层，而不是反过来。

如果抽象层依赖于具体实现，那么抽象层的改变将导致具体实现的改变，从而违反了依赖倒置原则。希望抽象层稳定，具体实现可以随时更换，而不影响抽象层和高层模块的代码。

举例说明

假设在设计一个日志系统，日志可以输出到控制台、文件或远程服务器。

#include <iostream>
#include <string>// 抽象层
class ILogger {
public:virtual void log(const std::string& message) = 0;virtual ~ILogger() = default;
};// 具体实现
class ConsoleLogger : public ILogger {
public:void log(const std::string& message) override {std::cout << "Console Log: " << message << std::endl;}
};class FileLogger : public ILogger {
public:void log(const std::string& message) override {// 模拟写入文件std::cout << "File Log: " << message << std::endl;}
};class RemoteLogger : public ILogger {
public:void log(const std::string& message) override {// 模拟发送到远程服务器std::cout << "Remote Log: " << message << std::endl;}
};// 高层模块
class Logger {ILogger& logger;
public:Logger(ILogger& l) : logger(l) {}void log(const std::string& message) {logger.log(message);}
};// 调用示例
int main() {ConsoleLogger consoleLogger;FileLogger fileLogger;RemoteLogger remoteLogger;Logger logger1(consoleLogger);Logger logger2(fileLogger);Logger logger3(remoteLogger);logger1.log("This is a console log message.");logger2.log("This is a file log message.");logger3.log("This is a remote log message.");return 0;
}

解释

1. 抽象层 ：ILogger 是一个抽象类，定义了 log 方法。

2. 具体实现 ：ConsoleLogger、FileLogger 和 RemoteLogger 类实现了 ILogger 接口，分别将日志输出到控制台、文件和远程服务器。

3. 高层模块 ：Logger 类依赖于 ILogger 接口，实现日志记录的逻辑。

4. 调用示例 ：在 main 函数中，创建了不同的具体实现对象，并传递给 Logger 类，分别模拟了不同的日志记录方式。

输出：

Console Log: This is a console log message.
File Log: This is a file log message.
Remote Log: This is a remote log message.

在这种设计中，ILogger 是一个抽象接口，ConsoleLogger、FileLogger 和 RemoteLogger 类实现了这个接口。Logger 类依赖于抽象的 ILogger 接口，而不是具体的实现。这样，如果需要添加新的日志输出方式，只需要实现 ILogger 接口，而不需要修改 Logger 类。