6 min. de lectura (aproximado)

Patrones de diseño en PHP: guía de los principales patrones

Los patrones de diseño son soluciones reutilizables y bien documentadas a problemas recurrentes en el diseño de software.

En el desarrollo web, especialmente con PHP, Laravel, Symfony, frameworks modernos o arquitecturas hexagonales/DDD los patrones de diseño adquieren especial relevancia porque las aplicaciones suelen crecer rápidamente, tienen múltiples capas (presentación, aplicación, dominio, infraestructura) y deben lidiar con cambios frecuentes de requisitos.

Clasificación clásica

Los patrones de diseño se agrupan tradicionalmente en tres categorías:

Categoría Propósito principal Ejemplos más usados en web
Creacionales Controlar la creación de objetos Factory Method, Abstract Factory, Builder, Singleton, Prototype
Estructurales Componer clases y objetos para formar estructuras mayores Adapter, Decorator, Facade, Proxy, Composite, Bridge
De comportamiento Definir cómo se comunican e interactúan los objetos Strategy, Observer, Command, State, Template Method, Chain of Responsibility, Mediator

Principales patrones creacionales

Factory Method

Centraliza la creación de objetos y desacopla el código cliente de las clases concretas.

interface Notification
{
public function send(string $message): void;
}

class EmailNotification implements Notification
{
public function send(string $message): void
{
// lógica de envío por email
}
}

class SmsNotification implements Notification
{
public function send(string $message): void
{
// lógica de envío por SMS
}
}

class NotificationFactory
{
public static function create(string $type): Notification
{
return match ($type) {
'email' => new EmailNotification(),
'sms' => new SmsNotification(),
default => throw new InvalidArgumentException("Tipo no soportado"),
};
}
}

// Uso
$notification = NotificationFactory::create('email');
$notification->send('Pedido confirmado');

Cuándo usarlo: cuando el tipo concreto de objeto se decide en tiempo de ejecución o cuando quieres ocultar la lógica de construcción.

Builder

Construye objetos complejos paso a paso. Muy útil para DTOs, queries o configuraciones.

class QueryBuilder
{
private array $select = [];
private ?string $from = null;
private array $where = [];

public function select(string ...$fields): self
{
$this->select = $fields;
return $this;
}

public function from(string $table): self
{
$this->from = $table;
return $this;
}

public function where(string $condition): self
{
$this->where[] = $condition;
return $this;
}

public function build(): string
{
return sprintf(
'SELECT %s FROM %s WHERE %s',
implode(', ', $this->select),
$this->from,
implode(' AND ', $this->where)
);
}
}

$query = (new QueryBuilder())
->select('id', 'name', 'email')
->from('users')
->where('active = 1')
->where('role = "admin"')
->build();

Singleton, usar con precaución

Garantiza una única instancia. En PHP moderno se recomienda evitarlo en favor de inyección de dependencias. Solo tiene sentido en casos muy controlados (conexiones a recursos externos muy costosos, por ejemplo).

Principales patrones estructurales

Adapter

Permite que clases incompatibles trabajen juntas (muy común al integrar APIs de terceros o librerías legacy).

// Interfaz que espera nuestro sistema
interface PaymentGateway
{
public function charge(float $amount, string $currency): bool;
}

// Clase de un proveedor externo con interfaz diferente
class StripeSdk
{
public function createCharge(int $cents, string $currencyCode): array { /* ... */ }
}

class StripeAdapter implements PaymentGateway
{
public function __construct(private StripeSdk $stripe) {}

public function charge(float $amount, string $currency): bool
{
$result = $this->stripe->createCharge((int)($amount * 100), $currency);
return $result['status'] === 'succeeded';
}
}

Decorator

Añade responsabilidades a un objeto de forma dinámica sin modificar su código.

interface Report
{
public function generate(): string;
}

class BasicReport implements Report
{
public function generate(): string
{
return "Datos del informe";
}
}

