డిపెండెన్సీ ఇంజెక్షన్ మరియు ఇన్వర్జన్ ఆఫ్ కంట్రోల్ అంటే ఏమిటి?

Question

Accepted Answer

**డిపెండెన్సీ ఇంజెక్షన్ (DI)** అంటే ఒక ఆబ్జెక్ట్ తన ఆధారపడటాలను తనలో నుండి సృష్టించుకోవడానికి బదులుగా బాహ్యం నుండి పొందుకోవడం. ఇది **ఇన్వర్జన్ ఆఫ్ కంట్రోల్ (IoC)** యొక్క ఒక రూపం: ఆబ్జెక్టులను వైర్ చేసే బాధ్యత ఆబ్జెక్ట్ నుండి *విలోమ* చేయబడి కాలర్ లేదా కంటైనర్‌కు ఇవ్వబడుతుంది.

## DI లేకుండా vs. DI తో

```python
# WITHOUT DI — the class controls its own dependencies (tight coupling)
class OrderService:
    def __init__(self):
        self.repo = PostgresOrderRepo()   # hard-wired; can't swap or test

# WITH DI — dependencies are passed in (loose coupling)
class OrderService:
    def __init__(self, repo: OrderRepo):  # any OrderRepo implementation
        self.repo = repo

# wiring happens outside:
service = OrderService(PostgresOrderRepo())   # prod
test    = OrderService(InMemoryOrderRepo())   # test — no DB needed
```

క్లాస్ ఇప్పుడు *నైరూప్యత* `OrderRepo` పై ఆధారపడి ఉంది, మరియు మరొకరు ఏ ఠోస్ సరఫరా చేయాలో నిర్ణయిస్తారు.

## ఇంజెక్షన్ రూపాలు

| రూపం | ఎలా |
|---|---|
| కన్‌స్ట్రక్టర్ | కన్‌స్ట్రక్టర్‌కు పాస్ చేయబడినది (సముచితమైనది - అవసరమైన ఆధారపడటాలు స్పష్టమైనవి) |
| Setter | నిర్మాణం తర్వాత ఒక పద్ధతి ద్వారా సెట్ చేయబడినది (ఐచ్ఛిక ఆధారపడటాలు) |
| ఇంటర్‌ఫేస్/కంటైనర్ | ఒక ఫ్రేమ్‌వర్క్ పరిష్కరిస్తుంది మరియు ఇంజెక్ట్ చేస్తుంది (Spring, .NET DI) |

## ట్రేడ్-ఆఫ్‌లు

```text
✓ Testable (inject fakes/mocks)   ✓ Swappable implementations
✓ Explicit dependencies            ⚠️ More wiring; indirection can obscure flow
⚠️ DI containers add "magic" → harder to trace what's wired where
```

## ఇది ఎందుకు ముఖ్యమైనది

DI అనేది డిపెండెన్సీ ఇన్‌వర్జన్ సూత్రం యొక్క ఆచరణాత్మక సాకారం - అధిక-స్థాయి తర్కం కాంక్రీట్, నిమ్న-స్థాయి తరగతులపై ఆధారపడటం ఆపివేస్తుంది.

ప్రయోజనం పరీక్ష యోగ్యత మరియు సరళత: మీరు పరీక్షలలో నకిలీ డేటాబేస్‌ను భర్తీ చేయవచ్చు లేదా ఉత్పత్తిలో చెల్లింపు ప్రదాతను సరఫరా చేయడం ఐచ్ఛికం, వ్యాపార తర్కం కాకుండా వైర్ చేయడం ద్వారా మార్చవచ్చు.

రూపం	ఎలా
కన్‌స్ట్రక్టర్	కన్‌స్ట్రక్టర్‌కు పాస్ చేయబడినది (సముచితమైనది - అవసరమైన ఆధారపడటాలు స్పష్టమైనవి)
Setter	నిర్మాణం తర్వాత ఒక పద్ధతి ద్వారా సెట్ చేయబడినది (ఐచ్ఛిక ఆధారపడటాలు)
ఇంటర్‌ఫేస్/కంటైనర్	ఒక ఫ్రేమ్‌వర్క్ పరిష్కరిస్తుంది మరియు ఇంజెక్ట్ చేస్తుంది (Spring, .NET DI)