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

Patrones de Diseño

Siguiente ►
►

Introducción

Los patrones de diseño son soluciones reutilizables a problemas comunes que surgen en el desarrollo de software. Estos patrones proporcionan una forma estandarizada de abordar problemas de diseño y ayudan a crear sistemas más robustos, mantenibles y escalables. En esta sección, exploraremos los patrones de diseño más comunes y cómo aplicarlos en la arquitectura de sistemas.

¿Qué es un Patrón de Diseño?

Un patrón de diseño es una descripción o plantilla para resolver un problema que puede ser utilizado en diferentes situaciones. Los patrones de diseño no son soluciones completas, sino guías que ayudan a resolver problemas específicos de diseño.

Características de los Patrones de Diseño

  • Reutilizables: Pueden ser aplicados en diferentes contextos y proyectos.
  • Probados: Han sido utilizados y probados en múltiples escenarios.
  • Documentados: Están bien documentados y son fáciles de entender y aplicar.

Clasificación de los Patrones de Diseño

Los patrones de diseño se clasifican generalmente en tres categorías principales:

  1. Patrones Creacionales: Se enfocan en la creación de objetos.
  2. Patrones Estructurales: Se enfocan en la composición de clases y objetos.
  3. Patrones de Comportamiento: Se enfocan en la interacción y responsabilidad entre objetos.

Patrones Creacionales

  1. Singleton: Asegura que una clase tenga solo una instancia y proporciona un punto de acceso global a ella.
  2. Factory Method: Define una interfaz para crear un objeto, pero permite a las subclases alterar el tipo de objeto que se creará.
  3. Abstract Factory: Proporciona una interfaz para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas.
  4. Builder: Separa la construcción de un objeto complejo de su representación, permitiendo crear diferentes representaciones.
  5. Prototype: Permite crear nuevos objetos copiando un objeto existente, conocido como prototipo.

Patrones Estructurales

  1. Adapter: Permite que clases con interfaces incompatibles trabajen juntas.
  2. Bridge: Desacopla una abstracción de su implementación, permitiendo que ambas varíen independientemente.
  3. Composite: Permite tratar objetos individuales y composiciones de objetos de manera uniforme.
  4. Decorator: Añade responsabilidades adicionales a un objeto de manera dinámica.
  5. Facade: Proporciona una interfaz simplificada a un conjunto de interfaces en un subsistema.
  6. Flyweight: Utiliza el almacenamiento compartido para soportar grandes cantidades de objetos de grano fino de manera eficiente.
  7. Proxy: Proporciona un sustituto o marcador de posición para otro objeto para controlar el acceso a él.

Patrones de Comportamiento

  1. Chain of Responsibility: Permite que más de un objeto maneje una solicitud, pasando la solicitud a lo largo de una cadena de manejadores.
  2. Command: Encapsula una solicitud como un objeto, permitiendo parametrizar a los clientes con diferentes solicitudes, colas o registros de solicitudes.
  3. Interpreter: Proporciona una manera de evaluar el lenguaje o gramática.
  4. Iterator: Proporciona una manera de acceder secuencialmente a los elementos de un objeto agregado sin exponer su representación subyacente.
  5. Mediator: Define un objeto que encapsula cómo interactúan un conjunto de objetos.
  6. Memento: Permite capturar y externalizar el estado interno de un objeto sin violar la encapsulación.
  7. Observer: Define una dependencia de uno a muchos entre objetos para que cuando un objeto cambie de estado, todos sus dependientes sean notificados y actualizados automáticamente.
  8. State: Permite que un objeto altere su comportamiento cuando su estado interno cambia.
  9. Strategy: Define una familia de algoritmos, encapsula cada uno de ellos y los hace intercambiables.
  10. Template Method: Define el esqueleto de un algoritmo en una operación, diferiendo algunos pasos a las subclases.
  11. Visitor: Representa una operación que se va a realizar en los elementos de una estructura de objetos.

Ejemplos Prácticos

Ejemplo de Singleton

El patrón Singleton asegura que una clase tenga solo una instancia y proporciona un punto de acceso global a ella.

class Singleton:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

# Uso del Singleton
singleton1 = Singleton()
singleton2 = Singleton()

print(singleton1 is singleton2)  # True

Ejemplo de Factory Method

El patrón Factory Method define una interfaz para crear un objeto, pero permite a las subclases alterar el tipo de objeto que se creará.

from abc import ABC, abstractmethod

