Curso de Java 11 Avanzado y Patrones para equipos de desarrollo

Patrón Singleton y control de una única instancia en aplicaciones Java.

Implementación clásica del Singleton y análisis de sus limitaciones.

Singleton thread-safe en entornos concurrentes.

Double checked locking, enum singleton y comparación entre variantes.

Casos de uso reales del Singleton y situaciones donde conviene evitarlo.

Impacto del Singleton en testing, concurrencia, acoplamiento y mantenibilidad.

Patrón Factory Method para delegar la creación de objetos sin acoplar el cliente a clases concretas.

Implementación de Factory Method en Java con herencia, interfaces y polimorfismo.

Uso de Factory Method en frameworks, servicios, configuración e integración con Spring.

Patrón Abstract Factory para crear familias de objetos relacionados manteniendo diseño desacoplado.

Diferencias entre Factory Method y Abstract Factory.

Extensibilidad, testing, refactorización, ventajas, limitaciones y buenas prácticas de estos patrones.

Patrón Builder para construir objetos complejos de forma clara, segura y mantenible.

Fluent API aplicada a configuraciones, peticiones, respuestas, modelos de dominio y objetos inmutables.

Builder inmutable y validación interna para evitar estados inconsistentes.

Comparación entre Builder, telescoping constructor, setters, factories, records y constructores tradicionales.

Integración con Lombok y revisión crítica de sus ventajas y riesgos.

Patrón Prototype para crear nuevos objetos a partir de instancias existentes.

Clonación superficial y clonación profunda.

Implementación con Cloneable y alternativas más seguras en Java moderno.

Copias seguras, control de referencias compartidas y prevención de efectos secundarios.

Integración con serialización, rendimiento, testing, limitaciones y buenas prácticas de Prototype.

Patrón Adapter para conectar interfaces incompatibles sin modificar código existente.

Adapter de clase y Adapter de objeto.

Integración con APIs legacy, librerías externas, sistemas antiguos y servicios de terceros.

Uso de Adapter en refactorización progresiva y arquitectura hexagonal.

Testing de adaptadores mediante dobles, contratos y simulación de proveedores.

Patrón Facade para simplificar subsistemas complejos y ofrecer una interfaz clara.

Uso de Facade en APIs complejas, módulos internos, servicios empresariales e integraciones.

Facade como herramienta de desacoplamiento arquitectónico.

Patrón Bridge para separar abstracción e implementación cuando ambas deben evolucionar de forma independiente.

Comparación entre Bridge y Adapter.

Casos empresariales, ventajas, limitaciones, refactorización y buenas prácticas de Adapter, Facade y Bridge.

Patrón Decorator para extender comportamiento dinámicamente usando composición.

Comparación entre Decorator y herencia.

Uso de Decorator en Java IO, filtros, validadores, middlewares, wrappers y pipelines.

Testing, refactorización, ventajas y limitaciones de Decorator.

Patrón Proxy: proxy virtual, proxy remoto, proxy de protección y proxy dinámico.

Uso de Proxy con reflexión, frameworks, lazy loading, seguridad, logging, caché y control de acceso.

Patrón Composite para representar estructuras jerárquicas con tratamiento uniforme.

Aplicación de Composite en árboles, menús, UI, permisos, estructuras organizativas y modelos de contenido.

Patrón Flyweight para compartir estado y reducir consumo de memoria.

Integración de Flyweight con cachés, pools, objetos inmutables y optimización de rendimiento.

Casos empresariales, arquitectura, testing y buenas prácticas de estos patrones estructurales.

Patrón Strategy para intercambiar algoritmos en tiempo de ejecución.

Implementación de Strategy con interfaces, clases, lambdas y programación funcional.

Uso de Strategy en reglas de negocio, pricing, validaciones, cálculos, filtros y políticas.

Refactorización desde condicionales complejos hacia estrategias intercambiables.

Patrón Template Method para definir algoritmos parametrizables con pasos comunes y variables.

Implementación abstracta, hooks, integración con frameworks y reutilización de estructura.

Comparación entre Strategy y Template Method.

Patrón State para gestionar objetos cuyo comportamiento cambia según su estado interno.

Comparación entre State y Strategy.

