Jaké návrhové vzory jsou běžné v PHP frameworcích?

Question

Accepted Answer

PHP frameworky (Laravel, Symfony) jsou postaveny na klasických **návrhových vzorech** — znovupoužitelných řešeních běžných problémů návrhu. Rozpoznávání těchto vzorů vám pomáhá pochopit, jak frameworky fungují, a psát lépe strukturovaný kód.

## MVC (Model-View-Controller) — architektonický základ

```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 — abstrakce přístupu k datům

```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
```

**Repository** pattern abstrahuje přístup k datům za rozhraním — odděluje obchodní logiku od databáze a zlepšuje testovatelnost.

## Factory — zapouzdření vytváření objektů

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

## Další běžné vzory v PHP frameworcích

```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 obzvláště předvádí tyto vzory: **Facades** (statické proxy ke službám), **Active Record** (Eloquent modely), **Observer** (eventy/observer modely), **Strategy** (vyměnitelné ovladače pro cache, queue, auth).

## Proč je to důležité

Návrhové vzory jsou důležité znalosti pro PHP vývojáře, protože hlavní frameworky (Laravel, Symfony) jsou na nich zcela postaveny — takže pochopení vzorů je nezbytné jak pro porozumění *tomu, jak tyto frameworky fungují*, tak pro psaní dobře strukturovaného kódu.

Rozeznávání **MVC** (architektonický základ téměř každého PHP webového frameworku), **Dependency Injection / IoC containers** (jak frameworky propojují závislosti pro oddělení a testovatelnost), **Repository pattern** (abstrakce přístupu k datům pro testovatelné, vyměnitelné perzistence) a frameworkově specifických vzorů jako Laravel **Facades** (statické proxy ke službám), **Active Record** (Eloquent modely) a **Observer** (eventy) demystifikuje "kouzlo" těchto frameworků a umožňuje vám je efektivně používat a rozšiřovat.

Beyond pouhého porozumění frameworkům vám znalost běžných vzorů dává sdílenou slovní zásobu pro diskuse o návrhu, osvědčená řešení se opakujícími se problémy a schopnost architektovat udržovatelný, flexibilní kód.

Protože profesionální PHP vývoj téměř vždy probíhá v rámci frameworků plných vzorů a protože dobrý návrh aplikace se spoléhá na vhodné použití vzorů, porozumění běžným návrhových vzorům — co řeší a kde se objevují v PHP ekosystému — je cenná znalost na senior úrovni, která rozlišuje vývojáře, kteří hluboko rozumí svým nástrojům a mohou postavit dobře strukturované aplikace, od těch, kteří frameworky používají povrchně. (Upozornění, jako vždy: vzory jsou nástroje na reálné problémy, ne cíle — jejich aplikace tam, kde nejsou potřebné, přidává zbytečnou složitost.)