1
classDiagram
2
    direction TB
3

4
    class Remote {
5
        -device: Device
6
        +togglePower()
7
        +volumeUp()
8
    }
9
    note for Remote "Abstracción: Define la interfaz de alto nivel."
10

11
    class Device {
12
        <<Interface>>
13
        +isEnabled()
14
        +enable()
15
        +disable()
16
        +setVolume(percent)
17
    }
18
    note for Device "Implementación: Define la interfaz para el trabajo real."
19

20
    class AdvancedRemote {
21
        +mute()
22
    }
23

24
    class TV {
25
        +enable()
26
        +setVolume(p)
27
    }
28
    class Radio {
29
        +enable()
30
        +setVolume(p)
31
    }
32

33
    Remote o-- Device : tiene un (el puente)
34
    Remote <|-- AdvancedRemote
35
    Device <|.. TV
36
    Device <|.. Radio

1
// Implementación (Interfaz)
2
public interface CanalDeEnvio {
3
    void enviarMensaje(String asunto, String mensaje);
4
}
5

6
// Implementaciones Concretas
7
public class CanalEmail implements CanalDeEnvio {
8
    public void enviarMensaje(String a, String m) { /* Lógica para enviar email */ }
9
}
10
public class CanalSMS implements CanalDeEnvio {
11
    public void enviarMensaje(String a, String m) { /* Lógica para enviar SMS */ }
12
}
13

14
// Abstracción
15
public abstract class Notificacion {
16
    protected CanalDeEnvio canal; // El puente
17

18
    public Notificacion(CanalDeEnvio canal) {
19
        this.canal = canal;
20
    }
21
    public abstract void notificar();
22
}
23

24
// Abstracción Refinada
25
public class NotificacionUrgente extends Notificacion {
26
    public NotificacionUrgente(CanalDeEnvio canal) { super(canal); }
27

28
    @Override
29
    public void notificar() {
30
        canal.enviarMensaje("¡URGENTE!", "Este es un mensaje crítico.");
31
    }
32
}
33

34
// Cliente
35
@Service
36
public class SistemaDeAlertas {
37
    public void ejecutar() {
38
        // El cliente elige qué implementación usar con qué abstracción
39
        CanalDeEnvio email = new CanalEmail();
40
        Notificacion notificacionUrgentePorEmail = new NotificacionUrgente(email);
41
        notificacionUrgentePorEmail.notificar();
42

43
        CanalDeEnvio sms = new CanalSMS();
44
        Notificacion notificacionUrgentePorSMS = new NotificacionUrgente(sms);
45
        notificacionUrgentePorSMS.notificar();
46
    }
47
}

1
from abc import ABC, abstractmethod
2

3
# Implementación (Interfaz)
4
class CanalDeEnvio(ABC):
5
    @abstractmethod
6
    def enviar_mensaje(self, asunto: str, mensaje: str) -> str:
7
        pass
8

9
# Implementaciones Concretas
10
class CanalEmail(CanalDeEnvio):
11
    def enviar_mensaje(self, asunto, mensaje):
12
        return f"Email enviado: '{asunto}' - '{mensaje}'"
13

14
class CanalSMS(CanalDeEnvio):
15
    def enviar_mensaje(self, asunto, mensaje):
16
        return f"SMS enviado: '{mensaje}' (Asunto ignorado)"
17

18
# Abstracción
19
class Notificacion(ABC):
20
    def __init__(self, canal: CanalDeEnvio):
21
        self._canal = canal  # El puente
22

23
    @abstractmethod
24
    def notificar(self) -> str:
25
        pass
26

27
# Abstracción Refinada
28
class NotificacionUrgente(Notificacion):
29
    def notificar(self) -> str:
30
        return self._canal.enviar_mensaje("¡URGENTE!", "Este es un mensaje crítico.")
31

32
# Cliente (una vista de Django)
33
from django.http import JsonResponse
34

35
def enviar_alerta_view(request, canal_tipo: str):
36
    if canal_tipo == "email":
37
        canal = CanalEmail()
38
    elif canal_tipo == "sms":
39
        canal = CanalSMS()
40
    else:
41
        return JsonResponse({"error": "Canal no válido"}, status=400)
42

43
    # El cliente conecta la abstracción con la implementación
44
    notificacion = NotificacionUrgente(canal)
45
    resultado = notificacion.notificar()
46

47
    return JsonResponse({"resultado": resultado})

1
package com.example.solid.bridgeejemplo.controller;
2

3
import com.example.solid.bridgeejemplo.abstraccion.Notificacion;
4
import com.example.solid.bridgeejemplo.abstraccion.NotificacionNormal;
5
import com.example.solid.bridgeejemplo.abstraccion.NotificacionUrgente;
6
import com.example.solid.bridgeejemplo.implementacion.CanalDeEnvio;
7
import org.springframework.http.ResponseEntity;
8
import org.springframework.web.bind.annotation.GetMapping;
9
import org.springframework.web.bind.annotation.PathVariable;
10
import org.springframework.web.bind.annotation.RequestMapping;
11
import org.springframework.web.bind.annotation.RestController;
12

13
import java.util.Map;
14

15
@RestController
16
@RequestMapping("/api/notificaciones")
17
public class NotificacionController {
18

19
    private final Map<String, CanalDeEnvio> canales;
20

21
    public NotificacionController(Map<String, CanalDeEnvio> canales) {
22
        this.canales = canales;
23
    }
24

25
    @GetMapping("/enviar/{tipoNotificacion}/{tipoCanal}")
26
    public ResponseEntity<String> enviarNotificacion(@PathVariable String tipoNotificacion, @PathVariable String tipoCanal) {
27
        CanalDeEnvio canal = canales.get(tipoCanal);
28
        if (canal == null) {
29
            return ResponseEntity.badRequest().body("El canal no es válido.");
30
        }
31

32
        Notificacion notificacion;
33
        String mensaje = "Revisar el estado del sistema.";
34

35
        // El cliente elige qué abstracción usar
36
        if ("urgente".equalsIgnoreCase(tipoNotificacion)) {
37
            notificacion = new NotificacionUrgente(canal);
38
        } else if ("normal".equalsIgnoreCase(tipoNotificacion)) {
39
            notificacion = new NotificacionNormal(canal);
40
        } else {
41
            return ResponseEntity.badRequest().body("El tipo de notificación no es válido.");
42
        }
43

44
        // El cliente "conecta" la abstracción con la implementación
45
        String resultado = notificacion.notificar(mensaje);
46
        return ResponseEntity.ok(resultado);
47
    }
48
}

1
from django.http import JsonResponse
2
from .implementacion import CanalEmail, CanalSMS
3
from .abstraccion import NotificacionNormal, NotificacionUrgente
4

5
CANALES = {"email": CanalEmail, "sms": CanalSMS}
6
NOTIFICACIONES = {"normal": NotificacionNormal, "urgente": NotificacionUrgente}
7

8
def enviar_notificacion(request, tipo_notificacion: str, tipo_canal: str):
9
    canal_class = CANALES.get(tipo_canal)
10
    notificacion_class = NOTIFICACIONES.get(tipo_notificacion)
11

12
    if not canal_class or not notificacion_class:
13
        return JsonResponse({"error": "Tipo de canal o notificación no válido"}, status=400)
14

15
    # El cliente conecta la implementación con la abstracción
16
    canal = canal_class()
17
    notificacion = notificacion_class(canal)
18

19
    mensaje = "Revisar el estado del sistema."
20
    resultado = notificacion.notificar(mensaje)
21

22
    return JsonResponse({"resultado": resultado})