Descripción y comparación

Los patrones de diseño son soluciones reutilizables a problemas que ocurren con frecuencia en el diseño de software. No son fragmentos de código terminados que se pegan: son planos, plantillas para resolver una clase de problema. Un patrón describe el problema, explica por qué fallan las soluciones ingenuas y le brinda una estructura comprobada que funciona. Los patrones surgieron del trabajo de arquitectura de Christopher Alexander y fueron incorporados al software por la "Banda de los Cuatro" (Gamma, Helm, Johnson, Vlissides) en su libro de 1994 "Patrones de diseño: elementos de software reutilizable orientado a objetos".

Un patrón no es un algoritmo. Un algoritmo define una secuencia exacta de pasos. Un patrón es una descripción de alto nivel de una solución; el mismo patrón se puede implementar de manera diferente en diferentes lenguajes y contextos.

Por qué son importantes los patrones

Las tres categorías

La Banda de los Cuatro clasificó los 23 patrones en tres categorías según su propósito. Los patrones de creación manejan la creación de objetos. Los patrones estructurales manejan cómo los objetos se componen en estructuras más grandes. Los patrones de comportamiento manejan la comunicación y la responsabilidad entre objetos. Comprender a qué categoría pertenece un patrón le indica inmediatamente qué problema está resolviendo.

Patrones de creación de un vistazo

Creacional: creación de objetos

Los patrones de creación abstraen el proceso de creación de instancias. Ayudan a que un sistema sea independiente de cómo se crean, componen y representan sus objetos. En lugar de llamar a los constructores directamente, se pasa por una interfaz: un método de fábrica, un objeto de fábrica, un constructor, un clon o un descriptor de acceso estático. Esto le brinda flexibilidad para cambiar lo que se crea, cómo y cuándo se crea, sin tocar el código del cliente. A medida que los sistemas crecen, la creación de objetos se convierte en una preocupación no trivial: es posible que necesite agrupar objetos, garantizar la unicidad, admitir múltiples representaciones o posponer una construcción costosa. Los patrones creacionales abordan todos estos.

Método de fábrica

Fábrica abstracta

Constructor

Prototipo

Semifallo

Patrones estructurales de un vistazo

Estructural: composición de objetos

Los patrones estructurales se ocupan de cómo se componen las clases y los objetos para formar estructuras más grandes. Los patrones estructurales basados en clases utilizan la herencia para componer interfaces. Los patrones estructurales basados en objetos describen formas de componer objetos para realizar nuevas funciones. La idea clave es que los diseños flexibles a menudo surgen no de jerarquías de herencia, sino de cómo los objetos se refieren y delegan entre sí. Los patrones estructurales le permiten ensamblar objetos en estructuras novedosas sin tener que reescribir las clases involucradas. Son especialmente valiosos al integrar bibliotecas de terceros, crear arquitecturas en capas u optimizar la memoria para gráficos de objetos grandes.

Adaptador

Puente

Compuesto

Decorador

Fachada

peso mosca

Apoderado

Patrones de comportamiento de un vistazo

Comportamiento - Comunicación de objetos

Los patrones de comportamiento caracterizan las formas en que las clases u objetos interactúan y distribuyen la responsabilidad. Cambian su enfoque de la estructura a la comunicación: quién envía mensajes a quién, en qué orden y quién maneja qué. Muchos de estos patrones desvinculan a los remitentes de los receptores: el remitente no sabe quién manejará una solicitud, ni siquiera si alguien lo hará. Otros encapsulan algoritmos para que puedan intercambiarse en tiempo de ejecución o registrar y restaurar el estado del objeto. Los patrones de comportamiento son el lugar donde se toman la mayoría de las decisiones de diseño del día a día: cómo fluyen los eventos a través del sistema, cómo se envían las solicitudes, cómo se modelan las máquinas de estado y cómo se implementa la funcionalidad de deshacer.

Cadena de Responsabilidad

Dominio

Iterador

Mediador

Recuerdo

Observador

Estado

Estrategia

Método de plantilla

Visitante

Los 23 patrones: la línea de tiempo completa

Comparación de patrones que a menudo se confunden

