Kaip veikia priklausomybės injekcija NestJS?

Question

Accepted Answer

**Dependency Injection (DI)** yra pagrindinė NestJS šablono, kur sistema **automatiškai sukuria ir pateikia** klasei reikalingos priklausomybės, o ne pati klasė jas konstruoja. Jūs deklaruojate, ko reikia konstruktoriuje, o NestJS jį tiekia — vedant į silpnai susietą, testiuojamą kodą.

## Kaip tai veikia: deklaruoti konstruktoriuje

```ts
@Injectable()
export class UsersService {
  // declare dependencies as constructor parameters — Nest injects them
  constructor(
    private readonly db: DatabaseService,
    private readonly logger: LoggerService,
  ) {}
  // you NEVER write `new DatabaseService()` — Nest creates and provides it
}
```

Nest nuskaito konstruktoriaus parametrų tipus, ieško atitinkamų registruotų tiekėjų, juos sukuria (jei dar nėra) ir juos praeina — automatiškai išsprendžia visą priklausomybės grafiką.

## DI srautas

```text
1. A class is marked @Injectable() → it's a provider
2. The provider is registered in a module's `providers` array
3. Another class declares it as a constructor parameter
4. NestJS's IoC container resolves and INJECTS the instance automatically
```

## Registracija ir sprendimas

```ts
@Module({
  providers: [UsersService, DatabaseService, LoggerService],  // register all providers
  controllers: [UsersController],
})
export class UsersModule {}
// Nest's container now knows how to construct each and inject them where needed
```

## Kodėl DI yra vertinga

```text
✓ Loose coupling — classes depend on ABSTRACTIONS, not on constructing concrete deps
✓ Testability — inject MOCK dependencies in tests easily (no real DB needed)
✓ Reusability — one shared instance (singleton) used across the app
✓ Maintainability — change an implementation in one place (the module registration)
```

## Testiuojamumas — svarbiausias pranašumas

```ts
// in a test, provide a fake DatabaseService — no real database required
const module = await Test.createTestingModule({
  providers: [
    UsersService,
    { provide: DatabaseService, useValue: mockDatabase },  // inject a mock
  ],
}).compile();
```

Kadangi klasė nesukonstruoja savo priklausomybių, galite greitai pakeisti modelius bandymams — DI daro NestJS programas itin testuojamas.

## Neklasės verčių injekcija

```ts
// use injection tokens for config/values, not just classes
constructor(@Inject("CONFIG") private config: AppConfig) {}
```

## Kodėl tai svarbu

Proklausomybės injekcija yra pagrindinė šablono, kurią remia visa NestJS architektūra — tai yra tai, kaip kontroleriai gauna paslaugas, paslaugos gauna saugyklas ir kitas paslaugas, ir visa programa yra sujungta.

Suprasti tai yra svarbu, nes beveik kiekviena NestJS klasė dalyvauja DI: jūs deklaruojate priklausomybes konstruktoriuje, o sistemos IoC konteineris jas automatiškai išsprendžia ir tiekia, pašalinant rankinį sukūrimą ir stiprų ryšį.

Pranašumai yra reikšmingi ir svarbūs NestJS vertei: **silpnas ryšys** (priklausau nuo abstrakcij), **testiuojamumas** (injekcija modeliai, o ne tikros priklausomybės — padaro išsamius moduliniais bandymais lengvais), pakartotinis naudojimas (bendrinamos vienetinės), ir priežiūrą.

DI pasiskolinta iš sistemų, tokių kaip Angular ir Spring, ir jį išmokti — kaip deklaruoti, registruoti, injekcija ir modeliuoti priklausomybes — reikalinga kurti gerai sustruktūrintas, testuojamas NestJS programas ir yra viena iš svarbiausių sąvokų, kurią reikia giliai suprasti sistemoje.