Introducción

En 1994, cuatro investigadores de la computación — Erich Gamma, Richard Helm, Ralph Johnson y John Vlissides — publicaron un libro que cambiaría para siempre la forma en que los ingenieros de software piensan sobre sus problemas. “Design Patterns: Elements of Reusable Object-Oriented Software” catalogó 23 soluciones recurrentes para problemas recurrentes en el desarrollo orientado a objetos. La comunidad los apodó Gang of Four (GoF) — la Banda de los Cuatro.

Tres décadas después, en un mundo de nube pública, arquitecturas híbridas, Kubernetes, serverless, equipos distribuidos globalmente y microservicios que se comunican por eventos, esos mismos patrones siguen siendo referencia. No porque el mundo se haya detenido. Porque los problemas fundamentales del software no cambiaron — solo cambiaron la escala y el entorno en que aparecen.

Este artículo explora:

  • Por qué necesitamos arquitectura de software — y qué ocurre cuando se ignora
  • El origen y el propósito del GoF — contexto histórico, motivaciones y la estructura de los 23 patrones
  • Cómo los patrones se aplican independientemente del lenguaje — GoF no es Java, ni C++; es un lenguaje de diseño
  • La revolución de la nube y los microservicios — cómo evolucionaron los patrones clásicos y cuáles surgieron
  • Equipos de desarrollo y de soporte — por qué la arquitectura es el vínculo que mantiene vivos los sistemas por más de una generación de desarrolladores

Para quién es este artículo: desarrolladores con experiencia práctica que quieren elevar su razonamiento de resolución de problemas al nivel de la arquitectura de software.

📦 Código fuente: La implementación completa de este artículo está en el repositorio blog-zocateli-sample en GitHub. Clónalo, explóralo y adáptalo a tu contexto.


Por Qué Importa la Arquitectura de Software

Software sin arquitectura: el costo invisible

Imagina un sistema bancario construido por 50 desarrolladores a lo largo de 8 años, sin ninguna convención arquitectónica. Cada desarrollador resolvió los problemas a su manera. El resultado es lo que la industria llama Big Ball of Mud — una masa amorfa donde cualquier cambio puede romper algo en cualquier lugar.

No es un escenario hipotético. Es el estado natural de los sistemas que crecen sin intención arquitectónica. Los síntomas son reconocibles:

  • Acoplamiento invisible: cambiar el módulo de pagos rompe el módulo de reportes, y nadie sabe por qué
  • Conocimiento tribal: solo 2 desarrolladores saben cómo esa parte “funciona de verdad”
  • Miedo al deploy: “el viernes no se sube” se volvió cultura porque nadie confía en el sistema
  • Regresión constante: cada nueva funcionalidad parece traer de vuelta 3 bugs antiguos
  • Onboarding lento: un desarrollador nuevo tarda 6 meses en ser productivo

La arquitectura no es lo que haces antes de escribir código — es la intención que guía cada decisión de diseño durante toda la vida del sistema.

¿Qué es, al final, la arquitectura de software?

Martin Fowler define la arquitectura de software como “las decisiones importantes y difíciles de revertir” en un sistema. Ralph Johnson la define como “las decisiones compartidas por los desarrolladores sobre cómo organizar el sistema”.

Estas definiciones revelan dos dimensiones de la arquitectura:

  1. Técnica: modularidad, acoplamiento, cohesión, contratos entre componentes, flujo de datos, manejo de fallas
  2. Social: vocabulario común entre personas, convenciones que permiten que un equipo de 20 trabaje con consistencia

La segunda dimensión suele ignorarse — y es justamente donde brillan los patrones GoF.

El costo de la deuda técnica arquitectónica

La deuda técnica arquitectónica es distinta y más grave que la deuda técnica de código. Refactorizar un método lleva una tarde. Cambiar la arquitectura de un sistema en producción puede llevar meses, con alto riesgo. Por eso, las decisiones arquitectónicas equivocadas acumulan intereses rápidamente:

1
2
3
4
Año 1: "Pongamos la lógica de negocio directamente en el controller, es más rápido"
Año 2: "Tenemos 300 controllers con 500 líneas cada uno, imposible de probar"
Año 3: "Necesitamos 6 meses para migrar a cualquier otra cosa"
Año 4: "No logramos contratar seniors porque nadie quiere trabajar en este código"

La arquitectura no elimina la deuda técnica — pero la orienta y la vuelve visible y gestionable.


El Origen de la Gang of Four

El contexto histórico: la crisis del software orientado a objetos

En 1994, la programación orientada a objetos había vivido su pico de hype. C++, Smalltalk y, más recientemente, Java prometían que la herencia, el encapsulamiento y el polimorfismo resolverían todos los problemas de reutilización de código. La promesa no se cumplió sola.

El problema no era la orientación a objetos en sí — era que los desarrolladores no tenían un vocabulario compartido para expresar cómo usar las herramientas de la OO. Cada proyecto reinventaba las mismas soluciones para los mismos problemas. Un desarrollador experimentado en Smalltalk tenía soluciones consolidadas para “cómo desacoplar un algoritmo de sus implementaciones concretas” — pero esas soluciones vivían en su cabeza, no en libros.

Gamma, Helm, Johnson y Vlissides se dieron cuenta de que estaban llegando, de forma independiente, a las mismas soluciones para los mismos tipos de problema. La idea del libro nació en una conferencia OOPSLA en 1990, cuando Erich Gamma y Richard Helm intercambiaron notas sobre patrones recurrentes. La escritura duró 4 años.