class PdfDecorator implements Report
{
public function __construct(private Report $report) {}

public function generate(): string
{
return "[PDF] " . $this->report->generate();
}
}

class EncryptedDecorator implements Report
{
public function __construct(private Report $report) {}

public function generate(): string
{
return base64_encode($this->report->generate());
}
}

$report = new EncryptedDecorator(new PdfDecorator(new BasicReport()));
echo $report->generate();

Facade

Proporciona una interfaz simple a un subsistema complejo (ideal para capas de infraestructura).

Principales patrones de comportamiento

Strategy

Define una familia de algoritmos intercambiables. Extremadamente útil en web (métodos de pago, formatos de exportación, algoritmos de cálculo, etc.).

interface TaxCalculator
{
public function calculate(float $amount): float;
}

class SpainTaxCalculator implements TaxCalculator
{
public function calculate(float $amount): float
{
return $amount * 0.21;
}
}

class UsaTaxCalculator implements TaxCalculator
{
public function calculate(float $amount): float
{
return $amount * 0.08;
}
}

class Order
{
public function __construct(
private float $amount,
private TaxCalculator $taxCalculator
) {}

public function total(): float
{
return $this->amount + $this->taxCalculator->calculate($this->amount);
}
}

Observer

Define una dependencia uno-a-muchos. Cuando un objeto cambia de estado, notifica automáticamente a todos sus observadores. En Laravel se implementa de forma nativa con Events + Listeners / Observers.

Command

Encapsula una petición como un objeto. Ideal para colas, deshacer/rehacer, o desacoplar el emisor del receptor (muy usado en CQRS y jobs de cola).

State

Permite que un objeto cambie su comportamiento cuando cambia su estado interno (máquinas de estados: pedidos, suscripciones, flujos de aprobación…).

Patrones especialmente útiles en arquitecturas web modernas

  • Repository: abstrae el acceso a datos. El dominio no conoce si usas Eloquent, Doctrine o una API externa.
  • DTO (Data Transfer Object): objetos inmutables para mover datos entre capas sin exponer entidades de dominio.
  • Service Layer / Application Services: orquestan casos de uso.
  • Pipeline / Middleware: cadena de responsabilidades (muy natural en HTTP).
  • Specification: encapsula reglas de negocio complejas y reutilizables.

Cuándo usar y cuándo no usar patrones

Cuando usarlos

  • El problema se repite o es probable que evolucione.
  • Necesitas desacoplar capas (especialmente en arquitecturas hexagonales o DDD).
  • Quieres facilitar el testing y la extensión.

Cuando no usarlos

  • El código es simple y no va a crecer (sobreingeniería).
  • El patrón añade más complejidad de la que elimina.
  • Estás “forzando” un patrón solo porque lo conoces.

Regla de oro: primero resuelve el problema de la forma más simple. Introduce el patrón cuando sientas el dolor de la rigidez o la duplicación.

Relación con principios SOLID y frameworks modernos

Los patrones de diseño son la materialización práctica de los principios SOLID. Frameworks como Laravel y Symfony ya implementan internamente muchos de ellos (Service Container = Factory + Singleton controlado, Events = Observer, Middleware = Chain of Responsibility, Form Requests, etc.).

Conocer los patrones te permite:

  • Entender mejor cómo funcionan los frameworks por dentro.
  • Extenderlos correctamente.
  • Diseñar aplicaciones desacopladas que no dependan del framework (arquitectura hexagonal / ports & adapters).

Conclusión

Los patrones de diseño no son un fin en sí mismos, sino herramientas de comunicación y de diseño. Un buen desarrollador web no memoriza 23 patrones, sino que reconoce situaciones y sabe aplicar la solución más adecuada con el menor coste de complejidad posible.

Empieza dominando bien estos: Factory, Strategy, Decorator, Adapter, Observer, Repository y Command. Con ellos resolverás la gran mayoría de los problemas de diseño que encontrarás en aplicaciones web reales.