Dominando los Patrones de Diseño Esenciales: Fábrica, Singleton y Estrategia en Java

Introducción a los Patrones de Diseño

Los patrones de diseño representan soluciones estandarizadas a problemas comunes en el desarrollo de software. Son herramientas fundamentales que permiten a los ingenieros construir sistemas más robustos, mantenibles y extensibles. Comprender y aplicar estos patrones es crucial para diseñar arquitecturas de software eficientes y escalables en entornos como Java. A continuación, exploramos algunos de los patrones más influyentes: Fábrica, Singleton y Estrategia.

Patrón de Fábrica: Abstracción de la Creación de Objetos

El patrón de Fábrica (Factory Method o Simple Factory, en sus variantes) se centra en delegar la lógica de creación de objetos a una clase especializada, la "fábrica". Esto desacopla el código cliente de la implementación concreta de los productos, promoviendo la adherencia al principio de abierto/cerrado (Open/Closed Principle).

Principio Fundamental

La idea central es permitir que las clases decidan qué objetos instanciar, postegrando esa decisión a subclases o métodos especializados. El cliente interactúa únicamente con una interfaz o clase abstracta del producto.

// Interfaz de producto abstracto
public interface Documento {
    void mostrarContenido();
    void exportar(String formato);
}

// Producto concreto: Documento PDF
public class DocumentoPDF implements Documento {
    @Override
    public void mostrarContenido() {
        System.out.println("Visualizando contenido de un documento PDF.");
    }

    @Override
    public void exportar(String formato) {
        System.out.println("Exportando PDF a formato: " + formato);
    }
}

// Producto concreto: Documento Word
public class DocumentoWord implements Documento {
    @Override
    public void mostrarContenido() {
        System.out.println("Visualizando contenido de un documento Word.");
    }

    @Override
    public void exportar(String formato) {
        System.out.println("Exportando Word a formato: " + formato);
    }
}

// Clase Fábrica: Gestor de creación de documentos
public class GestorDocumentos {
    public Documento crearDocumento(String tipoDocumento) {
        if ("pdf".equalsIgnoreCase(tipoDocumento)) {
            return new DocumentoPDF();
        } else if ("word".equalsIgnoreCase(tipoDocumento)) {
            return new DocumentoWord();
        }
        throw new IllegalArgumentException("Tipo de documento no soportado: " + tipoDocumento);
    }
}

Ventajas clave: Reduce el acoplamiento entre el cliente y las clases concretas, facilita la adición de nuevos tipos de productos sin modificar el código existente del cliente.

El Patrón Fábrica en el Ecosistema Spring

El framework Spring utiliza intensivamente el concepto de fábrica. La interfaz org.springframework.beans.factory.BeanFactory es un ejemplo canónico de una fábrica de objetos que gestiona el ciclo de vida y la creación de componentes (beans) dentro de una aplicación, abstraendo completamente su instanciación del código de negocio.

Patrón Singleton: Garantizando una Única Instancia

El patrón Singleton restringe la instanciación de una clase a un único objeto. Esto es particularmente útil para recursos que deben ser compartidos globalmente o que consumen muchos recursos si se crean múltiples veces, como un administrador de configuración, un registrador de eventos (logger) o una conexión a base de datos.

Implementaciones Comunes

Existen varias maneras de implementar el patrón Singleton de forma segura y eficiente.

// Implementación "Eager" (Ansiosa): La instancia se crea al cargar la clase.
public class ConfiguracionAplicacion {
    private static final ConfiguracionAplicacion INSTANCIA_UNICA = new ConfiguracionAplicacion();

    // Constructor privado para evitar instanciaciones externas
    private ConfiguracionAplicacion() {
        // Inicialización de la configuración
        System.out.println("Cargando configuración inicial de la aplicación.");
    }

    public static ConfiguracionAplicacion obtenerInstancia() {
        return INSTANCIA_UNICA;
    }

    public String obtenerPropiedad(String clave) {
        // Lógica para obtener una propiedad
        return "Valor de " + clave;
    }
}


// Implementación "Lazy" (Perezosa) con doble verificación y volatile:
// La instancia se crea solo cuando se solicita por primera vez, de forma segura en entornos concurrentes.
public class ConectorBaseDeDatos {
    private volatile static ConectorBaseDeDatos instancia; // 'volatile' asegura visibilidad entre hilos