La influencia de Christopher Alexander

Los autores se inspiraron explícitamente en Christopher Alexander, un arquitecto (de construcciones físicas, no de software) que en 1977 publicó “A Pattern Language” — un catálogo de 253 patrones recurrentes en arquitectura urbana y de edificaciones, desde el diseño de ciudades hasta la ubicación de ventanas.

La idea central de Alexander: los problemas recurrentes en un contexto tienen soluciones recurrentes que pueden nombrarse, documentarse y comunicarse. Cuando un arquitecto dice “esta sala necesita doble altura”, todos los demás arquitectos saben exactamente qué significa — sin explicarlo desde cero.

GoF aplicó esta idea al software: al decir “usa un Strategy aquí”, comunicas una estructura de diseño completa en una sola palabra.

La estructura de un patrón GoF

Cada uno de los 23 patrones sigue un formato consistente:

CampoDescripción
NombreEl vocabulario — “Strategy”, “Factory”, “Observer”
IntenciónQué hace el patrón, en una frase
También Conocido ComoNombres alternativos
MotivaciónEscenario concreto que justifica el patrón
AplicabilidadCuándo usarlo
EstructuraDiagrama de clases (UML)
ParticipantesLas clases y sus responsabilidades
ColaboracionesCómo interactúan los participantes
ConsecuenciasTrade-offs — qué ganas y a qué renuncias
ImplementaciónNotas de implementación, variaciones
Código de EjemploC++ en el libro original
Patrones RelacionadosConexiones con otros patrones

El campo Consecuencias es el más ignorado y el más valioso. Todo patrón tiene un costo. Conocer el costo es lo que diferencia a un arquitecto de alguien que solo aplica patrones mecánicamente.


Los 23 Patrones GoF

Los 23 patrones se dividen en tres categorías, según el tipo de problema que resuelven:

Mapa de los 23 patrones GoF organizados por categoría: Creacionales, Estructurales y de Comportamiento

Patrones Creacionales — Cómo Se Crean los Objetos

Encapsulan y abstraen el proceso de creación de objetos. El objetivo es desacoplar el código que usa un objeto del código que lo instancia.

Factory Method

Define una interfaz para crear un objeto, pero deja que las subclases decidan qué clase instanciar.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// Independiente del lenguaje — el principio:
// "Quiero crear algo, pero no quiero saber CÓMO se crea"

public abstract class NotificadorBase
{
    // Factory Method: las subclases definen qué canal usar
    protected abstract ICanal CriarCanal();

    public void Notificar(string mensagem)
    {
        var canal = CriarCanal();  // creación delegada a la subclass
        canal.Enviar(mensagem);
    }
}

public class NotificadorEmail : NotificadorBase
{
    protected override ICanal CriarCanal() => new CanalEmail();
}

public class NotificadorSms : NotificadorBase
{
    protected override ICanal CriarCanal() => new CanalSms();
}

// El código de orquestación no necesita saber qué canal se usa:
NotificadorBase notificador = ambiente == "prod"
    ? new NotificadorEmail()
    : new NotificadorSms();
notificador.Notificar("Pedido confirmado");

Abstract Factory

Crea familias de objetos relacionados sin especificar sus clases concretas.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// Problema: necesitas componentes que sean consistentes entre sí (misma "familia")
// Ejemplo: componentes de UI que deben ser todos "Light" o todos "Dark"

public interface IUiFactory
{
    IBotao CriarBotao();
    IInput CriarInput();
    ICard CriarCard();
}

public class LightThemeFactory : IUiFactory
{
    public IBotao CriarBotao() => new BotaoLight();
    public IInput CriarInput() => new InputLight();
    public ICard CriarCard() => new CardLight();
}

public class DarkThemeFactory : IUiFactory
{
    public IBotao CriarBotao() => new BotaoDark();
    public IInput CriarInput() => new InputDark();
    public ICard CriarCard() => new CardDark();
}

// La pantalla usa la factory — nunca instancia directamente:
public class TelaCheckout(IUiFactory factory)
{
    private readonly IBotao _btnConfirmar = factory.CriarBotao();
    private readonly IInput _inputCartao   = factory.CriarInput();
}

Builder

Separa la construcción de un objeto complejo de su representación.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Resuelve el problema del "telescoping constructor":
// En lugar de: new Pedido(1, "João", true, false, null, 0, "SP", "BR", ...)
// Usa:

var pedido = new PedidoBuilder()
    .ParaCliente(clienteId: 1)
    .ComItem(produtoId: 10, quantidade: 2)
    .ComItem(produtoId: 15, quantidade: 1)
    .ComDesconto(10)
    .ComEnderecoEntrega("Rua A", "São Paulo", "SP")
    .ComPrioridadeExpressa()
    .Build();

public class PedidoBuilder
{
    private readonly Pedido _pedido = new();

    public PedidoBuilder ParaCliente(int clienteId)
        { _pedido.ClienteId = clienteId; return this; }

    public PedidoBuilder ComItem(int produtoId, int quantidade)
        { _pedido.Itens.Add(new Item(produtoId, quantidade)); return this; }

    public PedidoBuilder ComDesconto(decimal percentual)
        { _pedido.Desconto = percentual; return this; }

    public PedidoBuilder ComPrioridadeExpressa()
        { _pedido.Prioridade = PrioridadePedido.Expressa; return this; }

    public Pedido Build()
    {
        _pedido.Validar();  // validación centralizada en Build
        return _pedido;
    }
}

Prototype

