Dependency injection ทำงานอย่างไรใน PHP สมัยใหม่?

Question

Accepted Answer

**Dependency Injection (DI)** คือดีไซน์แพตเทิร์นที่คลาสรับ dependency ของมันมาจากภายนอก (โดยทั่วไปผ่าน constructor) แทนที่จะสร้างขึ้นเอง เฟรมเวิร์ก PHP สมัยใหม่ใช้ DI อย่างหนัก มักร่วมกับ **container** ที่แก้ไขและฉีด (inject) dependency ให้โดยอัตโนมัติ นำไปสู่โค้ดที่ผูกกันหลวม ๆ (loosely-coupled) และทดสอบได้

## ปัญหาที่ 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
}
```

การฉีด dependency (อิงกับ **interface**) แยกคลาสออกจากการ implement แบบเฉพาะเจาะจง คุณสามารถสลับการ implement และฉีด mock เข้ามาในการทดสอบได้

## Constructor injection (รูปแบบมาตรฐาน)

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

Constructor injection ทำให้ dependency ชัดเจน และรับประกันว่าอ็อบเจกต์ถูกสร้างขึ้นมาอย่างสมบูรณ์เมื่อถูกสร้าง

## DI container — การแก้ไขอัตโนมัติ

```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** (ใน Laravel, Symfony หรือแบบ standalone อย่าง PHP-DI) สร้างอ็อบเจกต์โดยอัตโนมัติด้วยการแก้ไข dependency ของ constructor แบบเรียกซ้ำ (recursive) คุณกำหนดการ binding ระหว่าง interface กับ implementation แล้ว container จะเชื่อมโยงทุกอย่างเข้าด้วยกัน

## ประโยชน์

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

## ทำไมจึงสำคัญ

Dependency injection เป็นแพตเทิร์นพื้นฐานใน PHP สมัยใหม่ และเป็นหัวใจของโครงสร้างแอปพลิเคชันและเฟรมเวิร์กระดับมืออาชีพ (Laravel, Symfony) การเข้าใจมันจึงเป็นความรู้ระดับ senior ที่สำคัญ

คุณค่าหลักคือ **การลดการผูกติดและความสามารถในการทดสอบ**: ด้วยการให้คลาสรับ dependency ของมัน (ที่ประกาศอิงกับ interface) แทนการสร้างเอง โค้ดจึงผูกกันหลวม ๆ (อิงกับ abstraction ไม่ใช่ implementation แบบเฉพาะเจาะจง), **ทดสอบได้ง่าย** (คุณฉีด mock แทนฐานข้อมูล/บริการจริง ทำให้การทำ unit test ที่ครอบคลุมเป็นไปได้ในทางปฏิบัติ) และมีความยืดหยุ่น (สลับ implementation ผ่านการตั้งค่า)

เฟรมเวิร์ก PHP สมัยใหม่มี **DI container** ที่ทำสิ่งนี้โดยอัตโนมัติ คือแก้ไขและฉีด dependency graph ทั้งหมดให้โดยอัตโนมัติตามการ binding ระหว่าง interface กับ implementation คุณจึงไม่ต้องสร้างอ็อบเจกต์ด้วยตัวเอง

การเข้าใจ constructor injection (รูปแบบมาตรฐาน), การเขียนโปรแกรมอิงกับ interface และวิธีที่ DI container ทำงาน (การแก้ไขอัตโนมัติ) เป็นสิ่งจำเป็นต่อการทำงานกับเฟรมเวิร์ก PHP อย่างมีประสิทธิภาพ (ซึ่งสร้างขึ้นรอบ ๆ DI) และต่อการเขียนโค้ดที่ออกแบบมาดี บำรุงรักษาได้ และทดสอบได้

เนื่องจาก DI เป็นรากฐานของโครงสร้างเฟรมเวิร์ก PHP สมัยใหม่หลัก ๆ ทุกตัว และเป็นเอกลักษณ์ของการออกแบบแอปพลิเคชันระดับมืออาชีพ การเชี่ยวชาญมัน ทั้งแพตเทิร์น ประโยชน์ และการแก้ไขแบบ container เป็นความรู้สำคัญที่แยกแยะนักพัฒนาที่สามารถสร้าง PHP ที่สะอาด ทดสอบได้ และเป็นไปตามแบบฉบับของเฟรมเวิร์ก ออกจากผู้ที่เขียนโค้ดที่ผูกติดกันแน่นและทดสอบได้ยาก