आधुनिक PHP मा dependency injection कसरी काम गर्छ?

Question

Accepted Answer

**Dependency Injection (DI)** एक डिजाइन प्याटर्न हो जहाँ एक class लाई यसको dependencies बाहिरबाट (सामान्यतः constructor मार्फत) प्राप्त हुन्छ, तर यो आफैले सिर्जना गर्दैन। आधुनिक PHP frameworks ले DI लाई व्यापक रूपमा प्रयोग गर्छन्, प्रायः एक **container** सहित जो स्वचालित रूपमा dependencies को समाधान र इन्जेक्शन गर्छ — जससे loosely-coupled, testable code को नेतृत्व हुन्छ।

## समस्या जो 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
}
```

Dependencies इन्जेक्ट गर्दा (एक **interface** विरुद्ध) class लाई concrete implementations बाट अलग गर्छ — तपाईले implementations स्वप् गर्न सक्नु हुन्छ र tests मा mocks इन्जेक्ट गर्न सक्नु हुन्छ।

## Constructor injection (मानक फारम)

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

Constructor injection ले dependencies लाई स्पष्ट बनाउँछ र सुनिश्चित गर्छ कि object सृजना हुँदा पूर्ण रूप बनिएको छ।

## DI containers — स्वचालित समाधान

```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 मा) स्वचालित रूपमा आफ्नो constructor dependencies लाई पुनरावर्ती रूपमा समाधान गरेर objects निर्माण गर्छ — तपाईले interface-to-implementation bindings कन्फिगर गर्नु हुन्छ, र 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 मा एक मौलिक प्याटर्न हो, पेशाদार applications र frameworks (Laravel, Symfony) को संरचनाको केन्द्रबिन्दु हो, त्यसैले यो समझ्नु वरिष्ठ-स्तरको ज्ञान हो।

मूल मूल्य **decoupling र testability** हो: classes लाई आफ्नो dependencies प्राप्त गरेर (interfaces को विरुद्ध घोषणा गरेर) तर सिर्जना गर्न नसकेर, code loosely coupled हुन्छ (abstractions मा निर्भर छ, concrete implementations मा होइन), सजिलै **testable** छ (तपाईले वास्तविक databases/services को सट्टा mocks इन्जेक्ट गर्नु हुन्छ — thorough unit testing लाई व्यावहारिक बनाउँदै), र लचकदार छ (configuration मार्फत implementations स्वप् गर्न)।

आधुनिक PHP frameworks ले **DI containers** प्रदान गर्छन् जो यो स्वचालित गर्छन् — सम्पूर्ण dependency graph लाई स्वचालित रूपमा समाधान र इन्जेक्ट गर्दै interface-to-implementation bindings को आधारमा, त्यसैले तपाईले manually objects निर्माण गर्न हुँदैन।

Constructor injection (मानक फारम) को समझ, interfaces विरुद्ध programming, र DI containers कसरी काम गर्छ (स्वचालित समाधान) PHP frameworks सहित प्रभावकारी रूपमा काम गर्न आवश्यक छ (जो DI को वरिपरि निर्मित छ) र well-architected, maintainable, testable code लेखनको लागि।

DI को कारणले सबै प्रमुख आधुनिक PHP frameworks को संरचना अधीनमा छ र पेशाদार application design को एक विशेषता हो, यसलाई महारत हासिल गर्नु — प्याटर्न, यसको लाभहरू, र container-based resolution — महत्त्वपूर्ण ज्ञान हो जो developers लाई अलग गर्छ जो clean, testable, framework-idiomatic PHP निर्माण गर्न सक्छन् उनीहरूबाट tightly-coupled, hard-to-test code लेखन गरिरहेकाहरूलाई।