Crea nuevos objetos copiando (clonando) un objeto existente.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Útil cuando crear desde cero es caro (consulta a la base de datos, inicialización pesada)
public abstract class Componente
{
    public abstract Componente Clone();
    public string Nome { get; set; } = "";
    public Dictionary<string, string> Configuracoes { get; set; } = [];
}

public class ComponenteNginx : Componente
{
    public override Componente Clone()
    {
        var clone = (ComponenteNginx)MemberwiseClone();
        // Deep copy de las configuraciones mutables
        clone.Configuracoes = new Dictionary<string, string>(Configuracoes);
        return clone;
    }
}

// En lugar de crear y configurar desde cero cada vez:
var templateNginx = new ComponenteNginx { Nome = "nginx-template" };
templateNginx.Configuracoes["porta"] = "80";
templateNginx.Configuracoes["workers"] = "4";

// Clonar es mucho más barato:
var nginx1 = (ComponenteNginx)templateNginx.Clone();
nginx1.Nome = "nginx-producao";

Singleton

Garantiza que una clase tenga una sola instancia y proporciona acceso global a ella.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
// En .NET moderno, prefiere la inyección de dependencias con Lifetime.Singleton
// pero el patrón sigue siendo relevante para entender el concepto:

// ⚠️ Thread-safe con Lazy<T> (más idiomático en .NET):
public sealed class GerenciadorCache
{
    private static readonly Lazy<GerenciadorCache> _instancia =
        new(() => new GerenciadorCache());

    private GerenciadorCache() { }  // constructor privado

    public static GerenciadorCache Instancia => _instancia.Value;

    public object? Obter(string chave) { /* ... */ return null; }
    public void Definir(string chave, object valor) { /* ... */ }
}

// Uso:
GerenciadorCache.Instancia.Definir("config", dados);

// ✅ En ASP.NET Core: usa services.AddSingleton<IGerenciadorCache, GerenciadorCache>()
// El contenedor de DI garantiza la instancia única con thread-safety

Patrones Estructurales — Cómo Se Componen los Objetos

Tratan de la composición de clases y objetos para formar estructuras mayores, manteniendo flexibilidad y eficiencia.

Adapter

Convierte la interfaz de una clase en otra interfaz que los clientes esperan.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// Problema clásico: un nuevo SDK de pago con una interfaz distinta de la actual
public interface IGatewayPagamento  // interfaz que TU sistema espera
{
    Task<ResultadoPagamento> ProcessarAsync(DadosPagamento dados);
}

// Clase existente de terceros con una interfaz diferente:
public class StripeClient  // tú NO controlas esta clase
{
    public StripeResult Charge(string token, long amountCents, string currency)
        { /* Stripe SDK */ return new StripeResult(); }
}

// Adapter: adapta la interfaz de Stripe a la interfaz que espera el sistema
public class StripeAdapter(StripeClient stripe) : IGatewayPagamento
{
    public async Task<ResultadoPagamento> ProcessarAsync(DadosPagamento dados)
    {
        var resultado = await Task.Run(() =>
            stripe.Charge(dados.Token, (long)(dados.Valor * 100), dados.Moeda));

        return new ResultadoPagamento(
            Sucesso: resultado.Status == "succeeded",
            TransacaoId: resultado.Id);
    }
}

// El sistema nunca sabe que está usando Stripe:
IGatewayPagamento gateway = new StripeAdapter(new StripeClient());
await gateway.ProcessarAsync(dadosDoPedido);

Decorator

Agrega responsabilidades a un objeto dinámicamente, sin modificar su clase.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
// El verdadero poder: componer comportamientos sin hacer explotar la jerarquía de herencia

public interface IRepositorioPedidos
{
    Task<Pedido?> ObterAsync(int id);
    Task SalvarAsync(Pedido pedido);
}

// Decorator 1: agrega caché
public class PedidosComCache(IRepositorioPedidos inner, ICache cache)
    : IRepositorioPedidos
{
    public async Task<Pedido?> ObterAsync(int id)
    {
        var cached = await cache.GetAsync<Pedido>($"pedido:{id}");
        if (cached is not null) return cached;

        var pedido = await inner.ObterAsync(id);
        if (pedido is not null)
            await cache.SetAsync($"pedido:{id}", pedido, TimeSpan.FromMinutes(5));
        return pedido;
    }

    public Task SalvarAsync(Pedido pedido) => inner.SalvarAsync(pedido);
}

// Decorator 2: agrega logging
public class PedidosComLogging(IRepositorioPedidos inner, ILogger logger)
    : IRepositorioPedidos
{
    public async Task<Pedido?> ObterAsync(int id)
    {
        logger.LogInformation("Buscando pedido {Id}", id);
        var result = await inner.ObterAsync(id);
        logger.LogInformation("Pedido {Id}: {Status}", id, result is null ? "no encontrado" : "encontrado");
        return result;
    }

    public Task SalvarAsync(Pedido pedido) => inner.SalvarAsync(pedido);
}

// Composition root — apilas los decorators como quieras:
IRepositorioPedidos repo =
    new PedidosComLogging(
        new PedidosComCache(
            new PedidosEfCore(dbContext),
            redisCache),
        logger);

Facade

Proporciona una interfaz simplificada para un subsistema complejo.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// Problema: finalizar un pedido involucra 6 subsistemas diferentes
// Sin Facade: cada controller conoce y orquesta todos los subsistemas

