What design patterns are common in PHP frameworks?

Question

Accepted Answer

PHP frameworks (Laravel, Symfony) are built on classic **design patterns** — reusable solutions to common design problems. Recognizing them helps you understand how frameworks work and write better-structured code yourself.

## MVC (Model-View-Controller) — the architectural foundation

```text
Model      → data + business logic (e.g. Eloquent models)
View       → presentation (templates: Blade, Twig)
Controller → handles requests, coordinates models & views
→ The structural pattern of nearly every PHP web framework.
```

## Dependency Injection / IoC Container

```php
// frameworks use a container to resolve & inject dependencies (decoupling, testability)
$service = $container->get(UserService::class);   // dependencies auto-wired
```

## Repository pattern — abstract data access

```php
interface UserRepository {
    public function find(int $id): ?User;
}
class EloquentUserRepository implements UserRepository { /* DB-specific impl */ }
// services depend on the INTERFACE → swap data sources, mock in tests
```

The **Repository** pattern abstracts data access behind an interface — decoupling business logic from the database and aiding testing.

## Factory — encapsulate object creation

```php
class PaymentFactory {
    public static function create(string $type): PaymentGateway {
        return match($type) {
            'stripe' => new StripeGateway(),
            'paypal' => new PayPalGateway(),
        };
    }
}
```

## Other common patterns in PHP frameworks

```text
Singleton  → one shared instance (often via the DI container, e.g. config, DB connection)
Observer   → event/listener systems (Laravel events, model observers)
Strategy   → interchangeable algorithms (e.g. different cache/auth drivers)
Decorator  → wrap to add behavior (middleware-style request/response wrapping)
Facade     → a simple static interface to complex subsystems (Laravel Facades:
             Cache::get(), DB::table() — proxy to container-resolved services)
Adapter    → uniform interface over different implementations (e.g. filesystem drivers)
Active Record → models that wrap DB rows with query/save methods (Eloquent)
```

Laravel especially showcases these: **Facades** (static proxies to services), **Active Record** (Eloquent models), **Observer** (events/model observers), **Strategy** (swappable drivers for cache, queue, auth).

## Why it matters

Design patterns are important knowledge for PHP developers because the major frameworks (Laravel, Symfony) are built entirely on them — so understanding patterns is essential both for comprehending *how these frameworks work* and for writing well-structured code yourself.

Recognizing **MVC** (the architectural foundation of nearly every PHP web framework), **Dependency Injection / IoC containers** (how frameworks wire dependencies for decoupling and testability), the **Repository pattern** (abstracting data access for testable, swappable persistence), and framework-specific patterns like Laravel's **Facades** (static proxies to services), **Active Record** (Eloquent models), and **Observer** (events) demystifies the "magic" of these frameworks and lets you use and extend them effectively.

Beyond understanding frameworks, knowing common patterns gives you a shared vocabulary for design discussions, proven solutions to recurring problems, and the ability to architect maintainable, flexible code.

Since professional PHP development almost always happens within pattern-heavy frameworks, and since good application design relies on appropriate pattern use, understanding the common design patterns — what they solve and where they appear in the PHP ecosystem — is valuable senior-level knowledge that distinguishes developers who deeply understand their tools and can build well-architected applications from those who use frameworks superficially. (The caveat, as always: patterns are tools for real problems, not goals — applying them where they don't fit adds needless complexity.)