依赖倒置原则（DIP）
- 应用场景：高层模块不应该依赖低层模块，二者都应该依赖抽象；抽象不应该依赖细节，细节应该依赖抽象。例如，在一个电商系统中，订单服务（高层模块）不应该直接依赖具体的数据库操作类（低层模块），而是应该依赖一个抽象的数据库接口，这样当数据库类型发生变化时，订单服务不需要修改。
- 示例代码
- Java
// 抽象数据库接口
interface Database {
void saveData(String data);
}
// 具体数据库实现类：MySQL
class MySQLDatabase implements Database {
@Override
public void saveData(String data) {
System.out.println("Saving data to MySQL: " + data);
}
}
// 具体数据库实现类：Oracle
class OracleDatabase implements Database {
@Override
public void saveData(String data) {
System.out.println("Saving data to Oracle: " + data);
}
}
// 高层模块：订单服务
class OrderService {
private Database database;
public OrderService(Database database) {
this.database = database;
}
public void saveOrder(String orderData) {
database.saveData(orderData);
}
}
public class Main {
public static void main(String[] args) {
Database mysqlDB = new MySQLDatabase();
OrderService orderServiceWithMySQL = new OrderService(mysqlDB);
orderServiceWithMySQL.saveOrder("Order 1 data");
Database oracleDB = new OracleDatabase();
OrderService orderServiceWithOracle = new OrderService(oracleDB);
orderServiceWithOracle.saveOrder("Order 2 data");
}
}- **Python**from abc import ABC, abstractmethod
# 抽象数据库接口
class Database(ABC):
@abstractmethod
def save_data(self, data):
pass
# 具体数据库实现类：MySQL
class MySQLDatabase(Database):
def save_data(self, data):
print(f"Saving data to MySQL: {data}")
# 具体数据库实现类：Oracle
class OracleDatabase(Database):
def save_data(self, data):
print(f"Saving data to Oracle: {data}")
# 高层模块：订单服务
class OrderService:
def __init__(self, database):
self.database = database
def save_order(self, order_data):
self.database.save_data(order_data)
if __name__ == "__main__":
mysql_db = MySQLDatabase()
order_service_with_mysql = OrderService(mysql_db)
order_service_with_mysql.save_order("Order 1 data")
oracle_db = OracleDatabase()
order_service_with_oracle = OrderService(oracle_db)
order_service_with_oracle.save_order("Order 2 data")
- **PHP**database = $database;
}
public function saveOrder($orderData) {
$this->database->saveData($orderData);
}
}
$mysqlDB = new MySQLDatabase();
$orderServiceWithMySQL = new OrderService($mysqlDB);
$orderServiceWithMySQL->saveOrder("Order 1 data");
$oracleDB = new OracleDatabase();
$orderServiceWithOracle = new OrderService($oracleDB);
$orderServiceWithOracle->saveOrder("Order 2 data");
?>
- **C#**using System;
// 抽象数据库接口
interface IDatabase
{
void SaveData(string data);
}
// 具体数据库实现类：MySQL
class MySQLDatabase : IDatabase
{
public void SaveData(string data)
{
Console.WriteLine("Saving data to MySQL: " + data);
}
}
// 具体数据库实现类：Oracle
class OracleDatabase : IDatabase
{
public void SaveData(string data)
{
Console.WriteLine("Saving data to Oracle: " + data);
}
}
// 高层模块：订单服务
class OrderService
{
private IDatabase database;
public OrderService(IDatabase database)
{
this.database = database;
}
public void SaveOrder(string orderData)
{
database.SaveData(orderData);
}
}
class Program
{
static void Main()
{
IDatabase mysqlDB = new MySQLDatabase();
OrderService orderServiceWithMySQL = new OrderService(mysqlDB);
orderServiceWithMySQL.SaveOrder("Order 1 data");
IDatabase oracleDB = new OracleDatabase();
OrderService orderServiceWithOracle = new OrderService(oracleDB);
orderServiceWithOracle.SaveOrder("Order 2 data");
}
}
- **Go**package main
import "fmt"
// 抽象数据库接口
type Database interface {
SaveData(data string)
}
// 具体数据库实现类：MySQL
type MySQLDatabase struct{}
func (m MySQLDatabase) SaveData(data string) {
fmt.Printf("Saving data to MySQL: %s\n", data)
}
// 具体数据库实现类：Oracle
type OracleDatabase struct{}
func (o OracleDatabase) SaveData(data string) {
fmt.Printf("Saving data to Oracle: %s\n", data)
}
// 高层模块：订单服务
type OrderService struct {
database Database
}
func NewOrderService(database Database) *OrderService {
return &OrderService{database: database}
}
func (os *OrderService) SaveOrder(orderData string) {
os.database.SaveData(orderData)
}
func main() {
mysqlDB := MySQLDatabase{}
orderServiceWithMySQL := NewOrderService(mysqlDB)
orderServiceWithMySQL.SaveOrder("Order 1 data")
oracleDB := OracleDatabase{}
orderServiceWithOracle := NewOrderService(oracleDB)
orderServiceWithOracle.SaveOrder("Order 2 data")
}
- **JavaScript**// 抽象数据库接口
class Database {
saveData(data) {
throw new Error('This method must be implemented!');
}
}
// 具体数据库实现类：MySQL
class MySQLDatabase extends Database {
saveData(data) {
console.log(`Saving data to MySQL: ${data}`);
}
}
// 具体数据库实现类：Oracle
class OracleDatabase extends Database {
saveData(data) {
console.log(`Saving data to Oracle: ${data}`);
}
}
// 高层模块：订单服务
class OrderService {
constructor(database) {
this.database = database;
}
saveOrder(orderData) {
this.database.saveData(orderData);
}
}
const mysqlDB = new MySQLDatabase();
const orderServiceWithMySQL = new OrderService(mysqlDB);
orderServiceWithMySQL.saveOrder('Order 1 data');
const oracleDB = new OracleDatabase();
const orderServiceWithOracle = new OrderService(oracleDB);
orderServiceWithOracle.saveOrder('Order 2 data');
这些设计模式和设计原则是软件开发中非常重要的基础知识，合理运用它们可以提高代码的可维护性、可扩展性和可复用性。