// Con Facade: un único punto de entrada para el caso de uso
public class ServicoFinalizacaoPedido(
    IEstoqueService estoque,
    IFinanceiroService financeiro,
    ILogisticaService logistica,
    INotificacaoService notificacao,
    IAuditService auditoria)
{
    public async Task<ResultadoFinalizacao> FinalizarAsync(int pedidoId)
    {
        // Orquesta la complejidad internamente
        await estoque.ReservarItensAsync(pedidoId);
        var cobranca = await financeiro.CobrarAsync(pedidoId);

        if (!cobranca.Aprovada)
        {
            await estoque.LiberarReservaAsync(pedidoId);
            return ResultadoFinalizacao.FalhaNoPagamento(cobranca.Motivo);
        }

        var envio = await logistica.AgendarEnvioAsync(pedidoId);
        await notificacao.NotificarClienteAsync(pedidoId, envio.PrevisaoEntrega);
        await auditoria.RegistrarAsync(pedidoId, "PEDIDO_FINALIZADO");

        return ResultadoFinalizacao.Sucesso(cobranca.TransacaoId, envio.CodigoRastreio);
    }
}

// Controller: limpio, sin complejidad de orquestación:
[HttpPost("{id}/finalizar")]
public async Task<IActionResult> Finalizar(int id)
{
    var resultado = await _servico.FinalizarAsync(id);
    return resultado.Sucesso ? Ok(resultado) : BadRequest(resultado);
}

Proxy

Proporciona un sustituto de otro objeto para controlar el acceso a él.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Proxy virtual: carga datos bajo demanda (lazy loading)
// Proxy de protección: verifica permisos antes de delegar
// Proxy remoto: abstrae la comunicación de red

// Proxy de protección:
public class RepositorioPedidosProtegido(
    IRepositorioPedidos inner,
    IHttpContextAccessor httpContext) : IRepositorioPedidos
{
    public async Task<Pedido?> ObterAsync(int id)
    {
        var usuario = httpContext.HttpContext?.User;

        if (usuario?.IsInRole("Admin") != true)
        {
            // Restringe el acceso al pedido del propio usuario
            var pedido = await inner.ObterAsync(id);
            var userId = usuario?.FindFirst("sub")?.Value;
            return pedido?.ClienteId.ToString() == userId ? pedido : null;
        }

        return await inner.ObterAsync(id);
    }

    public Task SalvarAsync(Pedido pedido) => inner.SalvarAsync(pedido);
}

Composite, Bridge, Flyweight

Los demás patrones estructurales resuelven problemas igualmente comunes:

  • Composite — trata objetos individuales y colecciones de forma uniforme (árboles de menús, categorías jerárquicas, expresiones matemáticas)
  • Bridge — separa la abstracción de la implementación para que ambas evolucionen de forma independiente (drivers de base de datos, renderizadores de reportes)
  • Flyweight — comparte eficientemente objetos que aparecen en gran número (caracteres en un editor de texto, partículas en juegos)

Patrones de Comportamiento — Cómo Interactúan los Objetos

Tratan de la comunicación entre objetos y de la distribución de responsabilidades.

Strategy

Define una familia de algoritmos, encapsula cada uno y los vuelve intercambiables.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Contexto: calcular el envío con diferentes transportistas
public interface ICalculadorFrete
{
    decimal Calcular(Endereco origem, Endereco destino, decimal pesoKg);
}

public class FreteCorreios : ICalculadorFrete
{
    public decimal Calcular(Endereco origem, Endereco destino, decimal pesoKg)
        => /* lógica de Correios */ pesoKg * 3.5m + 8.0m;
}

public class FreteTransportadora : ICalculadorFrete
{
    public decimal Calcular(Endereco origem, Endereco destino, decimal pesoKg)
        => /* lógica del transportista */ pesoKg * 2.8m + 15.0m;
}

public class FreteRetiradaLoja : ICalculadorFrete
{
    public decimal Calcular(Endereco origem, Endereco destino, decimal pesoKg)
        => 0m;  // gratis al retirar en tienda
}

// Context: usa la estrategia sin saber cuál es
public class Carrinho(ICalculadorFrete calculadorFrete)
{
    public decimal CalcularFrete(Endereco destino)
        => calculadorFrete.Calcular(_enderecoLoja, destino, _pesoTotal);
}

// Flexibilidad en la composición:
var carrinho = new Carrinho(cliente.PrefereFreteProprio
    ? new FreteTransportadora()
    : new FreteCorreios());

Observer

Define una dependencia uno-a-muchos entre objetos: cuando uno cambia de estado, todos sus dependientes son notificados.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Base para sistemas de eventos, reactive programming, pub/sub
// .NET tiene IObservable<T>/IObserver<T> nativos que siguen este patrón

public interface IObservadorPedido
{
    Task AoAtualizarAsync(Pedido pedido);
}

public class ServicoPedidos
{
    private readonly List<IObservadorPedido> _observadores = [];

    public void Inscrever(IObservadorPedido obs) => _observadores.Add(obs);
    public void Cancelar(IObservadorPedido obs) => _observadores.Remove(obs);

    public async Task AtualizarStatusAsync(int id, StatusPedido novoStatus)
    {
        var pedido = await _repo.ObterAsync(id);
        pedido.Status = novoStatus;
        await _repo.SalvarAsync(pedido);

        // Notifica a todos los observadores
        foreach (var obs in _observadores)
            await obs.AoAtualizarAsync(pedido);
    }
}

// Observadores registrados:
var servico = new ServicoPedidos(repo);
servico.Inscrever(new NotificadorEmailCliente(emailService));
servico.Inscrever(new AtualizadorEstoque(estoqueService));
servico.Inscrever(new RegistradorAuditoria(auditService));
servico.Inscrever(new GatewayWebhook(webhookService));

