Bagaimanakah dependency injection berfungsi dalam PHP moden?

Question

Accepted Answer

**Dependency Injection (DI)** ialah corak reka bentuk di mana sesuatu kelas menerima dependency-nya dari luar (biasanya melalui konstruktor) dan bukannya menciptanya sendiri. Framework PHP moden menggunakan DI secara meluas, selalunya dengan **container** yang secara automatik meleraikan dan menyuntik dependency — membawa kepada kod yang longgar-gandingan dan boleh diuji.

## Masalah yang diselesaikan DI

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

Menyuntik dependency (terhadap suatu **interface**) menanggalkan gandingan kelas daripada pelaksanaan konkrit — anda boleh menukar pelaksanaan dan menyuntik mock dalam ujian.

## Constructor injection (bentuk standard)

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

Constructor injection menjadikan dependency eksplisit dan memastikan objek terbentuk sepenuhnya apabila dicipta.

## DI container — leraian automatik

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

**DI container** (dalam Laravel, Symfony, atau yang berdiri sendiri seperti PHP-DI) secara automatik membina objek dengan meleraikan dependency konstruktornya secara rekursif — anda mengkonfigurasi pengikatan interface-ke-pelaksanaan, dan container menyambungkan segala-galanya.

## Manfaat

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

Dependency injection ialah corak asas dalam PHP moden, inti kepada cara aplikasi profesional dan framework (Laravel, Symfony) distrukturkan, jadi memahaminya ialah pengetahuan peringkat senior yang penting.

Nilai terasnya ialah **penanggalan gandingan dan kebolehujian**: dengan membuatkan kelas menerima dependency-nya (diisytiharkan terhadap interface) dan bukannya menciptanya, kod menjadi longgar-gandingan (bergantung pada abstraksi, bukan pelaksanaan konkrit), mudah **diuji** (anda menyuntik mock dan bukannya pangkalan data/perkhidmatan sebenar — menjadikan ujian unit yang menyeluruh praktikal), dan fleksibel (menukar pelaksanaan melalui konfigurasi).

Framework PHP moden menyediakan **DI container** yang mengautomasikan ini — meleraikan dan menyuntik keseluruhan graf dependency secara automatik berdasarkan pengikatan interface-ke-pelaksanaan, jadi anda tidak perlu membina objek secara manual.

Memahami constructor injection (bentuk standard), programming terhadap interface, dan cara DI container berfungsi (leraian automatik) adalah penting untuk bekerja dengan berkesan dengan framework PHP (yang dibina di sekitar DI) dan untuk menulis kod yang berseni bina baik, boleh diselenggara, dan boleh diuji.

Memandangkan DI menyokong struktur semua framework PHP moden utama dan ialah ciri khas reka bentuk aplikasi profesional, menguasainya — corak, manfaatnya, dan leraian berasaskan container — ialah pengetahuan penting yang membezakan pembangun yang boleh membina PHP yang bersih, boleh diuji, dan idiomatik-framework daripada mereka yang menulis kod yang ketat-gandingan dan sukar diuji.