Bagaimana dependency injection bekerja di PHP modern?

Question

Accepted Answer

**Dependency Injection (DI)** adalah pola desain di mana sebuah kelas menerima dependensinya dari luar (biasanya melalui constructor) daripada membuatnya sendiri. Framework PHP modern menggunakan DI secara ekstensif, sering kali dengan sebuah **container** yang secara otomatis menyelesaikan dan menginjeksi dependensi — menghasilkan kode yang loosely-coupled dan testable.

## Masalah yang DI selesaikan

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

Menginjeksi dependensi (terhadap sebuah **interface**) memisahkan kelas dari implementasi konkret — Anda dapat menukar implementasi dan menginjeksi mock dalam test.

## Constructor injection (bentuk standar)

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

Constructor injection membuat dependensi eksplisit dan memastikan objek sepenuhnya terbentuk saat dibuat.

## DI containers — automatic resolution

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

Sebuah **DI container** (di Laravel, Symfony, atau standalone seperti PHP-DI) secara otomatis membangun objek dengan menyelesaikan dependensi constructor mereka secara rekursif — Anda mengonfigurasi binding interface-ke-implementasi, dan container menghubungkan semuanya bersama.

## Manfaatnya

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

## Mengapa ini penting

Dependency injection adalah pola fundamental di PHP modern, pusat dari cara aplikasi profesional dan framework (Laravel, Symfony) distruktur, jadi memahaminya adalah pengetahuan tingkat senior yang penting.

Nilai intinya adalah **decoupling dan testability**: dengan memiliki kelas menerima dependensi mereka (dideklarasikan terhadap interface) daripada membuatnya, kode menjadi loosely coupled (bergantung pada abstraksi, bukan implementasi konkret), mudah **testable** (Anda menginjeksi mock daripada database/layanan nyata — membuat unit testing yang menyeluruh praktis), dan fleksibel (menukar implementasi melalui konfigurasi).

Framework PHP modern menyediakan **DI containers** yang mengotomatisasi ini — menyelesaikan dan menginjeksi seluruh dependency graph secara otomatis berdasarkan binding interface-ke-implementasi, jadi Anda tidak perlu secara manual membangun objek.

Memahami constructor injection (bentuk standar), programming terhadap interface, dan bagaimana DI containers bekerja (automatic resolution) sangat penting untuk bekerja secara efektif dengan framework PHP (yang dibangun di sekitar DI) dan untuk menulis kode yang well-architected, maintainable, dan testable.

Karena DI adalah fondasi struktur semua framework PHP modern utama dan adalah ciri khas dari desain aplikasi profesional, menguasainya — pola, manfaatnya, dan resolusi berbasis container — adalah pengetahuan penting yang membedakan developer yang dapat membangun PHP yang clean dan testable serta idiomatic framework dari mereka yang menulis kode tightly-coupled dan sulit ditest.