Chain of Responsibility
Cadena de responsabilidad
Pasa una petición a lo largo de una cadena de manejadores; cada uno decide si la procesa, la rechaza o la pasa al siguiente.
“Una petición pasa por varios filtros y cualquiera puede cortarla.”
workEl caso real
Antes de aprobar un pago con tarjeta, tu fintech aplica controles antifraude en orden: lista de tarjetas bloqueadas, límite diario del cliente, país de la conexión frente al país de la tarjeta y un puntaje de riesgo calculado por un modelo externo. Cualquier control puede rechazar el pago y cortar el resto. El equipo de riesgo cambia el orden y añade controles cada pocas semanas.
warningEl problema sin el patrón
Un método validarPago() de 200 líneas tiene todos los controles en if encadenados. Cambiar el orden, o desactivar un control para un país, obliga a modificar y volver a probar el método entero.
check_circleCómo lo resuelve el patrón
Cada control es un manejador con la misma interfaz y una referencia al siguiente. Si detecta un problema, rechaza el pago; si no, lo pasa al siguiente eslabón. La cadena se arma al configurar la aplicación y puede ser distinta en cada país.
schemaDiagrama de clases
Diagrama interactivo: puedes acercar, mover el lienzo y pasar el cursor sobre cada clase para ver su detalle.
codeEl código, antes y después
async function validarPago(pago: Pago) {
if (await listaBloqueo.contiene(pago.tarjeta)) return rechazar('Tarjeta bloqueada');
if ((await totalDelDia(pago.cliente)) + pago.monto > LIMITE) return rechazar('Límite diario');
if (paisConexion(pago) !== pago.tarjeta.pais) return rechazar('País no coincide');
if ((await modeloRiesgo.puntuar(pago)) > 0.8) return rechazar('Riesgo alto');
return aprobar();
}abstract class ControlFraude {
private siguiente?: ControlFraude;
enlazar(control: ControlFraude) { this.siguiente = control; return control; }
async revisar(pago: Pago): Promise<Resultado> {
const motivo = await this.detectar(pago);
if (motivo) return { aprobado: false, motivo }; // corta la cadena
return this.siguiente ? this.siguiente.revisar(pago) : { aprobado: true };
}
protected abstract detectar(pago: Pago): Promise<string | null>;
}
class ControlListaBloqueo extends ControlFraude {
protected async detectar(pago: Pago) {
return (await listaBloqueo.contiene(pago.tarjeta)) ? 'Tarjeta bloqueada' : null;
}
}
const cadena = new ControlListaBloqueo();
cadena.enlazar(new ControlLimiteDiario()).enlazar(new ControlPais()).enlazar(new ControlRiesgo());
await cadena.revisar(pago);Ejemplos en TypeScript, simplificados para mostrar la idea: los tipos auxiliares (Pedido, Cliente…) se omiten.
Matiz importante
Define siempre qué ocurre si la petición llega al final sin que nadie la atienda: en este ejemplo se aprueba, en otros casos conviene un manejador por defecto. Los middlewares de Express, ASP.NET Core o Laravel son una variante de este patrón.
thumb_upCuándo usarlo
- ✓Una petición debe pasar por varios pasos de validación o procesamiento y cualquiera puede detenerla.
- ✓El orden o el conjunto de pasos cambia según la configuración o el contexto.
do_not_disturb_onCuándo no usarlo
- ✕Los pasos son pocos y fijos: una secuencia de llamadas es más fácil de leer.
- ✕La cadena es larga y no registras qué eslabón decidió: depurar un rechazo se vuelve difícil.
memoryPrincipios en juego
- •Responsabilidad única: cada control vive en su propia clase.
- •Abierto/Cerrado: añades, quitas o reordenas controles sin modificar los existentes.
hubPatrones relacionados
- •Decorator: estructura parecida, pero el decorador siempre delega; en la cadena cualquier eslabón puede cortar.
- •Command: las peticiones que recorren la cadena pueden representarse como comandos.
- •Composite: un evento puede subir de un componente a su contenedor como si fuera una cadena.
quizPon a prueba lo que leíste
Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.
code_blocksChain of Responsibility en tu lenguaje
El mismo caso, implementado completo y de forma idiomática. Se puede copiar y ejecutar.
LO IDIOMÁTICO EN TYPESCRIPT: Cada eslabón implementa detectar de forma asíncrona y devuelve string | null. El resultado es una unión discriminada: si aprobado es false, el compilador sabe que existe motivo. La cadena se arma encadenando enlazar, que devuelve el eslabón añadido.
export interface Pago {
tarjeta: string;
cliente: string;
monto: number;
paisTarjeta: string;
paisConexion: string;
}
export type Resultado = { aprobado: true } | { aprobado: false; motivo: string };
export abstract class ControlFraude {
#siguiente?: ControlFraude;
enlazar(siguiente: ControlFraude): ControlFraude {
this.#siguiente = siguiente;
return siguiente;
}
async revisar(pago: Pago): Promise<Resultado> {
const motivo = await this.detectar(pago);
if (motivo) return { aprobado: false, motivo }; // corta la cadena
return this.#siguiente ? this.#siguiente.revisar(pago) : { aprobado: true };
}
protected abstract detectar(pago: Pago): Promise<string | null>;
}
const tarjetasBloqueadas = new Set(['4000000000000002']);
const gastadoHoy = new Map([['cli-1', 900]]);
class ControlListaBloqueo extends ControlFraude {
protected async detectar(pago: Pago) {
return tarjetasBloqueadas.has(pago.tarjeta) ? 'Tarjeta bloqueada' : null;
}
}
class ControlLimiteDiario extends ControlFraude {
constructor(private readonly limite: number) { super(); }
protected async detectar(pago: Pago) {
const total = (gastadoHoy.get(pago.cliente) ?? 0) + pago.monto;
return total > this.limite ? 'Supera el límite diario' : null;
}
}
class ControlPais extends ControlFraude {
protected async detectar(pago: Pago) {
return pago.paisTarjeta !== pago.paisConexion ? 'El país de conexión no coincide' : null;
}
}
// ── Uso ──
const cadena = new ControlListaBloqueo();
cadena.enlazar(new ControlLimiteDiario(1000)).enlazar(new ControlPais());
const pago: Pago = { tarjeta: '4111111111111111', cliente: 'cli-2', monto: 120, paisTarjeta: 'PE', paisConexion: 'PE' };
console.log(await cadena.revisar(pago)); // { aprobado: true }
console.log(await cadena.revisar({ ...pago, cliente: 'cli-1' })); // límite diario
console.log(await cadena.revisar({ ...pago, paisConexion: 'RU' })); // paísLO IDIOMÁTICO EN C# / .NET: Así funciona el pipeline de middlewares de ASP.NET Core: cada control es un delegado que recibe el pago y la función siguiente. Si detecta un problema devuelve el rechazo sin llamar a siguiente, y Pipeline.Construir arma la cadena a partir de una lista de controles.
var revisar = Pipeline.Construir(
Controles.ListaBloqueo,
Controles.LimiteDiario(1000m),
Controles.MismoPais);
var pago = new Pago("4111111111111111", "cli-2", 120m, "PE", "PE");
Console.WriteLine(revisar(pago)); // Resultado { Aprobado = True, Motivo = }
Console.WriteLine(revisar(pago with { Cliente = "cli-1" })); // Motivo = Supera el límite diario
Console.WriteLine(revisar(pago with { PaisConexion = "RU" })); // Motivo = El país de conexión no coincide
public record Pago(string Tarjeta, string Cliente, decimal Monto, string PaisTarjeta, string PaisConexion);
public record Resultado(bool Aprobado, string? Motivo = null);
public delegate Resultado Control(Pago pago, Func<Pago, Resultado> siguiente);
public static class Controles
{
private static readonly HashSet<string> TarjetasBloqueadas = ["4000000000000002"];
private static readonly Dictionary<string, decimal> GastadoHoy = new() { ["cli-1"] = 900m };
public static Resultado ListaBloqueo(Pago pago, Func<Pago, Resultado> siguiente) =>
TarjetasBloqueadas.Contains(pago.Tarjeta) ? new(false, "Tarjeta bloqueada") : siguiente(pago);
public static Control LimiteDiario(decimal limite) => (pago, siguiente) =>
GastadoHoy.GetValueOrDefault(pago.Cliente) + pago.Monto > limite
? new(false, "Supera el límite diario")
: siguiente(pago);
public static Resultado MismoPais(Pago pago, Func<Pago, Resultado> siguiente) =>
pago.PaisTarjeta != pago.PaisConexion ? new(false, "El país de conexión no coincide") : siguiente(pago);
}
public static class Pipeline
{
public static Func<Pago, Resultado> Construir(params Control[] controles)
{
Func<Pago, Resultado> cadena = _ => new Resultado(true); // final: todo en orden
for (var i = controles.Length - 1; i >= 0; i--)
{
var control = controles[i];
var siguiente = cadena;
cadena = pago => control(pago, siguiente);
}
return cadena;
}
}LO IDIOMÁTICO EN JAVA: Es el diseño de los filtros de Servlet (Filter + FilterChain) y de Spring Security: cada control recibe el pago y el resto de la cadena. Como Control es una interfaz funcional, cada control es una lambda, y cadena los encadena del último al primero.
void main() {
var revisar = Controles.cadena(Controles.LISTA_BLOQUEO, Controles.limiteDiario(1000), Controles.MISMO_PAIS);
var pago = new Pago("4111111111111111", "cli-2", 120, "PE", "PE");
IO.println(revisar.apply(pago)); // Resultado[aprobado=true, motivo=null]
IO.println(revisar.apply(new Pago("4111111111111111", "cli-1", 120, "PE", "PE"))); // Supera el límite diario
IO.println(revisar.apply(new Pago("4111111111111111", "cli-2", 120, "PE", "RU"))); // El país de conexión no coincide
}
record Pago(String tarjeta, String cliente, double monto, String paisTarjeta, String paisConexion) {}
record Resultado(boolean aprobado, String motivo) {
static Resultado ok() { return new Resultado(true, null); }
static Resultado rechazado(String motivo) { return new Resultado(false, motivo); }
}
@FunctionalInterface
interface Control {
Resultado revisar(Pago pago, Function<Pago, Resultado> siguiente);
}
final class Controles {
private static final Set<String> TARJETAS_BLOQUEADAS = Set.of("4000000000000002");
private static final Map<String, Double> GASTADO_HOY = Map.of("cli-1", 900.0);
static final Control LISTA_BLOQUEO = (pago, siguiente) ->
TARJETAS_BLOQUEADAS.contains(pago.tarjeta()) ? Resultado.rechazado("Tarjeta bloqueada") : siguiente.apply(pago);
static final Control MISMO_PAIS = (pago, siguiente) ->
pago.paisTarjeta().equals(pago.paisConexion()) ? siguiente.apply(pago) : Resultado.rechazado("El país de conexión no coincide");
static Control limiteDiario(double limite) {
return (pago, siguiente) -> GASTADO_HOY.getOrDefault(pago.cliente(), 0.0) + pago.monto() > limite
? Resultado.rechazado("Supera el límite diario")
: siguiente.apply(pago);
}
static Function<Pago, Resultado> cadena(Control... controles) {
Function<Pago, Resultado> resto = pago -> Resultado.ok(); // final: todo en orden
for (var i = controles.length - 1; i >= 0; i--) {
var control = controles[i];
var siguiente = resto;
resto = pago -> control.revisar(pago, siguiente);
}
return resto;
}
}LO IDIOMÁTICO EN JAVASCRIPT: La forma idiomática en JavaScript es la de los middlewares de Express o Koa: cada control es una función (pago, siguiente) que responde o llama a siguiente(). componer arma la cadena a partir de un array, así que reordenar o quitar controles es editar una lista.
const tarjetasBloqueadas = new Set(['4000000000000002']);
const gastadoHoy = new Map([['cli-1', 900]]);
const listaBloqueo = async (pago, siguiente) =>
tarjetasBloqueadas.has(pago.tarjeta) ? { aprobado: false, motivo: 'Tarjeta bloqueada' } : siguiente();
const limiteDiario = (limite) => async (pago, siguiente) =>
(gastadoHoy.get(pago.cliente) ?? 0) + pago.monto > limite
? { aprobado: false, motivo: 'Supera el límite diario' }
: siguiente();
const mismoPais = async (pago, siguiente) =>
pago.paisTarjeta !== pago.paisConexion ? { aprobado: false, motivo: 'El país de conexión no coincide' } : siguiente();
export function componer(controles) {
return (pago) => {
const ejecutar = (i) => (i < controles.length ? controles[i](pago, () => ejecutar(i + 1)) : { aprobado: true });
return ejecutar(0);
};
}
// ── Uso ──
const revisarPago = componer([listaBloqueo, limiteDiario(1000), mismoPais]);
const pago = { tarjeta: '4111111111111111', cliente: 'cli-2', monto: 120, paisTarjeta: 'PE', paisConexion: 'PE' };
console.log(await revisarPago(pago)); // { aprobado: true }
console.log(await revisarPago({ ...pago, cliente: 'cli-1' })); // límite diario
console.log(await revisarPago({ ...pago, paisConexion: 'RU' })); // paísLO IDIOMÁTICO EN PYTHON: Cada control es una función que devuelve el motivo del rechazo o None. La cadena es una simple lista, y next() sobre un generador con el operador morsa (:=) recorre los controles en orden y se detiene en el primero que rechaza: el corte de la cadena sale gratis.
from collections.abc import Callable
from dataclasses import dataclass, replace
@dataclass(frozen=True)
class Pago:
tarjeta: str
cliente: str
monto: float
pais_tarjeta: str
pais_conexion: str
Control = Callable[[Pago], str | None]
TARJETAS_BLOQUEADAS = {"4000000000000002"}
GASTADO_HOY = {"cli-1": 900}
def lista_bloqueo(pago: Pago) -> str | None:
return "Tarjeta bloqueada" if pago.tarjeta in TARJETAS_BLOQUEADAS else None
def limite_diario(limite: float) -> Control:
def control(pago: Pago) -> str | None:
total = GASTADO_HOY.get(pago.cliente, 0) + pago.monto
return "Supera el límite diario" if total > limite else None
return control
def mismo_pais(pago: Pago) -> str | None:
return "El país de conexión no coincide" if pago.pais_tarjeta != pago.pais_conexion else None
def revisar(pago: Pago, cadena: list[Control]) -> str:
motivo = next((m for control in cadena if (m := control(pago))), None)
return f"rechazado: {motivo}" if motivo else "aprobado"
if __name__ == "__main__":
cadena = [lista_bloqueo, limite_diario(1000), mismo_pais] # reordenar = editar la lista
pago = Pago("4111111111111111", "cli-2", 120, "PE", "PE")
print(revisar(pago, cadena)) # aprobado
print(revisar(replace(pago, cliente="cli-1"), cadena)) # rechazado: Supera el límite diario
print(revisar(replace(pago, pais_conexion="RU"), cadena)) # rechazado: El país de conexión no coincideLO IDIOMÁTICO EN GO: El estilo de los middlewares de net/http: cada control recibe el siguiente manejador y devuelve uno nuevo. Si detecta un problema devuelve un error y no llama al siguiente, así que la cadena se corta sola. Encadenar arma la cadena a partir de una lista de controles.
package main
import (
"errors"
"fmt"
)
type Pago struct {
Tarjeta string
Cliente string
Monto float64
PaisTarjeta string
PaisConexion string
}
type Manejador func(Pago) error
type Control func(siguiente Manejador) Manejador
var tarjetasBloqueadas = map[string]bool{"4000000000000002": true}
var gastadoHoy = map[string]float64{"cli-1": 900}
func ListaBloqueo(siguiente Manejador) Manejador {
return func(p Pago) error {
if tarjetasBloqueadas[p.Tarjeta] {
return errors.New("tarjeta bloqueada")
}
return siguiente(p)
}
}
func LimiteDiario(limite float64) Control {
return func(siguiente Manejador) Manejador {
return func(p Pago) error {
if gastadoHoy[p.Cliente]+p.Monto > limite {
return errors.New("supera el límite diario")
}
return siguiente(p)
}
}
}
func MismoPais(siguiente Manejador) Manejador {
return func(p Pago) error {
if p.PaisTarjeta != p.PaisConexion {
return errors.New("el país de conexión no coincide")
}
return siguiente(p)
}
}
// Encadenar envuelve el manejador final con los controles, del último al primero
func Encadenar(final Manejador, controles ...Control) Manejador {
for i := len(controles) - 1; i >= 0; i-- {
final = controles[i](final)
}
return final
}
func main() {
aprobar := func(p Pago) error {
fmt.Println(" pago aprobado por", p.Monto)
return nil
}
revisar := Encadenar(aprobar, ListaBloqueo, LimiteDiario(1000), MismoPais)
pago := Pago{"4111111111111111", "cli-2", 120, "PE", "PE"}
fmt.Println("resultado:", revisar(pago)) // pago aprobado por 120 · resultado: <nil>
sobreLimite := pago
sobreLimite.Cliente = "cli-1"
fmt.Println("resultado:", revisar(sobreLimite)) // resultado: supera el límite diario
otroPais := pago
otroPais.PaisConexion = "RU"
fmt.Println("resultado:", revisar(otroPais)) // resultado: el país de conexión no coincide
}LO IDIOMÁTICO EN RUST: Cada control es un cierre (closure) que devuelve Some(motivo) si rechaza o None si deja pasar. La cadena es un Vec de controles y find_map los recorre en orden y se detiene en el primero que devuelve Some: el corte de la cadena lo hace el propio iterador.
use std::collections::{HashMap, HashSet};
#[derive(Clone)]
struct Pago {
tarjeta: String,
cliente: String,
monto: f64,
pais_tarjeta: String,
pais_conexion: String,
}
type Control = Box<dyn Fn(&Pago) -> Option<String>>;
fn lista_bloqueo(bloqueadas: HashSet<&'static str>) -> Control {
Box::new(move |pago| {
bloqueadas
.contains(pago.tarjeta.as_str())
.then(|| "Tarjeta bloqueada".to_string())
})
}
fn limite_diario(limite: f64, gastado_hoy: HashMap<&'static str, f64>) -> Control {
Box::new(move |pago| {
let total = gastado_hoy
.get(pago.cliente.as_str())
.copied()
.unwrap_or(0.0)
+ pago.monto;
(total > limite).then(|| "Supera el límite diario".to_string())
})
}
fn mismo_pais() -> Control {
Box::new(|pago| {
(pago.pais_tarjeta != pago.pais_conexion)
.then(|| "El país de conexión no coincide".to_string())
})
}
fn revisar(pago: &Pago, cadena: &[Control]) -> Result<(), String> {
match cadena.iter().find_map(|control| control(pago)) {
Some(motivo) => Err(motivo),
None => Ok(()),
}
}
fn main() {
// Reordenar o quitar controles es editar esta lista
let cadena = vec![
lista_bloqueo(HashSet::from(["4000000000000002"])),
limite_diario(1000.0, HashMap::from([("cli-1", 900.0)])),
mismo_pais(),
];
let pago = Pago {
tarjeta: "4111111111111111".to_string(),
cliente: "cli-2".to_string(),
monto: 120.0,
pais_tarjeta: "PE".to_string(),
pais_conexion: "PE".to_string(),
};
println!("{:?}", revisar(&pago, &cadena)); // Ok(())
let sobre_limite = Pago {
cliente: "cli-1".to_string(),
..pago.clone()
};
println!("{:?}", revisar(&sobre_limite, &cadena)); // Err("Supera el límite diario")
let otro_pais = Pago {
pais_conexion: "RU".to_string(),
..pago
};
println!("{:?}", revisar(&otro_pais, &cadena)); // Err("El país de conexión no coincide")
}LO IDIOMÁTICO EN PHP: Es la técnica del Pipeline de Laravel y de los middlewares PSR-15: cada control es un closure fn (Pago $pago, Closure $siguiente), y array_reduce los envuelve uno dentro de otro, del último al primero. Reordenar la cadena es reordenar el array.
<?php
declare(strict_types=1);
final readonly class Pago
{
public function __construct(
public string $tarjeta,
public string $cliente,
public float $monto,
public string $paisTarjeta,
public string $paisConexion,
) {}
}
$tarjetasBloqueadas = ['4000000000000002'];
$gastadoHoy = ['cli-1' => 900.0];
$listaBloqueo = fn (Pago $p, Closure $siguiente): string =>
in_array($p->tarjeta, $tarjetasBloqueadas, true) ? 'rechazado: Tarjeta bloqueada' : $siguiente($p);
$limiteDiario = fn (float $limite): Closure => fn (Pago $p, Closure $siguiente): string =>
($gastadoHoy[$p->cliente] ?? 0.0) + $p->monto > $limite ? 'rechazado: Supera el límite diario' : $siguiente($p);
$mismoPais = fn (Pago $p, Closure $siguiente): string =>
$p->paisTarjeta !== $p->paisConexion ? 'rechazado: El país de conexión no coincide' : $siguiente($p);
/** @param list<Closure> $controles */
function encadenar(array $controles): Closure
{
return array_reduce(
array_reverse($controles),
fn (Closure $resto, Closure $control): Closure => fn (Pago $p): string => $control($p, $resto),
fn (Pago $p): string => 'aprobado', // final: todo en orden
);
}
$revisar = encadenar([$listaBloqueo, $limiteDiario(1000), $mismoPais]);
echo $revisar(new Pago('4111111111111111', 'cli-2', 120, 'PE', 'PE')), "\n"; // aprobado
echo $revisar(new Pago('4111111111111111', 'cli-1', 120, 'PE', 'PE')), "\n"; // rechazado: Supera el límite diario
echo $revisar(new Pago('4111111111111111', 'cli-2', 120, 'PE', 'RU')), "\n"; // rechazado: El país de conexión no coincide