Varios patrones comparten similitudes a nivel de superficie (ambos envuelven objetos o ambos definen interfaces) pero resuelven problemas fundamentalmente diferentes. Las siguientes comparaciones aclaran la intención detrás de cada par o grupo.

Método de fábrica frente a fábrica abstracta frente a constructor

Adaptador vs Decorador vs Proxy

Estrategia vs Estado vs Método de plantilla

Observador vs Mediador vs Cadena de Responsabilidad

Compuesto vs decorador

Principios de diseño detrás de los patrones

Se aplican los patrones de principios

Los patrones no se inventan arbitrariamente: cada uno es una aplicación directa de uno o más principios de diseño fundamentales. Comprender el principio detrás de un patrón le ayuda a reconocer cuándo aplicarlo y cuándo es mejor una solución más simple. La Banda de los Cuatro identificó dos principios clave que sustentan casi los 23 patrones: 'Programar en una interfaz, no en una implementación', que permite toda la flexibilidad polimórfica, y 'Favorecer la composición de objetos sobre la herencia de clases', que evita el frágil problema de la clase base y permite la flexibilidad del tiempo de ejecución. A partir de estos dos principios, más SOLID (especialmente OCP y DIP), todo el catálogo de patrones se desprende de forma natural.

Programa para interfaces

Favorecer la composición

Principio abierto/cerrado

Inversión de dependencia

Responsabilidad única

Sustitución de Liskov

No te repitas

Cuándo NO usar patrones

Patrones en los marcos Java modernos

Donde ves patrones todos los días

Los patrones de diseño no son ejercicios académicos: son el andamiaje invisible de todos los principales marcos y bibliotecas de Java que utiliza. Spring Framework es un escaparate de patrones: su contenedor de IoC es Inyección de dependencia (una variante de Strategy + Factory), @Transactional usa Proxy dinámico, @Async usa Proxy, ApplicationEvent usa Observer, RestTemplate usa Template Method y DispatcherServlet de Spring MVC usa Chain of Responsibility para el mapeo de controladores. Hibernate usa Proxy para entidades con carga diferida, Identity Map (tipo Flyweight) para caché de sesión y Repositorio (Facade) para acceso a bases de datos. El paquete java.io está construido íntegramente en Decorator (envoltorios InputStream). JDBC utiliza un puente entre la API estándar y las implementaciones de proveedores. JavaFX y Swing utilizan Composite para el árbol de componentes y Observer para los detectores de eventos. Conocer patrones es saber cómo funcionan los marcos, no solo cómo llamar a sus API.

COI de primavera

@Proxy transaccional

Evento de aplicación

Hibernar proxy

Decorador de java.io

Puente JDBC

Compuesto de columpio

Haga clic en las líneas resaltadas para detectar el patrón dentro de Spring + Java SE

java

// ── Observer ─────────────────────────────────────────────────────

@EventListener

▼

public void onOrderPlaced(OrderPlacedEvent event) { ... }

// ── Proxy (@Transactional) ───────────────────────────────────────

@Transactional

▼

public void transferFunds(Account from, Account to, BigDecimal amount) { ... }

// ── Template Method ──────────────────────────────────────────────

JdbcTemplate.query(sql, rowMapper);

▼

// ── Decorator (java.io) ──────────────────────────────────────────

new BufferedReader(new InputStreamReader(socket.getInputStream()));

▼

// ── Strategy ─────────────────────────────────────────────────────

list.sort(Comparator.comparing(Person::getName));

▼

Conclusión clave: los patrones de diseño son un lenguaje, un vocabulario para decisiones de diseño. Dominarlos no significa memorizar 23 diagramas de clases. Significa comprender los problemas que resuelven, reconocer esos problemas en su propio código y saber cuándo los beneficios del patrón superan sus costos.

Qué sigue: los siguientes capítulos cubren cada patrón en profundidad, con diagramas interactivos, ejemplos de código completo y referencias de bibliotecas Java del mundo real. Comience con Patrones de creación, luego pase a Estructurales y luego a Comportamiento. Cada lección se basa en el vocabulario presentado aquí.