    private ConectorBaseDeDatos() {
        // Lógica de inicialización de la conexión
        System.out.println("Inicializando conexión a la base de datos.");
    }

    public static ConectorBaseDeDatos obtenerInstancia() {
        if (instancia == null) { // Primera verificación: reduce contención del bloqueo
            synchronized (ConectorBaseDeDatos.class) { // Bloqueo a nivel de clase
                if (instancia == null) { // Segunda verificación: evita crear múltiples instancias
                    instancia = new ConectorBaseDeDatos();
                }
            }
        }
        return instancia;
    }

    public void ejecutarConsulta(String consulta) {
        System.out.println("Ejecutando consulta: '" + consulta + "' en la base de datos.");
    }
}

Escenarios de uso: Pool de conexiones, caché, gestores de logs, configuración del sistema.

Patrón de Estrategia: Flexibilidad en los Algoritmos

El patrón de Estrategia define una familia de algoritmos, encapsula cada uno de ellos y los hace intercambiables. Esto permite que el algoritmo varíe independientemente de los clientes que lo utilizan. Es ideal para situaciones donde un objeto necesita cambiar su comportamiento dinámicamente o cuando existen múltiples formas de realizar una tarea.

Estructura del Patrón Estrategia

// Interfaz de estrategia: Define el contrato para los algoritmos
public interface EstrategiaCalculoImpuesto {
    double calcularImpuesto(double ingresoBruto);
}

// Estrategia concreta: Cálculo de impuesto simplificado
public class ImpuestoFijo implements EstrategiaCalculoImpuesto {
    private static final double TASA_FIJA = 0.15; // 15%

    @Override
    public double calcularImpuesto(double ingresoBruto) {
        System.out.println("Calculando impuesto con tasa fija del " + (TASA_FIJA * 100) + "%.");
        return ingresoBruto * TASA_FIJA;
    }
}

// Estrategia concreta: Cálculo de impuesto progresivo
public class ImpuestoProgresivo implements EstrategiaCalculoImpuesto {
    @Override
    public double calcularImpuesto(double ingresoBruto) {
        System.out.println("Calculando impuesto con esquema progresivo.");
        if (ingresoBruto <= 20000) {
            return ingresoBruto * 0.10; // 10%
        } else if (ingresoBruto <= 50000) {
            return ingresoBruto * 0.20; // 20%
        } else {
            return ingresoBruto * 0.30; // 30%
        }
    }
}

// Clase Contexto: Utiliza una estrategia para realizar una operación
public class CalculadoraImpuestos {
    private EstrategiaCalculoImpuesto estrategia;

    public void establecerEstrategia(EstrategiaCalculoImpuesto estrategia) {
        this.estrategia = estrategia;
    }

    public double procesarCalculo(double ingresoBruto) {
        if (estrategia == null) {
            throw new IllegalStateException("No se ha establecido una estrategia de cálculo de impuestos.");
        }
        return estrategia.calcularImpuesto(ingresoBruto);
    }
}

Beneficios: Evita largas estructuras if-else o switch, promueve la extensibilidad y la reutilización de código.

El Patrón Estrategia en Spring Security

En frameworks como Spring, el patrón Estrategia se manifiesta en componentes como AuthenticationManager de Spring Security. Diferentes proveedores de autenticación (estrategias) pueden ser configurados y utilizados por el AuthenticationManager para procesar las solicitudes de autenticación.

Aplicaciones Prácticas y Combinación de Patrones

Gestión de Procesadores de Pago en un Sistema de Comercio Electrónico

Un sistema de comercio electrónico puede combinar los patrones Fábrica y Estrategia para menejar diferentes métodos de pago de forma flexible.

// Interfaz Estrategia: Define el contrato para el procesamiento de pagos
public interface EstrategiaPago {
    void procesarPago(double monto);
}

// Estrategia concreta: Pago con PayPal
public class PagoPayPal implements EstrategiaPago {
    @Override
    public void procesarPago(double monto) {
        System.out.println("Realizando pago de " + monto + " USD a través de PayPal.");
    }
}

// Estrategia concreta: Pago con Tarjeta de Crédito
public class PagoTarjetaCredito implements EstrategiaPago {
    @Override
    public void procesarPago(double monto) {
        System.out.println("Realizando pago de " + monto + " USD con Tarjeta de Crédito.");
    }
}

