D: Principio de Inversión de Dependencias (DIP)#

Definición#

El Dependency Inversion Principle (DIP) establece: “Las clases de alto nivel no deben depender de clases de bajo nivel. Ambas deben depender de abstracciones.”

Idea clave#

Alto nivel: contiene la lógica de negocio.
Bajo nivel: operaciones técnicas (BD, red, archivos, etc.).
Problema: si el alto nivel depende directamente del bajo nivel, cualquier cambio en la infraestructura afecta la lógica de negocio.
Solución:
1. Crear una abstracción (interfaz).
2. Hacer que el alto nivel dependa de esa abstracción.
3. Hacer que las clases de bajo nivel implementen la abstracción.

Ejemplo general#

Antes (violando DIP)#

1
classDiagram
2
    direction LR
3

4
    subgraph Alto nivel
5
        class BudgetReport {
6
            -database
7
            +open(date)
8
            +save()
9
        }
10
    end
11

12
    subgraph Bajo nivel
13
        class MySQLDatabase {
14
            +insert()
15
            +update()
16
            +delete()
17
        }
18
    end
19

20
    BudgetReport --> MySQLDatabase

Después (aplicando DIP)#

1
classDiagram
2
    subgraph Alto nivel
3
        class BudgetReport {
4
            -database
5
            +open(date)
6
            +save()
7
        }
8
        subgraph Abstracción
9
            class Database {
10
                <<interface>>
11
                +insert()
12
                +update()
13
                +delete()
14
            }
15
        end
16
    end
17

18
    subgraph Bajo nivel
19
        class MySQL {
20
            +insert()
21
            +update()
22
            +delete()
23
        }
24
        class MongoDB {
25
            +insert()
26
            +update()
27
            +delete()
28
        }
29
    end
30

31
    BudgetReport --> Database
32
    Database <|.. MySQL
33
    Database <|.. MongoDB

Ejemplo en Spring Boot (Java)#

Antes (violando DIP)#

1
public class BudgetReport {
2
    private MySQLDatabase database = new MySQLDatabase();
3

4
    public void save() {
5
        database.insert("report data");
6
    }
7
}
8

9
public class MySQLDatabase {
10
    public void insert(String data) { /* código MySQL */ }
11
}

Después (aplicando DIP con interfaces)#

1
// Abstracción
2
public interface Database {
3
    void insert(String data);
4
}
5

6
// Implementación de bajo nivel
7
public class MySQLDatabase implements Database {
8
    @Override
9
    public void insert(String data) { /* código MySQL */ }
10
}
11

12
public class MongoDatabase implements Database {
13
    @Override
14
    public void insert(String data) { /* código MongoDB */ }
15
}
16

17
// Clase de alto nivel depende de la abstracción
18
public class BudgetReport {
19
    private final Database database;
20

21
    // Inyección de dependencias
22
    public BudgetReport(Database database) {
23
        this.database = database;
24
    }
25

26
    public void save() {
27
        database.insert("report data");
28
    }
29
}

En Spring Boot, la inyección se hace automática con @Autowired.

Ejemplo en Django (Python)#

Antes (violando DIP)#

1
class MySQLDatabase:
2
    def insert(self, data):
3
        print(f"Inserción en MySQL: {data}")
4

5
class BudgetReport:
6
    def __init__(self):
7
        self.database = MySQLDatabase()  # Alto nivel depende de bajo nivel
8

9
    def save(self):
10
        self.database.insert("report data")

Después (aplicando DIP con abstracción)#

1
from abc import ABC, abstractmethod
2

3
# Abstracción
4
class Database(ABC):
5
    @abstractmethod
6
    def insert(self, data): pass
7

8
# Implementaciones de bajo nivel
9
class MySQLDatabase(Database):
10
    def insert(self, data):
11
        print(f"Inserción en MySQL: {data}")
12

13
class MongoDatabase(Database):
14
    def insert(self, data):
15
        print(f"Inserción en MongoDB: {data}")
16

17
# Alto nivel depende de la abstracción
18
class BudgetReport:
19
    def __init__(self, database: Database):
20
        self.database = database
21

22
    def save(self):
23
        self.database.insert("report data")
24

25
# Uso
26
report = BudgetReport(MongoDatabase())
27
report.save()  # Inserción en MongoDB: report data

Conclusión#

El DIP asegura que:

La lógica de negocio (alto nivel) no depende de los detalles técnicos (bajo nivel).
Ambos dependen de una abstracción común.
Facilita el cambio de implementaciones (ej. de MySQL a MongoDB) sin modificar el código de alto nivel.