El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Mediator

Siguiente ►
►

Introducción

El patrón Mediator es un patrón de diseño de comportamiento que se utiliza para reducir las dependencias entre los objetos de un programa. En lugar de que los objetos se comuniquen directamente entre sí, se comunican a través de un objeto mediador. Este patrón promueve el principio de "comunicación indirecta" y ayuda a mantener un diseño más limpio y manejable.

Objetivos del Patrón Mediator

  • Reducir las dependencias entre los objetos: Los objetos no necesitan conocer los detalles de otros objetos para interactuar con ellos.
  • Facilitar la comunicación entre objetos: Centraliza la comunicación en un único punto, lo que simplifica la gestión de las interacciones.
  • Mejorar la mantenibilidad: Al reducir las dependencias, es más fácil modificar y extender el sistema.

Ejemplo Práctico

Imaginemos un sistema de chat donde varios usuarios pueden enviar mensajes entre sí. Sin el patrón Mediator, cada usuario tendría que conocer a todos los demás usuarios para enviarles mensajes directamente. Con el patrón Mediator, los usuarios solo necesitan conocer al mediador, que se encargará de distribuir los mensajes.

Diagrama de Clases

+-------------------+
|     Mediator      |
+-------------------+
| +sendMessage()    |
| +addUser()        |
+-------------------+
          |
          v
+-------------------+
| ConcreteMediator  |
+-------------------+
| -users: List<User>|
+-------------------+
| +sendMessage()    |
| +addUser()        |
+-------------------+
          |
          v
+-------------------+
|       User        |
+-------------------+
| -name: String     |
| -mediator: Mediator|
+-------------------+
| +send()           |
| +receive()        |
+-------------------+

Implementación en Código

A continuación, se muestra una implementación en Python del patrón Mediator:

class Mediator:
    def send_message(self, message, user):
        pass

    def add_user(self, user):
        pass

class ConcreteMediator(Mediator):
    def __init__(self):
        self.users = []

    def add_user(self, user):
        self.users.append(user)

    def send_message(self, message, user):
        for u in self.users:
            if u != user:
                u.receive(message)

class User:
    def __init__(self, name, mediator):
        self.name = name
        self.mediator = mediator

    def send(self, message):
        print(f"{self.name} sends: {message}")
        self.mediator.send_message(message, self)

    def receive(self, message):
        print(f"{self.name} receives: {message}")

# Uso del patrón Mediator
mediator = ConcreteMediator()

user1 = User("Alice", mediator)
user2 = User("Bob", mediator)
user3 = User("Charlie", mediator)

mediator.add_user(user1)
mediator.add_user(user2)
mediator.add_user(user3)

user1.send("Hello, everyone!")

Explicación del Código

  1. Clase Mediator: Define la interfaz para enviar mensajes y agregar usuarios.
  2. Clase ConcreteMediator: Implementa la interfaz Mediator y mantiene una lista de usuarios. Gestiona la distribución de mensajes entre los usuarios.
  3. Clase User: Representa a un usuario en el sistema de chat. Cada usuario tiene un nombre y una referencia al mediador. Los métodos send y receive permiten enviar y recibir mensajes a través del mediador.

Ejercicio Práctico

Implemente un sistema de control de tráfico aéreo utilizando el patrón Mediator. En este sistema, varios aviones se comunican con una torre de control para recibir instrucciones de aterrizaje y despegue.

Requisitos

  1. Clase Mediator: Define la interfaz para la comunicación entre aviones y la torre de control.
  2. Clase ConcreteMediator: Implementa la interfaz Mediator y gestiona la comunicación entre los aviones.
  3. Clase Airplane: Representa un avión en el sistema. Cada avión puede solicitar permiso para aterrizar o despegar a través del mediador.

Solución

class Mediator:
    def request_landing(self, airplane):
        pass

    def request_takeoff(self, airplane):
        pass

class ConcreteMediator(Mediator):
    def __init__(self):
        self.airplanes = []

    def add_airplane(self, airplane):
        self.airplanes.append(airplane)

    def request_landing(self, airplane):
        print(f"Torre de control: Permiso para aterrizar concedido a {airplane.name}")

    def request_takeoff(self, airplane):
        print(f"Torre de control: Permiso para despegar concedido a {airplane.name}")

class Airplane:
    def __init__(self, name, mediator):
        self.name = name
        self.mediator = mediator

    def request_landing(self):
        print(f"{self.name} solicita permiso para aterrizar.")
        self.mediator.request_landing(self)

    def request_takeoff(self):
        print(f"{self.name} solicita permiso para despegar.")
        self.mediator.request_takeoff(self)

# Uso del patrón Mediator
mediator = ConcreteMediator()

airplane1 = Airplane("Avión 1", mediator)
airplane2 = Airplane("Avión 2", mediator)

mediator.add_airplane(airplane1)
mediator.add_airplane(airplane2)

airplane1.request_landing()
airplane2.request_takeoff()

Explicación del Código

  1. Clase Mediator: Define la interfaz para solicitar aterrizajes y despegues.
  2. Clase ConcreteMediator: Implementa la interfaz Mediator y gestiona las solicitudes de aterrizaje y despegue.
  3. Clase Airplane: Representa un avión en el sistema. Cada avión puede solicitar permiso para aterrizar o despegar a través del mediador.

Conclusión

El patrón Mediator es una herramienta poderosa para gestionar la comunicación entre objetos en un sistema, reduciendo las dependencias y mejorando la mantenibilidad. Al centralizar la comunicación en un mediador, es más fácil modificar y extender el sistema sin afectar a los objetos individuales.

Resumen

  • Objetivo: Reducir las dependencias entre objetos y centralizar la comunicación.
  • Ventajas: Mejora la mantenibilidad y facilita la gestión de las interacciones.
  • Ejemplo: Sistema de chat y control de tráfico aéreo.
  • Ejercicio: Implementar un sistema de control de tráfico aéreo utilizando el patrón Mediator.

Con este conocimiento, estás listo para aplicar el patrón Mediator en tus propios proyectos y mejorar la estructura y mantenibilidad de tu código.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados