Qué son los patrones de diseño y los más usados en programación

Imagina que estás construyendo una casa. En lugar de inventar una nueva forma de instalar las tuberías o diseñar una escalera desde cero, utilizas planos y técnicas arquitectónicas que han demostrado funcionar durante décadas. En la ingeniería de software, estos "planos comprobados" se conocen como patrones de diseño.

Los patrones de diseño no son fragmentos de código listos para copiar y pegar, sino soluciones conceptuales a problemas comunes que los desarrolladores enfrentan repetidamente en el diseño de software orientado a objetos. Fueron popularizados en 1994 por el libro "Design Patterns: Elements of Reusable Object-Oriented Software", escrito por un grupo conocido cariñosamente como el Gang of Four (GoF).

¿Por qué deberías aprender patrones de diseño?

• Soluciones probadas: Son el resultado del ensayo y error de miles de desarrolladores. Funcionan, y funcionan bien.
• Vocabulario común: Cuando le dices a otro programador "usemos un Observer aquí", ambos entienden exactamente la arquitectura sin necesidad de explicar la lógica interna.
• Código más limpio: Muchos patrones están íntimamente relacionados con los Principios SOLID, ayudando a mantener tu código desacoplado y mantenible.

Clasificación de los patrones de diseño

El "Gang of Four" clasificó los 23 patrones originales en tres grandes categorías:

1. Creacionales: Tratan sobre la inicialización y creación de objetos (cómo instanciarlos de forma segura).
2. Estructurales: Se enfocan en cómo las clases y objetos se componen para formar estructuras más grandes y complejas.
3. De Comportamiento: Gestionan algoritmos, relaciones y la comunicación entre los objetos.

Los 5 Patrones de Diseño más utilizados

Aunque existen muchos, hay algunos que todo desarrollador encontrará en su día a día. Veamos los más populares con ejemplos prácticos en PHP.

1. Singleton (Creacional)

Propósito: Asegura que una clase tenga una única instancia en toda la aplicación y proporciona un punto de acceso global a ella.

Es muy común usarlo para gestionar la conexión a la base de datos o leer configuraciones globales. Si instanciáramos la base de datos en cada clase, saturaríamos el servidor de conexiones.

class Database {
    private static $instancia = null;
    private $conexion;

    // El constructor es privado para evitar "new Database()"
    private function __construct() {
        $this->conexion = new PDO("mysql:host=localhost;dbname=test", "root", "");
    }

    public static function getInstancia() {
        if (self::$instancia === null) {
            self::$instancia = new Database();
        }
        return self::$instancia;
    }
}

// Uso:
$db1 = Database::getInstancia();
$db2 = Database::getInstancia();
// $db1 y $db2 son exactamente el mismo objeto en memoria

2. Factory Method (Creacional)

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

Es muy útil cuando tu sistema debe crear múltiples tipos de objetos relacionados sin acoplar el código a las clases concretas. Piensa en un sistema de notificaciones.

interface Notificacion {
    public function enviar($mensaje);
}

class EmailNotificacion implements Notificacion {
    public function enviar($mensaje) { echo "Enviando Email: $mensaje"; }
}

class SmsNotificacion implements Notificacion {
    public function enviar($mensaje) { echo "Enviando SMS: $mensaje"; }
}

class NotificacionFactory {
    public static function crear($tipo): Notificacion {
        switch ($tipo) {
            case 'email': return new EmailNotificacion();
            case 'sms': return new SmsNotificacion();
            default: throw new Exception("Tipo no soportado");
        }
    }
}

// Uso:
$notificacion = NotificacionFactory::crear('email');
$notificacion->enviar("¡Hola Mundo!");

3. Strategy (De Comportamiento)

Propósito: Permite definir una familia de algoritmos, encapsular cada uno en una clase separada y hacerlos intercambiables en tiempo de ejecución.

