Dependency injection modern PHP'de nasıl çalışır?

Question

Accepted Answer

**Dependency Injection (DI)**, bir sınıfın bağımlılıklarını kendisi oluşturmak yerine dışarıdan (tipik olarak constructor aracılığıyla) alması tasarım desenidir. Modern PHP framework'leri DI'ı yoğun şekilde kullanırlar, çoğunlukla bağımlılıkları otomatik olarak çözen ve enjekte eden bir **container** ile — bu da gevşek bağlantılı, test edilebilir kod ile sonuçlanır.

## DI'ın çözdüğü sorun

```php
// ❌ tight coupling — the class CREATES its own dependencies (hard to test/swap)
class UserService {
    private $mailer;
    public function __construct() {
        $this->mailer = new SmtpMailer();   // hardcoded → can't mock, can't swap
    }
}

// ✅ dependency injection — dependencies are PASSED IN
class UserService {
    public function __construct(private MailerInterface $mailer) {}
    // depends on an INTERFACE, receives the concrete impl from outside
}
```

Bağımlılıkları enjekte etmek (**interface**'e karşı) sınıfı somut uygulamalardan ayırır — uygulamaları değiştirebilir ve test'lerde mock'ları enjekte edebilirsiniz.

## Constructor injection (standart form)

```php
class OrderService {
    public function __construct(
        private OrderRepository $repo,        // dependencies declared in the constructor
        private MailerInterface $mailer,
        private LoggerInterface $logger,
    ) {}
}
```

Constructor injection bağımlılıkları açık kılar ve nesne oluşturulduğunda tamamen oluşturulmuş olmasını sağlar.

## DI container'ları — otomatik çözüm

```php
// a DI CONTAINER builds objects, resolving the whole dependency graph automatically
$container->bind(MailerInterface::class, SmtpMailer::class);   // map interface → impl

$service = $container->get(OrderService::class);
// the container sees OrderService needs OrderRepository, MailerInterface, LoggerInterface,
// constructs each (recursively), and injects them — you don't `new` anything manually
```

Bir **DI container** (Laravel, Symfony'de veya PHP-DI gibi bağımsız bir container'da) constructor bağımlılıklarını özyinelemeli olarak çözerek nesneleri otomatik olarak oluşturur — interface-to-implementation bağlamalarını konfigüre edersiniz ve container her şeyi birbirine bağlar.

## Yararları

```text
✓ Loose coupling — depend on interfaces/abstractions, not concrete classes
✓ Testability — inject mocks/fakes in tests (no real DB/mailer needed)
✓ Flexibility — swap implementations via container config (e.g. fake mailer in dev)
✓ Single responsibility — classes focus on logic, not constructing dependencies
```

## Neden önemli

Dependency injection, modern PHP'de temel bir desendir, profesyonel uygulamaların ve framework'lerin (Laravel, Symfony) yapısının merkezindedir, bu nedenle bunu anlamak önemli senior seviyesi bilgisidir.

Temel değer **decoupling ve test edilebilirlik**'dir: sınıflar bağımlılıklarını oluşturmak yerine alarak (interface'lere karşı bildirilmiş), kod gevşek bağlantılı olur (somut uygulamalara değil, abstraksiyonlara bağlı), kolayca **test edilebilir** hale gelir (gerçek veritabanları/servisler yerine mock'ları enjekte edersiniz — kapsamlı birim test'leri pratik kılar) ve esnek olur (konfigürasyon aracılığıyla uygulamaları değiştirebilirsiniz).

Modern PHP framework'leri bunu otomatize eden **DI container'ları** sağlarlar — interface-to-implementation bağlamalarına göre tüm bağımlılık grafiğini otomatik olarak çözer ve enjekte ederler, böylece nesneleri manuel olarak oluşturmanız gerekmez.

Constructor injection'ı (standart form), interface'lere karşı programlamayı ve DI container'ların nasıl çalıştığını (otomatik çözüm) anlamak, PHP framework'leri ile etkili şekilde çalışmak (bunlar DI etrafında inşa edilmiştir) ve iyi mimarlanmış, bakım yapılabilir, test edilebilir kod yazmak için gereklidir.

DI tüm büyük modern PHP framework'lerinin yapısını temel aldığından ve profesyonel uygulama tasarımının bir işareti olduğundan, onu ustalığından — deseni, faydalarını ve container tabanlı çözümünü — önemli bilgidir ve temiz, test edilebilir, framework uyumlu PHP yazabilen geliştiricileri, sıkı bağlantılı, test edilmesi zor kod yazan geliştiricilerden ayırt eder.