Ce sunt serviciile și injecția de dependență în Angular?

Question

Accepted Answer

Un **service** este o clasă pentru **logică non-UI** — extragere de date, reguli de afaceri, stare partajată, logging — pe care componente le pot reutiliza. **Dependency Injection (DI)** este modul în care Angular *furnizează* aceste servicii componentelor care le au nevoie, în loc ca componentele să le creeze manual.

## Defining a service

```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); }
}
```

Decoratorul `@Injectable({ providedIn: "root" })` înregistrează serviciul cu sistemul DI al Angular ca o singură instanță partajată (singleton) pentru întreaga aplicație.

## Injecting it into a component

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

Declari pur și simplu serviciul ca parametru al constructorului; DI Angular **creează și furnizează** instanța. Nu scrii niciodată `new UserService()`. (Angular modern poate folosi și funcția `inject()` în loc de injecție prin constructor.)

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

## Why DI is valuable

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

Deoarece componenta nu construiește dependențele sale, poți injecta un serviciu **fals** în teste, sau poți schimba implementarea pe toată aplicația într-un singur loc.

## De ce conteaza

Servicios + DI sunt centrale în arhitectura Angular: componente rămân focusate pe UI în timp ce serviciile conțin logică și stare, iar DI le conectează cu cuplare minimă.

Această separare (și testabilitatea pe care o aduce) este una dintre punctele forte definitorii ale Angular — împrumutată din framework-urile backend — și `@Injectable({ providedIn: 'root' })` este modelul zilnic pentru un singleton partajat și injectabil.