// Fábrica: Crea instancias de Estrategias de Pago
public class FabricaEstrategiasPago {
    public EstrategiaPago obtenerEstrategia(String tipoPago) {
        if ("paypal".equalsIgnoreCase(tipoPago)) {
            return new PagoPayPal();
        } else if ("tarjeta".equalsIgnoreCase(tipoPago)) {
            return new PagoTarjetaCredito();
        }
        throw new IllegalArgumentException("Tipo de pago no soportado: " + tipoPago);
    }
}

Esta combinación permite que el sistema añada nuevos métodos de pago simplemente creando una nueva implementación de EstrategiaPago y extendiendo la FabricaEstrategiasPago, sin alterar el código que solicita el pago.

Manejo de Estados en un Flujo de Pedidos (Patrón State)

El patrón State es útil para gestionar objetos cuyo comportamiento cambia según su estado interno. Por ejemplo, un objeto Pedido en un sistema de comercio electrónico puede pasar por diferentes estados (Pendiente, Procesado, Enviado, Entregado, Cancelado), y sus acciones disponibles varían en cada estado.

// Interfaz de estado
public interface EstadoPedido {
    void procesar(Pedido pedido);
    void cancelar(Pedido pedido);
}

// Estado concreto: Pedido Pendiente
public class EstadoPendiente implements EstadoPedido {
    @Override
    public void procesar(Pedido pedido) {
        System.out.println("Pedido pendiente, procesando...");
        pedido.establecerEstado(new EstadoProcesando());
    }

    @Override
    public void cancelar(Pedido pedido) {
        System.out.println("Cancelando pedido pendiente.");
        pedido.establecerEstado(new EstadoCancelado());
    }
}

// Clase Contexto: Pedido
public class Pedido {
    private EstadoPedido estadoActual;
    private String idPedido;

    public Pedido(String idPedido) {
        this.idPedido = idPedido;
        this.estadoActual = new EstadoPendiente(); // Estado inicial
        System.out.println("Nuevo pedido creado: " + idPedido + ", estado inicial: Pendiente.");
    }

    public void establecerEstado(EstadoPedido nuevoEstado) {
        this.estadoActual = nuevoEstado;
        System.out.println("El pedido " + idPedido + " ha cambiado a estado: " + nuevoEstado.getClass().getSimpleName());
    }

    public void procesarPedido() {
        estadoActual.procesar(this);
    }

    public void cancelarPedido() {
        estadoActual.cancelar(this);
    }
}

El patrón State encapsula la lógica de cada estado, haciendo que el objeto Pedido sea más limpio y fácil de mantener.

Consideraciones Avanzadas y Mejores Prácticas

Diferenciando Fábrica Simple y Fábrica Abstracta

  • Fábrica Simple: Se encarga de la creación de una única clase de productos, eligiendo entre diferentes implementaciones basadas en un parámetro.
  • Fábrica Abstracta: Proporciona una interfaz para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas. Es una fábrica de fábricas. Por ejemplo, una fábrica que puede producir componentes de UI para macOS y otra para Windows, cada una produciedno botones, casillas de verificación, etc., específicos de su sistema operativo.

Implementaciones Robustas del Patrón Singleton

Además de las mostradas, otras formas de implementar Singletons incluyen:

  • Bloque de inicialización estático: Similar al "Eager", pero permite manejar excepciones durante la inicialización.
  • Clase interna estática (Initialization-on-demand holder idiom): Considerada una de las mejores implementaciones para lazy loading y seguridad de hilos, sin necesidad de volatile o synchronized explícitos.
  • Enum (enumeraciones): La forma más sencilla y segura de implementar Singletons en Java, automáticamente manejando la serialización y la seguridad de hilos.

Inyección de Dependencias y Patrones en Spring

Spring promueve la Inyección de Dependencias (DI), que a menudo trabaja en conjunto con los patrones de diseño. Se prefiere la inyección por constructor por varias razones:

  • Asegura que las dependencias sean obligatorias y estén disponibles cuando se crea el objeto.
  • Permite que los objetos sean inmutables (final).
  • Facilita las pruebas unitarias al hacer explícitas las dependencias.
  • Cumple el principio de abierto/cerrado al no requerir setters mutables para las dependencias.

La combinación de patrones de diseño con la inyección de dependencias en frameworks como Spring resulta en aplicaciones altamente modulares, extensibles y fáciles de probar.

Etiquetas: java design-patterns factory-pattern singleton-pattern strategy-pattern

Publicado el 11-4 18:30

Etiquetas populares

©2026 Friki Work