Testing, arquitectura limpia, ventajas, limitaciones y buenas prácticas de estos patrones.

Patrón Observer para reaccionar a cambios mediante suscriptores, listeners y eventos.

Implementación clásica de Observer con interfaces.

Event listeners, integración con Streams y uso en sistemas empresariales.

Concurrencia, orden de notificación, memoria, desacoplamiento y testing en Observer.

Patrón Command para encapsular acciones, peticiones, operaciones y tareas ejecutables.

Undo, redo, colas, menús, UI, jobs, auditoría y operaciones diferidas con Command.

Implementación funcional de Command mediante lambdas, handlers y objetos de acción.

Patrón Chain of Responsibility para encadenar validadores, filtros, middlewares y pasos de procesamiento.

Integración con filtros, seguridad, validación, pipelines y flujos empresariales.

Refactorización, testing, ventajas, limitaciones, arquitectura y buenas prácticas de estos patrones.

Patrón Mediator para coordinar componentes sin dependencias directas entre ellos.

Implementación profesional de Mediator en UI, módulos, workflows, casos de uso y procesos empresariales.

Ventajas y limitaciones de Mediator frente a servicios centrales excesivamente acoplados.

Integración de Mediator con arquitectura de aplicación y comunicación entre componentes.

Patrón Memento para capturar y restaurar estados sin romper encapsulación.

Implementación segura de Memento en editores, asistentes, históricos, rollback y recuperación.

Coste de memoria, rendimiento, serialización, límites y testing de Memento.

Patrón Visitor para separar operaciones de estructuras de objetos complejas.

Implementación de Visitor en jerarquías, árboles, AST, validadores, exportadores y transformadores.

Refactorización, integración, arquitectura, ventajas, limitaciones y buenas prácticas de Mediator, Memento y Visitor.

Interfaces funcionales y su relación con diseño flexible y patrones modernos.

Lambdas aplicadas a estrategias, comandos, filtros, transformaciones y callbacks.

Method references para mejorar legibilidad y reducir ruido sintáctico.

Streams avanzados para procesamiento declarativo de colecciones.

Collectors personalizados para agregaciones, agrupaciones y transformaciones complejas.

Optional avanzado para modelar ausencia de valor sin abusar de null ni ocultar errores.

Inmutabilidad como herramienta de seguridad, concurrencia, claridad y diseño limpio.

Paralelismo con streams, ventajas, limitaciones y riesgos de uso indiscriminado.

Integración de programación funcional con patrones clásicos de diseño.

Buenas prácticas y limitaciones de la programación funcional en aplicaciones Java empresariales.

Conceptos reactivos y diferencias entre programación síncrona, asíncrona, concurrente y no bloqueante.

Reactive Streams como base para interoperabilidad y control de flujo.

Project Reactor y sus tipos principales para construir flujos reactivos.

Backpressure y gestión de presión cuando productores y consumidores avanzan a distinta velocidad.

Programación no bloqueante aplicada a APIs, integraciones, colas, eventos y servicios externos.

Integración con Spring y ecosistemas reactivos empresariales.

Manejo de errores, retries, timeouts, fallback y recuperación controlada.

Testing reactivo con herramientas específicas y verificación de flujos.

Escalabilidad, rendimiento y límites reales de la programación reactiva.

Buenas prácticas para decidir cuándo usar programación reactiva y cuándo no compensa su complejidad.

Threads, Runnable y fundamentos de ejecución concurrente.

ExecutorService para gestionar pools, tareas, planificación y control de recursos.

ForkJoinPool y división de trabajo en tareas paralelizables.

CompletableFuture para composición asíncrona, pipelines, combinación de resultados y manejo de errores.

Locks avanzados, synchronized, ReadWriteLock y control fino de secciones críticas.

Atomic variables y estructuras concurrentes para evitar bloqueos innecesarios.

Sincronización, visibilidad de memoria, race conditions y problemas de consistencia.

Deadlocks, livelocks, starvation y estrategias para detectarlos y evitarlos.

Profiling concurrente, análisis de bloqueos, tiempos de espera y saturación de threads.

Buenas prácticas para diseñar concurrencia segura, mantenible, escalable y observable.