class Product(ABC):
    @abstractmethod
    def operation(self):
        pass

class ConcreteProductA(Product):
    def operation(self):
        return "Result of ConcreteProductA"

class ConcreteProductB(Product):
    def operation(self):
        return "Result of ConcreteProductB"

class Creator(ABC):
    @abstractmethod
    def factory_method(self):
        pass

    def some_operation(self):
        product = self.factory_method()
        return f"Creator: The same creator's code has just worked with {product.operation()}"

class ConcreteCreatorA(Creator):
    def factory_method(self):
        return ConcreteProductA()

class ConcreteCreatorB(Creator):
    def factory_method(self):
        return ConcreteProductB()

# Uso del Factory Method
creator_a = ConcreteCreatorA()
print(creator_a.some_operation())

creator_b = ConcreteCreatorB()
print(creator_b.some_operation())

Ejercicios Prácticos

Ejercicio 1: Implementar el Patrón Decorator

Descripción: Implementa el patrón Decorator para añadir funcionalidades adicionales a una clase Coffee.

Requisitos:

  1. Crea una clase base Coffee con un método cost().
  2. Crea una clase SimpleCoffee que herede de Coffee y devuelva un costo base.
  3. Crea decoradores Milk y Sugar que añadan costo adicional al café.

Solución:

class Coffee:
    def cost(self):
        pass

class SimpleCoffee(Coffee):
    def cost(self):
        return 5

class CoffeeDecorator(Coffee):
    def __init__(self, coffee):
        self._coffee = coffee

    def cost(self):
        return self._coffee.cost()

class Milk(CoffeeDecorator):
    def cost(self):
        return self._coffee.cost() + 2

class Sugar(CoffeeDecorator):
    def cost(self):
        return self._coffee.cost() + 1

# Uso del Decorator
simple_coffee = SimpleCoffee()
print(f"Cost of Simple Coffee: {simple_coffee.cost()}")

milk_coffee = Milk(simple_coffee)
print(f"Cost of Coffee with Milk: {milk_coffee.cost()}")

sugar_milk_coffee = Sugar(milk_coffee)
print(f"Cost of Coffee with Milk and Sugar: {sugar_milk_coffee.cost()}")

Ejercicio 2: Implementar el Patrón Observer

Descripción: Implementa el patrón Observer para un sistema de notificaciones.

Requisitos:

  1. Crea una clase Subject que mantenga una lista de observadores y notifique cambios.
  2. Crea una clase Observer con un método update().
  3. Implementa una clase concreta ConcreteObserver que imprima un mensaje cuando se actualice.

Solución:

class Subject:
    def __init__(self):
        self._observers = []

    def attach(self, observer):
        self._observers.append(observer)

    def detach(self, observer):
        self._observers.remove(observer)

    def notify(self):
        for observer in self._observers:
            observer.update()

class Observer:
    def update(self):
        pass

class ConcreteObserver(Observer):
    def update(self):
        print("Observer has been notified!")

# Uso del Observer
subject = Subject()
observer1 = ConcreteObserver()
observer2 = ConcreteObserver()

subject.attach(observer1)
subject.attach(observer2)

subject.notify()

Conclusión

En esta sección, hemos explorado los patrones de diseño más comunes y cómo aplicarlos en la arquitectura de sistemas. Los patrones de diseño son herramientas poderosas que pueden ayudar a crear sistemas más robustos, mantenibles y escalables. Asegúrate de practicar estos patrones y aplicarlos en tus proyectos para mejorar tus habilidades de diseño de software.

En el siguiente módulo, profundizaremos en los componentes de una arquitectura de sistemas, donde aprenderemos sobre las capas de una arquitectura, la comparación entre microservicios y monolitos, y las bases de datos y almacenamiento.

◄ Anterior
◄
Siguiente ►
►

Arquitecturas de Sistemas: Principios y Prácticas para Diseñar Arquitecturas Tecnológicas Robustas y Escalables

Módulo 1: Introducción a las Arquitecturas de Sistemas

Módulo 2: Principios de Diseño de Arquitecturas

Módulo 3: Componentes de una Arquitectura de Sistemas

Módulo 4: Escalabilidad y Rendimiento

Módulo 5: Seguridad en Arquitecturas de Sistemas

Módulo 6: Herramientas y Tecnologías

Módulo 7: Casos de Estudio y Ejemplos Prácticos

Módulo 8: Tendencias y Futuro de las Arquitecturas de Sistemas

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