// En .NET moderno: MediatR + domain events implementan exactamente este patrón

Command

Encapsula una solicitud como un objeto, permitiendo parametrizar operaciones, encolarlas, registrarlas y deshacerlas.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// El patrón Command está en el corazón de CQRS, event sourcing y undo/redo

public interface IComando<TResultado> { }

public record CancelarPedidoComando(int PedidoId, string Motivo)
    : IComando<ResultadoCancelamento>;

public class CancelarPedidoHandler(
    IRepositorioPedidos repo,
    IEventBus eventBus,
    IAuditService auditoria)
    : IHandlerComando<CancelarPedidoComando, ResultadoCancelamento>
{
    public async Task<ResultadoCancelamento> ExecutarAsync(CancelarPedidoComando cmd)
    {
        var pedido = await repo.ObterAsync(cmd.PedidoId)
            ?? throw new PedidoNaoEncontradoException(cmd.PedidoId);

        if (!pedido.PodeCancelar())
            return ResultadoCancelamento.Falha("El estado no permite la cancelación");

        pedido.Cancelar(cmd.Motivo);
        await repo.SalvarAsync(pedido);

        // Publica un evento para otros servicios (Observer + Command combinados)
        await eventBus.PublicarAsync(new PedidoCanceladoEvent(pedido.Id, cmd.Motivo));
        await auditoria.RegistrarAsync(pedido.Id, "PEDIDO_CANCELADO", cmd.Motivo);

        return ResultadoCancelamento.Sucesso();
    }
}

Chain of Responsibility, Template Method, State, Iterator, Mediator, Visitor, Memento, Interpreter

Los demás patrones de comportamiento cubren problemas igualmente recurrentes:

PatrónProblema que resuelveUso moderno
Chain of ResponsibilityProcesa una solicitud pasándola por una cadena de handlers hasta que se atiendeASP.NET Core Middleware, pipelines
Template MethodDefine el esqueleto de un algoritmo en una clase base, dejando partes a las subclasesClases base de pruebas, pipelines ETL
StatePermite que un objeto cambie su comportamiento cuando cambia de estadoMáquinas de estado, pedidos, workflows
IteratorRecorre una colección sin exponer su estructura internaIEnumerable<T>, foreach, yield return
MediatorLos objetos se comunican a través de un mediador central — reduce dependencias directasMediatR, message broker, event bus
VisitorAgrega operaciones a objetos sin modificar sus clasesAST visitors, transformaciones de árboles
MementoCaptura y restaura el estado interno de un objeto sin violar el encapsulamientoUndo/redo, checkpoints, snapshots
InterpreterDefine una gramática y un intérprete para ellaDSLs, validación de reglas de negocio

GoF Es Independiente del Lenguaje

Un error común es tratar los patrones GoF como “patrones Java” o “patrones C++”. El libro original se escribió con ejemplos en C++ y Smalltalk. Pero los patrones son conceptos de diseño, no APIs.

El mismo problema, lenguajes diferentes

Observer en JavaScript:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
// EventEmitter de Node.js es un Observer nativo
const { EventEmitter } = require('events');
class ServicoPedidos extends EventEmitter {
  async cancelar(id, motivo) {
    /* ... */
    this.emit('pedidoCancelado', { id, motivo });
  }
}
const svc = new ServicoPedidos();
svc.on('pedidoCancelado', ({ id }) => notificarCliente(id));
svc.on('pedidoCancelado', ({ id }) => atualizarEstoque(id));

Strategy en Python:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
from abc import ABC, abstractmethod

class CalculadorFrete(ABC):
    @abstractmethod
    def calcular(self, peso: float) -> float: ...

class FreteCorreios(CalculadorFrete):
    def calcular(self, peso: float) -> float:
        return peso * 3.5 + 8.0

class Carrinho:
    def __init__(self, calculador: CalculadorFrete):
        self._calculador = calculador  # Strategy inyectada

Factory en Go:

1
2
3
4
5
6
7
8
9
type Notificador interface { Enviar(msg string) error }

func NovoNotificador(tipo string) Notificador {
    switch tipo {
    case "email": return &NotificadorEmail{}
    case "sms":   return &NotificadorSms{}
    default:      return &NotificadorLog{}
    }
}

¿Por qué importa esto en equipos multidisciplinarios?

Cuando tienes un equipo con desarrolladores de C#, Go, Python y TypeScript, los patrones GoF son la lingua franca del diseño. La conversación:

“Necesitamos un Observer aquí, porque varios módulos deben reaccionar cuando cambia el estado del pedido”

…tiene sentido para todos, sin importar el lenguaje que cada uno usa en el día a día. Sin ese vocabulario común, la conversación sería:

“Necesitamos una clase que, cuando cambia el estado, llame a una lista de otras clases que tienen un método que… ya me entiendes”


La Era de la Nube y los Microservicios

Cómo la nube cambió el contexto, no los problemas

La migración a la nube trajo nuevos problemas de escala, disponibilidad y distribución. Pero los problemas fundamentales — acoplamiento, cohesión, separación de responsabilidades — no cambiaron. Lo que cambió fue dónde aparecen los problemas y cuánto cuesta una mala decisión.

EraEntornoCosto de fallaEscalaPatrón central
MonolitoServidor únicoControladoVerticalGoF clásico
SOARed internaModeradoModeradaAdapter, Facade
MicroserviciosNube distribuidaAlto (cascada)Horizontal ilimitadaPatrones distribuidos
ServerlessNube efímeraVariableAuto-scalingStateless por diseño
HíbridoMixtoComplejoHeterogéneaAbstracción de infraestructura