Comprender cómo gestiona memoria la JVM y cómo afecta al rendimiento de aplicaciones Java.

Tipos de Garbage Collector y criterios para elegir recolector según carga, latencia y tamaño de heap.

G1 como recolector equilibrado para muchos entornos empresariales.

ZGC para escenarios de baja latencia, heaps grandes y aplicaciones sensibles a pausas.

Análisis de heap, generación de dumps y lectura de información de memoria.

Profiling de CPU, memoria, asignaciones, pausas, threads y cuellos de botella.

Detección de memory leaks, referencias retenidas, cachés mal gestionadas y objetos de larga vida.

Optimización de asignaciones, estructuras de datos, objetos temporales y presión de memoria.

JVM tuning mediante parámetros, límites, observabilidad, métricas y validación con pruebas.

Diagnóstico de cuellos de botella y buenas prácticas para mejorar rendimiento sin introducir complejidad prematura.

Java Platform Module System como herramienta para modularidad fuerte.

Uso de module-info.java para declarar módulos, dependencias y exposición de paquetes.

Dependencias explícitas y reducción de acoplamiento accidental.

Encapsulación fuerte para proteger APIs internas y separar responsabilidades.

Diseño modular aplicado a aplicaciones empresariales grandes.

Integración de JPMS con Maven, builds, librerías internas y dependencias externas.

Seguridad y control de exposición mediante módulos bien definidos.

Refactorización modular de aplicaciones existentes.

Relación entre módulos, capas, bounded contexts, monolito modular y arquitectura empresarial.

Buenas prácticas para diseñar módulos que mejoren mantenibilidad sin añadir fricción innecesaria.

Testing unitario de patrones creacionales, estructurales y de comportamiento.

Testing de integración para adaptadores, proxies, repositorios, servicios externos y frameworks.

Testing de concurrencia, programación reactiva, streams, comandos, eventos y flujos asíncronos.

Testing de rendimiento para memoria, GC, latencia, throughput, bloqueos y consumo de recursos.

Refactorización hacia patrones cuando existe duplicidad, condicionales complejos, acoplamiento o código rígido.

Refactorización desde patrones mal aplicados hacia soluciones más simples.

Integración de patrones de diseño con Spring, inversión de dependencias, beans, configuración, perfiles y composición.

Uso de Factory, Proxy, Template Method, Strategy, Observer y Chain of Responsibility en aplicaciones Spring.

Validación de arquitectura para evitar dependencias prohibidas, ciclos y violaciones de capas.

Documentación técnica de decisiones, patrones usados, trade-offs, métricas y alternativas descartadas.

Diseñar una arquitectura empresarial Java aplicando principios SOLID, Clean Architecture y patrones de diseño.

Definir un dominio de negocio con entidades, servicios, casos de uso, módulos y límites claros.

Aplicar patrones creacionales para resolver construcción, configuración, familias de objetos y reutilización controlada.

Aplicar patrones estructurales para integrar APIs, simplificar subsistemas, optimizar memoria y desacoplar componentes.

Aplicar patrones de comportamiento para gestionar algoritmos, eventos, comandos, estados, workflows y operaciones complejas.

Incorporar programación funcional avanzada con lambdas, streams, collectors, Optional e inmutabilidad.

Integrar programación reactiva con Project Reactor cuando el caso requiera flujos no bloqueantes o backpressure.

Diseñar concurrencia controlada con ExecutorService, CompletableFuture, locks, atomics y prevención de deadlocks.

Analizar rendimiento de la JVM, tipos de Garbage Collector, G1, ZGC, heap, memory leaks y cuellos de botella.

Modularizar la solución con Java Platform Module System, Maven, dependencias explícitas y encapsulación fuerte.

Diseñar una estrategia de testing avanzado: unitario, integración, contrato, reactivo, concurrente y rendimiento.

Refactorizar partes del sistema para mejorar cohesión, reducir acoplamiento y eliminar anti-patrones.

Definir métricas de rendimiento, calidad de arquitectura, mantenibilidad y estabilidad.

Preparar documentación técnica con patrones aplicados, decisiones, trade-offs y justificación arquitectónica.

Presentar la solución final defendiendo diseño, modularización, concurrencia, rendimiento, testing y consolidación arquitectónica.