I: Principio de Segregación de Interfaces (ISP)#

Definición#

El Interface Segregation Principle (ISP) establece que: “Los clientes no deben estar obligados a depender de métodos que no utilizan.”

Idea clave#

Las interfaces deben ser específicas y pequeñas.
Una interfaz “gorda” con muchos métodos obliga a que las clases implementen cosas que no necesitan.
Mejor dividir interfaces en partes más refinadas y que las clases implementen solo lo que realmente usan.

Ejemplo general (Cloud Providers)#

Antes (violando ISP)#

Una única interfaz muy amplia:

1
classDiagram
2
    direction LR
3
    class CloudProvider {
4
        <<interface>>
5
        + storeFile(name)
6
        + getFile(name)
7
        + createServer(region)
8
        + listServers(region)
9
        + getCDNAddress()
10
    }
11

12
    class Amazon {
13
        + storeFile(name)
14
        + getFile(name)
15
        + createServer(region)
16
        + listServers(region)
17
        + getCDNAddress()
18
    }
19

20
    class Dropbox {
21
        + storeFile(name)
22
        + getFile(name)
23
        + createServer(region)
24
        + listServers(region)
25
        + getCDNAddress()
26
    }
27

28
    CloudProvider <|.. Amazon
29
    CloudProvider <|.. Dropbox
30

31
    note for Dropbox "❌ Métodos de hosting y CDN no aplican"

Después (aplicando ISP)#

Interfaces divididas en partes más pequeñas:

1
classDiagram
2
    class CloudHostingProvider {
3
        <<interface>>
4
        +createServer(region)
5
        +listServers(region)
6
    }
7

8
    class CDNProvider {
9
        <<interface>>
10
        +getCDNAddress()
11
    }
12

13
    class CloudStorageProvider {
14
        <<interface>>
15
        +storeFile(name)
16
        +getFile(name)
17
    }
18

19
    class Amazon {
20
        +storeFile(name)
21
        +getFile(name)
22
        +createServer(region)
23
        +listServers(region)
24
        +getCDNAddress()
25
    }
26

27
    class Dropbox {
28
        +storeFile(name)
29
        +getFile(name)
30
    }
31

32
    CloudHostingProvider <|.. Amazon
33
    CDNProvider <|.. Amazon
34
    CloudStorageProvider <|.. Amazon
35
    CloudStorageProvider <|.. Dropbox

Ejemplo en Spring Boot (Java)#

Antes (violando ISP)#

1
public interface CloudProvider {
2
    void storeFile(String name);
3
    String getFile(String name);
4
    void createServer(String region);
5
    void listServers(String region);
6
    String getCDNAddress();
7
}
8

9
public class Dropbox implements CloudProvider {
10
    @Override
11
    public void storeFile(String name) { ... }
12
    @Override
13
    public String getFile(String name) { ... }
14

15
    // Métodos que no aplican
16
    @Override
17
    public void createServer(String region) {
18
        throw new UnsupportedOperationException("No soportado.");
19
    }
20
    @Override
21
    public void listServers(String region) {
22
        throw new UnsupportedOperationException("No soportado.");
23
    }
24
    @Override
25
    public String getCDNAddress() {
26
        throw new UnsupportedOperationException("No soportado.");
27
    }
28
}

Después (aplicando ISP)#

1
public interface CloudStorageProvider {
2
    void storeFile(String name);
3
    String getFile(String name);
4
}
5

6
public interface CloudHostingProvider {
7
    void createServer(String region);
8
    void listServers(String region);
9
}
10

11
public interface CDNProvider {
12
    String getCDNAddress();
13
}
14

15
public class Dropbox implements CloudStorageProvider {
16
    @Override
17
    public void storeFile(String name) { ... }
18
    @Override
19
    public String getFile(String name) { ... }
20
}

Ejemplo en Django (Python)#

Antes (violando ISP)#

1
class CloudProvider:
2
    def store_file(self, name): pass
3
    def get_file(self, name): pass
4
    def create_server(self, region): pass
5
    def list_servers(self, region): pass
6
    def get_cdn_address(self): pass
7

8
class Dropbox(CloudProvider):
9
    def store_file(self, name): ...
10
    def get_file(self, name): ...
11
    # Métodos que no aplican
12
    def create_server(self, region): raise NotImplementedError
13
    def list_servers(self, region): raise NotImplementedError
14
    def get_cdn_address(self): raise NotImplementedError

Después (aplicando ISP)#

1
class CloudStorageProvider:
2
    def store_file(self, name): pass
3
    def get_file(self, name): pass
4

5
class CloudHostingProvider:
6
    def create_server(self, region): pass
7
    def list_servers(self, region): pass
8

9
class CDNProvider:
10
    def get_cdn_address(self): pass
11

12
class Dropbox(CloudStorageProvider):
13
    def store_file(self, name): ...
14
    def get_file(self, name): ...

Conclusión#

El ISP evita interfaces infladas y asegura que:

Los clientes solo implementan lo que realmente necesitan.
El código es más modular, flexible y limpio.