ప్రొవైడర్లు మరియు సర్వీసులు అంటే ఏమిటి?

Question

Accepted Answer

NestJS లో, **ప్రొవైడర్** అనేది డిపెండెన్సీ గా ఇంజెక్ట్ చేయగల ఏదైనా క్లాస్, మరియు **సర్వీస్** అనేది అత్యంత సాధారణ రకం — **బిజనెస్ లాజిక్** ను కలిగి ఉన్న క్లాస్. `@Injectable()` డెకోరేటర్ తో క్లాస్ ను మార్క్ చేయడం వలన అది NestJS యొక్క DI సిస్టమ్ ద్వారా సృష్టించబడి ఇంజెక్ట్ చేయగల ప్రొవైడర్ అవుతుంది.

## సర్వీస్ ని నిర్వచించడం (అత్యంత సాధారణ ప్రొవైడర్)

```ts
import { Injectable } from "@nestjs/common";

@Injectable()              // marks the class as a provider (injectable)
export class UsersService {
  private users = [];

findAll() { return this.users; }                  // business logic
  findOne(id: string) { return this.users.find(u => u.id === id); }
  create(data) { this.users.push(data); return data; }
}
```

`@Injectable()` డెకోరేటర్ NestJSకి ఈ క్లాస్ డిపెండెన్సీ ఇంజెక్షన్ లో పాల్గొనుతుందని చెప్పుతుంది — ఇది కంట్రోలర్లు లేదా ఇతర ప్రొవైడర్లలోకి ఇంజెక్ట్ చేయబడుతుంది.

## కన్‌స్ట్రక్టర్ ద్వారా సర్వీస్ ను ఇంజెక్ట్ చేయడం

```ts
@Controller("users")
export class UsersController {
  // NestJS sees this parameter and INJECTS a UsersService instance automatically
  constructor(private usersService: UsersService) {}

@Get()
  findAll() {
    return this.usersService.findAll();   // use the injected service
  }
}
```

యоड అడిపెండెన్సీ ను కన్‌స్ట్రక్టర్ పారామీటర్ గా డిక్లేర్ చేసుకుంటారు; NestJS ఇన్‌స్టెన్‌స్ ను సృష్టించి సరఫరా చేస్తుంది — మీరు ఎప్పుడూ `new UsersService()` రాయవలసిన లేదు.

## మాడ్యూల్ లో ప్రొవైడర్లను రిజిస్టర్ చేయడం

```ts
@Module({
  controllers: [UsersController],
  providers: [UsersService],        // register the provider so DI can resolve it
  exports: [UsersService],          // make it available to OTHER modules that import this one
})
export class UsersModule {}
```

DI వారి గురించి తెలుసుకోవడానికి ప్రొవైడర్లను మాడ్యూల్ యొక్క `providers` అర్రేలో రిజిస్టర్ చేయవలసి ఉంటుంది, మరియు `exports` వాటిని ఇతర మాడ్యూల్లకు భాగస్వామ్యం చేస్తుంది.

## ప్రొవైడర్లు డిఫాల్ట్‌గా సింగిల్‌టన్‌లు

```text
By default, NestJS creates ONE shared instance of each provider (singleton scope)
for the whole application → efficient, shared state.
(Other scopes exist: REQUEST-scoped, TRANSIENT — but singleton is the default.)
```

## కంట్రోలర్లు నుండి సర్వీసులను ఎందుకు విడిగా ఉంచాలి?

```text
Controller → handles HTTP (routing, request/response)
Service    → handles business logic (rules, data access, computations)
→ Separation makes logic REUSABLE (multiple controllers can use one service),
  TESTABLE (test the service in isolation), and ORGANIZED.
```

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

ప్రొవైడర్లు మరియు సర్వీసులు NestJS యొక్క ఆర్కిటెక్చర్ మరియు దాని డిపెండెన్సీ-ఇంజెక్షన్-ఆధారిత డిజైన్ కు ప్రధానమైనవి.

సర్వీసులు అప్లికేషన్ యొక్క **బిజనెస్ లాజిక్** ను కలిగి ఉంటాయి, కంట్రోలర్ల నుండి (ఇవి HTTP సమస్యలను మాత్రమే నిర్వహిస్తాయి) విడిగా ఉంచబడతాయి — ఈ శ్రమ యొక్క విభజన లాజిక్ ను కంట్రోలర్ల నుండి పునర్వినియోగం చేయదగినదిగా, ఐసోలేషన్‌లో సులభంగా పరీక్షించదగినదిగా, మరియు బాగా-సంస్థాపితమైనదిగా చేస్తుంది.

`@Injectable()` క్లాస్ ను ఇంజెక్టబుల్ ప్రొవైడర్‌గా మార్క్ చేస్తుందని, ప్రొవైడర్లు మాడ్యూల్‌లలో రిజిస్టర్ చేయబడి కన్‌స్ట్రక్టర్ల ద్వారా ఇంజెక్ట్ చేయబడతాయని (DI ఇన్‌స్టెన్‌సులను సృష్టిస్తుంది), మరియు అవి డిఫాల్ట్‌గా సింగిల్‌టన్‌లు అని అర్థం చేసుకోవడం ప్రతిదిన NestJS జ్ఞానానికి ప్రాథమికమైనది.

కంట్రోలర్లు మరియు మాడ్యూల్‌లతో కలిపి ప్రొవైడర్/సర్వీస్ నమూనా ప్రతి NestJS అప్లికేషన్ యొక్క వెన్నెముక — దానిని నైపుణ్యం కలిగి ఉండటం బాగా-నిర్మితమైన, నిర్వహణీయమైన బ్యాక్‌ఎండ్‌లను నిర్మించడానికి ఎవరికీ అవసరం మరియు ఫ్రేమ్‌వర్క్‌లో నేర్చుకోవలసిన మొదటి కాన్సెప్టుల్లో ఉంది.