Python Cadena de Responsabilidad

El patrón Cadena de Responsabilidad es un patrón de diseño de comportamiento que te permite pasar solicitudes a lo largo de una cadena de manejadores. Al recibir una solicitud, cada manejador puede procesarla o pasarla al siguiente manejador de la cadena.

Analogía en la vida real

Imagina el proceso de aprobación de permisos en una empresa:

  • 1-3 días→ Aprobación del líder de equipo
  • 4-7 días→ Aprobación del gerente de departamento
  • Más de 8 días→ Aprobación del gerente general

Cuando envías una solicitud de permiso, esta se pasa a lo largo de la cadena hasta que encuentra a alguien con autoridad para procesarla. Esto es una manifestación real del patrón Cadena de Responsabilidad.

La idea central del patrón

Desacoplar el emisor y el receptor de la solicitud, permitiendo que múltiples objetos tengan la oportunidad de procesar la solicitud, evitando así el acoplamiento estrecho entre el emisor y el receptor.Estructura del patrón Cadena de Responsabilidad


Estructura del patrón Cadena de Responsabilidad

Descripción de los componentes principales

Descripción de los componentes principales

Define la interfaz para procesar solicitudes

  • Incluye un método para establecer el sucesor
  • Puede implementar el comportamiento predeterminado de la cadena de sucesores
  • ConcreteHandler (manejador concreto)

Implementa la lógica de procesamiento concreta

  • Si puede procesar la solicitud, la procesa
  • De lo contrario, reenvía la solicitud al sucesor
  • Implementación básica: sistema de aprobación de permisos

Implementación básica: sistema de aprobación de permisos

Paso 1: Definir el manejador abstracto

Paso 1: Definir el manejador abstracto

Ejemplo

from abc import ABC, abstractmethod
from typing import Optional

class Approver(ABC):
    """Establecer el aprobador sucesor"""
   
    def __init__(self, name: str):
        self.name = name
        self.successor: Optional['Approver'] = None
   
    def set_successor(self, successor: 'Approver'):
        """Método abstracto para procesar solicitudes de permiso"""
        self.successor = successor
   
    @abstractmethod
    def process_request(self, leave_request: 'LeaveRequest'):
        Paso 2: Definir el objeto de solicitud
        pass

Paso 2: Definir el objeto de solicitud

Ejemplo

from dataclasses import dataclass

@dataclass
class LeaveRequest:
    # Nombre del empleado
    employee_name: str    # Días de permiso
    leave_days: int       # Motivo del permiso
    reason: str           "{self.employee_name} solicita permiso por {self.leave_days} días, motivo: {self.reason}"
   
    def __str__(self):
        return fPaso 3: Implementar los manejadores concretos

Paso 3: Implementar los manejadores concretos

Ejemplo

