Angular లో సేవలు (services) మరియు dependency injection అంటే ఏమిటి?

Question

Accepted Answer

**సేవ** అనేది **UI కాని లాజిక్** కోసం ఒక తరగతి — ડేటా ఫెచింగ్, వ్యాపార నియమాలు, భాగస్వామ్య స్థితి, లాగింగ్ — ఇది కాంపోనెంట్‌లు తిరిగి ఉపయోగించవచ్చు. **Dependency Injection (DI)** అనేది Angular ఆ సేవలను వాటిని అవసరమైన కాంపోనెంట్‌లకు *సరఫరా* చేసే విధానం, కాంపోనెంట్‌లు వాటిని ఆన్‌లీ విధంగా సృష్టించడానికి బదులుగా.

## సేవ నిర్వచించడం

```ts
import { Injectable } from "@angular/core";

@Injectable({ providedIn: "root" }) // makes it a singleton available app-wide
export class UserService {
  private users = [];
  getUsers() { return this.users; }
  addUser(u) { this.users.push(u); }
}
```

`@Injectable({ providedIn: "root" })` డెకోరేటర్ సేవను Angular DI సిస్టమ్‌కు సంపూర్ణ యాప్‌కు సింగిల్ షేర్‌డ్ ఇన్‌స్టెన్స్ (singleton) గా నమోదు చేస్తుంది.

## దీనిని కాంపోనెంట్‌లోకి ఇంజెక్ట్ చేయడం

```ts
@Component({ ... })
export class UserListComponent {
  // Angular sees this constructor param and INJECTS the singleton automatically
  constructor(private userService: UserService) {}

users = this.userService.getUsers(); // just use it
}
```

మీరు సేవను కన్‌స్ట్రక్టర్ పారామీటర్ గా ప్రకటించండి; Angular DI **ఇన్‌స్టెన్స్ సృష్టించి సరఫరా** చేస్తుంది. మీరు `new UserService()` ఎప్పుడూ రాయరు. (ఆధునిక Angular కూడా కన్‌స్ట్రక్టర్ ఇంజెక్షన్‌కు బదులుగా `inject()` ఫంక్షన్‌ను ఉపయోగించగలదు.)

```ts
import { inject } from "@angular/core";
export class UserListComponent {
  private userService = inject(UserService); // alternative injection style
}
```

## DI ఎందుకు విలువైనది

```text
✓ Single source of truth — one shared UserService instance across components
✓ Loose coupling — components depend on the type, not on constructing it
✓ Testability — swap in a mock service in tests easily
✓ Lifecycle management — Angular handles creation and sharing
```

కాంపోనెంట్ దాని డిపెండెన్సీలను నిర్మించనందున, మీరు టెస్ట్‌లలో **నకిలీ** సేవను ఇంజెక్ట్ చేయవచ్చు, లేదా అనువర్తనం-విస్తృత ఒక సరిదిద్దుకోవడం ఒక చోటిలో మార్చవచ్చు.

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

సేవలు + DI Angular ఆర్కిటెక్చర్‌కు కేంద్రీయ: కాంపోనెంట్‌లు UI పై దృష్టి సేపుకుంటూ ఉంటాయి సేవలు లాజిక్ మరియు స్థితిని పట్టుకుంటాయి, మరియు DI వాటిని కనీస సంకర్షణతో ఏకీకృత చేస్తుంది.

ఈ విభజన (మరియు అది తీసుకువచ్చే పరీక్ష సామర్థ్యం) Angular యొక్క నిర్వచించే బలాలలో ఒకటి — బ్యాకెండ్ ఫ్రేమ్‌వర్క్‌ల నుండి ఎత్తుకుని — మరియు `@Injectable({ providedIn: 'root' })` ఒక భాగస్వామ్య, ఇంజెక్టబుల్ singleton కోసం రోజువారీ నమూనా.