Línea de tiempo de la evolución de la arquitectura de software: Monolito, SOA, GoF formalizado, Cloud Native e Híbrido

Nuevos patrones para nuevos problemas

La nube trajo una nueva generación de patrones, muchos de ellos construidos sobre los principios GoF:

Circuit Breaker (Disyuntor) — el Proxy aplicado a llamadas externas. Detecta fallas en cascada e interrumpe las llamadas a servicios degradados:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
// Polly implementa Circuit Breaker en .NET:
var pipeline = new ResiliencePipelineBuilder()
    .AddCircuitBreaker(new CircuitBreakerStrategyOptions
    {
        FailureRatio = 0.5,          // 50% de fallas → abre el disyuntor
        SamplingDuration = TimeSpan.FromSeconds(30),
        BreakDuration = TimeSpan.FromSeconds(15),
        OnOpened = args =>
        {
            logger.LogWarning("Circuit breaker ABIERTO para el servicio de pagos");
            return ValueTask.CompletedTask;
        }
    })
    .Build();

await pipeline.ExecuteAsync(async ct =>
    await gatewayPagamentos.ProcessarAsync(dados, ct));

Sidecar — el Decorator aplicado a nivel de infraestructura. Un proceso auxiliar que se ejecuta junto al servicio principal y agrega responsabilidades (logging, mTLS, rate limiting) sin modificar el código del servicio:

1
2
3
4
5
6
7
8
9
# Kubernetes: sidecar de logging (patrón Decorator a nivel de pod)
spec:
  containers:
  - name: api-pedidos          # contenedor principal
    image: api-pedidos:1.2
  - name: fluent-bit           # sidecar: recolecta y envía logs
    image: fluent/fluent-bit
    volumeMounts:
    - mountPath: /var/log/pods

Saga — Command + Observer aplicados a transacciones distribuidas. Como no existe transacción ACID entre microservicios, la Saga orquesta una secuencia de transacciones locales con compensaciones para las fallas:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// Saga orquestada con MassTransit:
// 1. Reservar stock           → si falla → compensar: nada
// 2. Cobrar pago              → si falla → compensar: liberar reserva
// 3. Programar envío          → si falla → compensar: reembolsar + liberar
// 4. Notificar al cliente     → si falla → compensar: log (no crítico)

public class FinalizarPedidoSaga : MassTransitStateMachine<FinalizarPedidoState>
{
    public State Reservando { get; private set; } = null!;
    public State Cobrando { get; private set; } = null!;
    public State Enviando { get; private set; } = null!;

    public FinalizarPedidoSaga()
    {
        Initially(
            When(PedidoFinalizado)
                .Then(ctx => ctx.Saga.PedidoId = ctx.Message.PedidoId)
                .TransitionTo(Reservando)
                .Publish(ctx => new ReservarEstoqueCommand(ctx.Saga.PedidoId)));

        During(Reservando,
            When(EstoqueReservado)
                .TransitionTo(Cobrando)
                .Publish(ctx => new CobrarPagamentoCommand(ctx.Saga.PedidoId)),
            When(EstoqueFalhou)
                .Publish(ctx => new PedidoCanceladoEvent(ctx.Saga.PedidoId, "Sin stock"))
                .Finalize());
        // ...
    }
}

CQRS (Command Query Responsibility Segregation) — Command + Strategy aplicados a lectura/escritura:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
// Segregar lectura de escritura permite optimizaciones independientes
// Escritura: consistencia fuerte, validaciones, eventos de dominio
// Lectura: desnormalización, caché, read replicas, proyecciones

// Command side (escritura):
public record CriarPedidoCommand(int ClienteId, List<ItemDto> Itens)
    : ICommand<PedidoCriadoResult>;

// Query side (lectura — sin entidades de dominio, directo a la base de lectura):
public record ListarPedidosQuery(int ClienteId, int Pagina)
    : IQuery<PagedResult<PedidoResumoDto>>;

public class ListarPedidosHandler(IReadDbContext db)
    : IQueryHandler<ListarPedidosQuery, PagedResult<PedidoResumoDto>>
{
    public async Task<PagedResult<PedidoResumoDto>> HandleAsync(ListarPedidosQuery q)
        => await db.PedidosView  // view desnormalizada, optimizada para lectura
            .Where(p => p.ClienteId == q.ClienteId)
            .OrderByDescending(p => p.DataCriacao)
            .ToPagedResultAsync(q.Pagina);
}

Cloud vs On-Premises: la decisión arquitectónica más cara

La dicotomía cloud vs on-premises no es técnica — es estratégica y tiene implicaciones arquitectónicas profundas:

DimensiónCloudOn-PremisesHíbrido
EscalabilidadElástica (pagas por uso)Limitada por el hardwareBurst hacia la nube
LatenciaDepende de la regiónPredecible, bajaComplejidad de enrutamiento
CumplimientoVaría por nube/regiónControl total de los datosDatos sensibles: on-prem
CapEx vs OpExOpEx dominanteCapEx dominanteMixto
Vendor lock-inAlto (PaaS/SaaS)BajoModerado
Complejidad opsBaja (managed)Alta (equipo de infra)Muy alta
Patrones de apoyoAdapter (abstraer el SDK de la nube)Sin necesidadAnti-Corruption Layer