¿Recuerdas el Principio Open/Closed de SOLID? El patrón Strategy es su máxima expresión. Es perfecto para algoritmos de ordenamiento, cálculos de impuestos o métodos de pago.

interface MetodoPago {
    public function cobrar($monto);
}

class PagoPaypal implements MetodoPago {
    public function cobrar($monto) { echo "Cobrando $monto vía PayPal."; }
}

class PagoStripe implements MetodoPago {
    public function cobrar($monto) { echo "Cobrando $monto vía Stripe."; }
}

class Carrito {
    private $metodoPago;

    // Inyectamos la estrategia
    public function setMetodoPago(MetodoPago $metodoPago) {
        $this->metodoPago = $metodoPago;
    }

    public function procesarCheckout($monto) {
        $this->metodoPago->cobrar($monto);
    }
}

// Uso:
$carrito = new Carrito();
$carrito->setMetodoPago(new PagoStripe());
$carrito->procesarCheckout(100); // Usa Stripe

4. Observer (De Comportamiento)

Propósito: Define una dependencia de "uno a muchos" entre objetos, de manera que cuando un objeto cambia de estado, todos sus dependientes son notificados y actualizados automáticamente.

Es la base de la programación reactiva y los sistemas de eventos (como los Event Listeners de Laravel o JavaScript).

interface Suscriptor {
    public function actualizar($noticia);
}

class Lector implements Suscriptor {
    private $nombre;
    public function __construct($nombre) { $this->nombre = $nombre; }
    public function actualizar($noticia) {
        echo "{$this->nombre} recibió la noticia: $noticia 
";
    }
}

class Blog {
    private $suscriptores = [];

    public function suscribir(Suscriptor $suscriptor) {
        $this->suscriptores[] = $suscriptor;
    }

    public function publicarNuevoArticulo($titulo) {
        // Notificamos a todos los observers
        foreach ($this->suscriptores as $sub) {
            $sub->actualizar($titulo);
        }
    }
}

// Uso:
$blog = new Blog();
$blog->suscribir(new Lector("Juan"));
$blog->suscribir(new Lector("María"));

// Ambos lectores recibirán una notificación automática
$blog->publicarNuevoArticulo("Patrones de Diseño en PHP");

5. Adapter / Wrapper (Estructural)

Propósito: Actúa como un puente entre dos interfaces incompatibles. Permite que clases trabajen juntas cuando de otro modo no podrían debido a interfaces diferentes.

Muy usado cuando integras una librería externa vieja o de terceros con tu código moderno.

// La interfaz de nuestro sistema moderno
interface StorageModerno {
    public function guardar($archivo);
}

// Una librería de terceros o antigua (incompatible)
class AmazonS3Viejo {
    public function uploadFileToCloud($file) {
        echo "Subiendo $file a S3...";
    }
}

// El Adaptador
class S3Adapter implements StorageModerno {
    private $s3Viejo;

    public function __construct(AmazonS3Viejo $s3Viejo) {
        $this->s3Viejo = $s3Viejo;
    }

    // Adaptamos el método moderno al antiguo
    public function guardar($archivo) {
        $this->s3Viejo->uploadFileToCloud($archivo);
    }
}

// Uso: Nuestro sistema solo usa "guardar()"
$storage = new S3Adapter(new AmazonS3Viejo());
$storage->guardar("imagen.jpg");

Conclusión: Cuidado con la "Patronitis"

Conocer los patrones de diseño es un superpoder, pero como diría el Tío Ben: "Un gran poder conlleva una gran responsabilidad". Un error común en desarrolladores junior/mid es sufrir de "patronitis": intentar forzar un patrón de diseño en cada línea de código, lo que lleva a un sistema innecesariamente complejo (over-engineering).

Recuerda: Los patrones son soluciones a problemas. Si no tienes el problema, no implementes la solución. Usa el sentido común, comienza con código simple, y refactoriza aplicando un patrón solo cuando el código empiece a volverse difícil de mantener.