class TeamLeader(Approver):
    "El líder de equipo {self.name} aprobó {leave_request}"
   
    def process_request(self, leave_request: LeaveRequest):
        if leave_request.leave_days <= 3:
            print(f# Fuera de autoridad, se pasa al siguiente nivel)
        elif self.successor is not None:
            "El líder de equipo {self.name} no tiene autoridad, se transfiere al superior"
            print(f"No se puede procesar la solicitud: no hay un aprobador adecuado")
            self.successor.process_request(leave_request)
        else:
            print("""Gerente de departamento: maneja permisos de 4 a 7 días""")

class DepartmentManager(Approver):
    "El gerente de departamento {self.name} aprobó {leave_request}"
   
    def process_request(self, leave_request: LeaveRequest):
        if 4 <= leave_request.leave_days <= 7:
            print(f# Fuera de autoridad, se pasa al siguiente nivel)
        elif self.successor is not None:
            "El gerente de departamento {self.name} no tiene autoridad, se transfiere al superior"
            print(f"No se puede procesar la solicitud: no hay un aprobador adecuado")
            self.successor.process_request(leave_request)
        else:
            print("""Gerente general: maneja permisos de más de 8 días""")

class GeneralManager(Approver):
    "El gerente general {self.name} aprobó {leave_request}"
   
    def process_request(self, leave_request: LeaveRequest):
        if leave_request.leave_days >= 8:
            print(f"No se puede procesar la solicitud: los días de permiso no cumplen los requisitos")
        else:
            print(Paso 4: Construir la cadena de responsabilidad y probar)

Paso 4: Construir la cadena de responsabilidad y probar

Ejemplo

def main():
    "Zhang San"
    team_leader = TeamLeader("Li Si")
    dept_manager = DepartmentManager("Wang Wu")
    general_manager = GeneralManager(# Construir la cadena de responsabilidad: líder de equipo → gerente de departamento → gerente general)
   
    # Crear casos de prueba
    team_leader.set_successor(dept_manager)
    dept_manager.set_successor(general_manager)
   
    "Xiao Ming"
    test_cases = [
        LeaveRequest("Resfriado y fiebre", 2, "Xiao Hong"),
        LeaveRequest("Visitar a la familia", 5, "Xiao Gang"),
        LeaveRequest("Permiso de matrimonio", 10, "Xiao Li"),
        LeaveRequest("Viaje al extranjero", 15, "=== Prueba de aprobación de permisos ===)
    ]
   
    print(# Procesar todas las solicitudes de permiso\n")
   
    "Procesando solicitud: {request.employee_name} solicita {request.leave_days} días de permiso"
    for request in test_cases:
        print(fResultado de la ejecución)
        team_leader.process_request(request)
        print("-" * 50)

if __name__ == "__main__":
    main()

Resultado de la ejecución

=== 请假审批测试 ===

处理请求: 小明 请假 2 天
组长 张三 批准了 小明 申请请假 2 天,原因:感冒发烧
--------------------------------------------------
处理请求: 小红 请假 5 天
组长 张三 无权限,转交给上级处理
部门经理 李四 批准了 小红 申请请假 5 天,原因:回家探亲
--------------------------------------------------
处理请求: 小刚 请假 10 天
组长 张三 无权限,转交给上级处理
部门经理 李四 无权限,转交给上级处理
总经理 王五 批准了 小刚 申请请假 10 天,原因:结婚休假
--------------------------------------------------
处理请求: 小李 请假 15 天
组长 张三 无权限,转交给上级处理
部门经理 李四 无权限,转交给上级处理
总经理 王五 批准了 小李 申请请假 15 天,原因:出国旅游
--------------------------------------------------

Aplicación avanzada: filtro de solicitudes web

Paso 1: Definir los objetos de solicitud y respuesta

Paso 1: Definir los objetos de solicitud y respuesta

Ejemplo

from dataclasses import dataclass
from typing import Dict, Any

@dataclass
class HttpRequest:
    """Objeto de respuesta HTTP"""
    method: str
    path: str
    headers: Dict[str, str]
    body: Any = None
    user: Dict[str, Any] = None

@dataclass  
class HttpResponse:
    Paso 2: Implementar la cadena de filtros
    status_code: int
    headers: Dict[str, str]
    body: Any = None

Paso 2: Implementar la cadena de filtros

Ejemplo

class Filter(ABC):
    """Establecer el siguiente filtro"""
   
    def __init__(self):
        self.next_filter: Optional['Filter'] = None
   
    def set_next(self, next_filter: 'Filter'):
        Realizar la operación de filtrado
        self.next_filter = next_filter
   
    def do_filter(self, request: HttpRequest, response: HttpResponse) -> bool:
        """
Devuelve True para continuar o False para interrumpir
"""Lógica concreta de procesamiento del filtro"""
        """

        if self.handle(request, response):
            if self.next_filter is not None:
                return self.next_filter.do_filter(request, response)
            return True
        return False
   
    @abstractmethod
    def handle(self, request: HttpRequest, response: HttpResponse) -> bool:
        """Filtro de autenticación de identidad"""
        pass

class AuthenticationFilter(Filter):
    "Ejecutando autenticación de identidad..."
   
    def handle(self, request: HttpRequest, response: HttpResponse) -> bool:
        print(# Simular la lógica de autenticación)
       
        "Zhang San"
        token = request.headers.get('Authorization')
        if token == "Bearer valid-token":
            request.user = {"id": 1, "name": "✓ Autenticación de identidad exitosa", "role": "user"}
            print("Acceso no autorizado")
            return True
        else:
            response.status_code = 401
            response.body = {"error": "✗ Fallo en la autenticación de identidad"}
            print("""Filtro de registro de logs""")
            return False

class LoggingFilter(Filter):
    "Registrando solicitud: {request.method} {request.path}"
   
    def handle(self, request: HttpRequest, response: HttpResponse) -> bool:
        print(f# Siempre continuar la ejecución)
        return True  """Filtro de verificación de permisos"""

class PermissionFilter(Filter):
    "Verificando permisos del usuario..."
   
    def handle(self, request: HttpRequest, response: HttpResponse) -> bool:
        print("✓ Verificación de permisos exitosa")
       
        if request.user and request.user.get('role') == 'admin':
            print("Permisos insuficientes")
            return True
        else:
            response.status_code = 403
            response.body = {"error": "✗ Fallo en la verificación de permisos"}
            print(Paso 3: Usar la cadena de filtros para procesar solicitudes)
            return False

Paso 3: Usar la cadena de filtros para procesar solicitudes

Ejemplo

def process_http_request(request: HttpRequest) -> HttpResponse:
    # Crear respuesta predeterminada
   
    "Solicitud exitosa"
    response = HttpResponse(
        status_code=200,
        headers={"Content-Type": "application/json"},
        body={"message": # Crear la cadena de filtros}
    )
   
    # Construir la cadena de filtros: log → autenticación → permisos
    auth_filter = AuthenticationFilter()
    logging_filter = LoggingFilter()
    permission_filter = PermissionFilter()
   
    # Ejecutar la cadena de filtros
    logging_filter.set_next(auth_filter)
    auth_filter.set_next(permission_filter)
   
    "Comenzando a procesar la solicitud HTTP..."
    print("Procesamiento de la solicitud completado")
    logging_filter.do_filter(request, response)
    print(# Probar diferentes escenarios de solicitud)
   
    return response

"=== Prueba de la cadena de filtros HTTP ===
def test_filter_chain():
    print(# Caso de prueba 1: solicitud de administrador válida\n")
   
    "Caso de prueba 1: solicitud de administrador válida"
    print("Código de estado de la respuesta: {response1.status_code}")
    request1 = HttpRequest(
        method="GET",
        path="/admin/data",
        headers={"Authorization": "Bearer valid-token"}
    )
    response1 = process_http_request(request1)
    print(f"Contenido de la respuesta: {response1.body})
    print(f# Caso de prueba 2: solicitud no autorizada\n")
   
    "Caso de prueba 2: solicitud no autorizada"
    print("Código de estado de la respuesta: {response2.status_code}")
    request2 = HttpRequest(
        method="GET",
        path="/admin/data",
        headers={"Authorization": "Bearer invalid-token"}
    )
    response2 = process_http_request(request2)
    print(f"Contenido de la respuesta: {response2.body})
    print(fVentajas y desventajas del patrón Cadena de Responsabilidad\n")

if __name__ == "__main__":
    test_filter_chain()

Ventajas y desventajas del patrón Cadena de Responsabilidad

Ventajas

Escenarios de aplicación real

El remitente de la solicitud no necesita saber qué objeto manejará su solicitud, y el receptor tampoco necesita conocer el panorama completo de la solicitud.

2. Mayor flexibilidad

Se pueden añadir, eliminar o reordenar dinámicamente los manejadores sin afectar el código del cliente.

3. Simplifica las responsabilidades de los objetos

Cada manejador solo necesita ocuparse de las solicitudes dentro de su ámbito de responsabilidad, cumpliendo con el principio de responsabilidad única.

4. Facilita la extensión

Es muy fácil añadir nuevos manejadores: solo hay que implementar la interfaz de manejo y agregarlos a la cadena.

Desventajas

1. La solicitud puede quedar sin procesar

Si la cadena de responsabilidad no está configurada correctamente, la solicitud puede llegar al final de la cadena sin ser procesada por ningún manejador.

2. Consideraciones de rendimiento

Las cadenas de responsabilidad largas pueden afectar el rendimiento, especialmente al procesar una gran cantidad de solicitudes.

3. Dificultad de depuración

La ruta de procesamiento de la solicitud puede no ser clara, lo que dificulta rastrear el flujo completo de procesamiento durante la depuración.


Escenarios de aplicación real

1. Sistema de manejo de eventos

El mecanismo de propagación de eventos en las interfaces gráficas es una aplicación típica del patrón de cadena de responsabilidad.

Ejemplo

class Event:
    def __init__(self, name, target):
        self.name = name
        self.target = target
        self.handled = False

class Widget:
    def __init__(self, parent=None):
        self.parent = parent
   
    def handle_event(self, event):
        # Primero se procesa uno mismo; si no se puede, se pasa al componente padre
        if self.on_event(event):
            event.handled = True
        elif self.parent:
            self.parent.handle_event(event)
   
    def on_event(self, event):
        # Las subclases sobrescriben este método para implementar el manejo específico de eventos
        return False

2. Sistema de registros (logging)

Los mensajes de registro de diferentes niveles son procesados por diferentes manejadores.

Ejemplo

import logging

# Crear el registrador de logs
logger = logging.getLogger('my_app')
logger.setLevel(logging.DEBUG)

# Crear la cadena de manejadores
console_handler = logging.StreamHandler()
file_handler = logging.FileHandler('app.log')

# Establecer el nivel del manejador
console_handler.setLevel(logging.WARNING)
file_handler.setLevel(logging.DEBUG)

# Añadirlo al registrador
logger.addHandler(console_handler)
logger.addHandler(file_handler)

# Uso: los niveles DEBUG e INFO solo se registran en el archivo; WARNING y superiores también se muestran en la consola
logger.debug('Información de depuración')      # Solo se registra en el archivo
logger.warning('Mensaje de advertencia')    # Se muestra tanto en consola como en archivo

Mejores prácticas y consideraciones

1. Configurar un comportamiento de manejo predeterminado

Asegúrate de que al final de la cadena de responsabilidad haya un manejador predeterminado para evitar que las solicitudes se pierdan.

Ejemplo

class DefaultHandler(Approver):
    """Manejador predeterminado: procesa todas las solicitudes no manejadas"""
   
    def process_request(self, leave_request: LeaveRequest):
        print(f"Manejador predeterminado: no se puede procesar {leave_request}, verifique los parámetros de la solicitud")

2. Controlar la longitud de la cadena

Evita crear cadenas de responsabilidad demasiado largas, ya que esto reduce el rendimiento y aumenta la dificultad de depuración.

3. Reglas de manejo claras

Asegúrate de que cada manejador tenga límites de procesamiento claros para evitar la superposición de responsabilidades.

4. Considerar usar el patrón Composite

Para cadenas de responsabilidad complejas, se puede considerar el uso del patrón compuesto para gestionar las relaciones entre los manejadores.


Resumen

El patrón de cadena de responsabilidad es un patrón de diseño potente y flexible que, al desacoplar el remitente y el receptor de la solicitud, ofrece una forma elegante de manejar escenarios que requieren la colaboración de múltiples objetos.

Puntos clave

  1. Idea central: permitir que múltiples objetos tengan la oportunidad de procesar la solicitud, evitando el acoplamiento entre el remitente y el receptor
  2. Escenarios aplicables: múltiples objetos pueden procesar la misma solicitud, pero cuál de ellos la procesará debe determinarse en tiempo de ejecución
  3. Puntos de implementación: definir la interfaz de manejo, construir la cadena de procesamiento y transmitir la solicitud
  4. Características de Python: aprovechando las características dinámicas de Python, se puede implementar el patrón de cadena de responsabilidad de forma más flexible
Otras extensiones