El Adapter como anti-lock-in: los equipos que construyen directamente sobre los proveedores de nube en todo el código quedan atrapados. La solución es usar el patrón Adapter para abstraer la infraestructura:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// ❌ Lock-in directo a Azure:
public class PedidoService
{
    private readonly BlobServiceClient _blob;   // Azure SDK directo
    private readonly ServiceBusClient _bus;     // Azure SDK directo

    public async Task ProcessarAsync(Pedido p)
    {
        await _blob.GetBlobContainerClient("pedidos")
            .UploadBlobAsync(p.Id.ToString(), /* ... */);
        await _bus.CreateSender("pedidos").SendMessageAsync(/* ... */);
    }
}

// ✅ Con abstracción (Adapter + Facade):
public class PedidoService(IArmazenamento storage, IFilaMensagens fila)
{
    public async Task ProcessarAsync(Pedido p)
    {
        await storage.SalvarAsync("pedidos", p.Id.ToString(), p);
        await fila.PublicarAsync("pedidos", new PedidoCriadoEvent(p.Id));
    }
}

// Las implementaciones pueden intercambiarse sin tocar el servicio:
// services.AddSingleton<IArmazenamento, AzureBlobStorage>();
// services.AddSingleton<IArmazenamento, S3Storage>();
// services.AddSingleton<IArmazenamento, LocalFileSystem>(); // dev/test

Equipos de Desarrollo y Equipos de Soporte

Esta es, quizá, la dimensión más subestimada de la arquitectura de software. Todo sistema exitoso termina siendo mantenido por personas que no lo construyeron. A veces por un equipo diferente. A veces años después. A veces por desarrolladores con perfiles y habilidades muy distintos.

El ciclo de vida real de un sistema

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
Fase 1 — Construcción (6-18 meses):
  Equipo original: seniors motivados, conocimiento profundo del dominio
  Foco: velocidad de entrega, features, go-to-market
  Riesgo: decisiones rápidas sin documentar trade-offs

Fase 2 — Crecimiento (1-3 años):
  Equipo: mezcla de originales + nuevos miembros
  Foco: escalar equipos, mantener la velocidad
  Riesgo: divergencia de patrones, "islas de conocimiento"

Fase 3 — Madurez (3-10 años):
  Equipo: principalmente soporte, pocos originales
  Foco: estabilidad, correcciones, pequeñas evoluciones
  Riesgo: "nadie sabe por qué existe este código"

Fase 4 — Legado (10+ años):
  Equipo: soporte, posiblemente offshore
  Foco: mantenerlo funcionando sin romper
  Riesgo: reescritura forzada por acumulación de deuda técnica

Por qué los patrones son la memoria institucional del sistema

Cuando un desarrollador nuevo llega a un sistema que usa los patrones GoF de forma consistente, no necesita reinventar la lectura del código. Al ver IStrategy como dependencia inyectada en una clase, entiende de inmediato:

  1. Esa clase tiene comportamiento que puede variar
  2. Las implementaciones están en otros archivos, llamados XXXStrategy
  3. Para agregar un nuevo comportamiento, basta con crear una nueva implementación
  4. El código existente no necesita cambiar (Open/Closed Principle)

Sin ese vocabulario compartido, el mismo escenario produce:

“¿Por qué hay una interfaz aquí con una sola implementación? Esto parece desperdicio.”

…seguido de una refactorización bienintencionada que elimina la abstracción, genera acoplamiento, vuelve otro código más difícil de probar y rompe el comportamiento en producción.

Diversidad de equipos: un activo con costo de coordinación

Los equipos modernos de software son multidisciplinarios por necesidad:

RolFoco principalPerspectiva de arquitectura
Desarrollador BackendLógica de negocio, APIsPatrones de dominio, CQRS, Event Sourcing
Desarrollador FrontendUX, rendimiento de renderPatrones de componentes, estado global
Data EngineerPipelines, ETL, analyticsPatrones de datos, streaming
DevOps / SREDisponibilidad, observabilidadPatrones de infra, resiliencia
Arquitecto de SolucionesIntegración, dominioPatrones enterprise, contextos delimitados
Tech Lead / Staff EngDecisiones de plataformaTodos los niveles
Soporte N1/N2Triage, correcciones rápidasPatrones de mantenibilidad

El riesgo de equipos sin lenguaje común:

  • Un Data Engineer implementa un pipeline con lógica de negocio que duplica lo que ya existe en el dominio
  • Un DevOps crea scripts de deploy que asumen detalles de implementación que el equipo de backend cambió
  • El soporte N2 corrige un bug en el Adapter sin entender que hay múltiples implementaciones, rompiendo otra

La arquitectura documentada — con patrones nombrados, decision records (ADRs) y diagramas de contexto — es lo que permite que personas con perspectivas diferentes contribuyan sin colisiones.

Architecture Decision Records (ADRs)

Para cada decisión arquitectónica relevante, documenta:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
# ADR-007: Uso del patrón Strategy para el cálculo de envío

**Estado:** Aceptado  
**Fecha:** 2025-03-15  
**Contexto:** El cálculo de envío debe soportar múltiples transportistas,
con la posibilidad de agregar nuevos sin modificar el código existente.

**Decisión:** Implementar usando el patrón Strategy con inyección de dependencias.
La selección de la estrategia se hará en la composition root según la configuración.

**Consecuencias:**
- ✅ Agregar un nuevo transportista = crear una nueva clase, sin modificar código existente
- ✅ Cada estrategia se puede probar de forma aislada
- ✅ La regla de selección queda explícita y centralizada
- ⚠️ Más clases en el proyecto (aceptable, cada una tiene una responsabilidad clara)
- ❌ No usar: cuando hay una sola forma de calcular y no hay perspectiva de cambio

