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 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
@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
"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
"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 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
"""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
# 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
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
# 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
"""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
- Idea central: permitir que múltiples objetos tengan la oportunidad de procesar la solicitud, evitando el acoplamiento entre el remitente y el receptor
- Escenarios aplicables: múltiples objetos pueden procesar la misma solicitud, pero cuál de ellos la procesará debe determinarse en tiempo de ejecución
- Puntos de implementación: definir la interfaz de manejo, construir la cadena de procesamiento y transmitir la solicitud
- 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