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.