**Patrones relacionados:** Factory Method (para crear la Strategy correcta), Open/Closed Principle

Ese registro vale oro para el equipo de soporte 3 años después. Sin él, la pregunta “¿por qué existe esta interfaz?” no tiene respuesta — y la respuesta improvisada suele ser incorrecta.


Principios que Sostienen Todo

Los patrones GoF no existen en el vacío. Son expresiones prácticas de principios más fundamentales. Los más importantes:

SOLID

PrincipioDefiniciónPatrón GoF que lo expresa
S — Single ResponsibilityUna clase, una razón para cambiarFacade (aísla responsabilidades), Command
O — Open/ClosedAbierto a extensión, cerrado a modificaciónStrategy, Decorator, Observer
L — Liskov SubstitutionLas subclases deben poder sustituir a sus basesFactory Method, Template Method
I — Interface SegregationInterfaces pequeñas y enfocadasAdapter, Proxy
D — Dependency InversionDepende de abstracciones, no de implementacionesTodos los patrones vía DI

Cohesión y Acoplamiento

Alta cohesión, bajo acoplamiento — quizá el principio más antiguo y más violado de la ingeniería de software.

  • Alta cohesión: cada módulo/clase hace una cosa bien hecha. Facade, Strategy y Command promueven la cohesión.
  • Bajo acoplamiento: los módulos tienen pocas dependencias entre sí. Observer, Mediator y Event Bus reducen el acoplamiento.

Ley de Demeter (Principio del Menor Conocimiento)

Un módulo debe conocer solo a sus colaboradores inmediatos — no a los colaboradores de sus colaboradores.

1
2
3
4
5
6
7
// ❌ Viola Demeter — "train wreck code"
// El servicio conoce la estructura interna de 4 objetos diferentes:
var cidade = pedido.Cliente.Endereco.Cidade.Nome;

// ✅ Respeta Demeter — agregar un método al objeto responsable:
var cidade = pedido.ObterCidadeEntrega();
// "Toma solo un paso a la vez"

Trampas: Cuando los Patrones Estorban

Los patrones aplicados sin criterio son tan perjudiciales como ningún patrón. Los antipatrones más comunes:

Overengineering (“patronitis”)

1
2
3
4
5
6
7
// ❌ Factory para una única implementación que no va a cambiar:
public interface ICalculadorImposto { decimal Calcular(decimal valor); }
public class CalculadorImpostoFactory { public ICalculadorImposto Criar() => new CalculadorImposto(); }
public class CalculadorImposto : ICalculadorImposto { public decimal Calcular(decimal v) => v * 0.12m; }

// ✅ Cuando hay una sola implementación y ninguna previsión de cambio:
public static decimal CalcularImposto(decimal valor) => valor * 0.12m;

Singleton como variable global

El Singleton es el patrón más abusado. Cuando todo es Singleton, en esencia recreas estado global:

1
2
3
4
5
6
7
8
9
// ❌ Singleton como acceso global (dificulta las pruebas, oculta dependencias):
var db = DatabaseSingleton.Instancia;       // acoplamiento global
var cache = CacheSingleton.Instancia;       // imposible de probar de forma aislada
var config = ConfigSingleton.Instancia;     // los cambios afectan a toda la app silenciosamente

// ✅ Singleton administrado por el contenedor de DI (testeable, sustituible):
services.AddSingleton<IDatabaseContext, DatabaseContext>();
services.AddSingleton<ICache, RedisCache>();
// En las pruebas: AddSingleton<ICache, InMemoryCache>()

Abstracción prematura

No uses patrones para problemas que todavía no tienes:

“You Aren’t Gonna Need It” (YAGNI) — no agregues complejidad para necesidades hipotéticas.

La regla práctica: cuando el problema aparezca por segunda vez, considera un patrón. Cuando aparezca por tercera vez, aplícalo.


Conclusión

Los patrones GoF cumplen 30 años y siguen en la lista de lectura obligatoria de ingenieros de software de todo el mundo — no por veneración nostálgica, sino porque los problemas que resuelven no desaparecieron. Nombrar soluciones para problemas recurrentes es una de las herramientas más poderosas de la ingeniería.

Lo que cambió no fueron los problemas fundamentales, sino el contexto en que aparecen:

  • En un monolito, un Observer mal aplicado genera código difícil de leer. En un sistema distribuido, genera una cascada de fallas que derriba múltiples servicios.
  • En un proyecto de un solo desarrollador, un Singleton sin DI es una molestia. En un equipo de 50 personas, crea dependencias ocultas que nadie ve hasta que el sistema cae en producción.
  • En un entorno on-premises estático, el acoplamiento a una implementación específica es manejable. En el ecosistema de nube híbrida, crea deudas de migración de meses.

La arquitectura de software — especialmente sus patrones nombrados — es lo que permite que los sistemas sobrevivan más allá de su generación original de desarrolladores. Es lo que permite que un desarrollador que entra hoy a un proyecto entienda las intenciones de diseño de quien construyó el sistema hace 5 años. Es lo que permite que el equipo de soporte corrija un bug sin introducir accidentalmente tres nuevos.

Aprende los 23 patrones GoF. No para aplicarlos todos — sino para tener un vocabulario que te permita pensar, comunicar y documentar decisiones de diseño con precisión. El software que escribes hoy alguien lo mantendrá mañana. Deja mensajes claros.


Lee También


Referencias