Bagaimanakah penyelesaian kebergantungan berfungsi dalam NestJS?

Question

Accepted Answer

**Dependency Injection (DI)** adalah pola teras NestJS di mana kerangka kerja **secara otomatis membuat dan menyediakan** kebergantungan yang diperlukan kelas, daripada kelas itu sendiri membuatnya. Anda mendeklarasikan apa yang anda perlukan dalam konstruktor, dan NestJS menyediakannya — yang membawa kepada kode yang longgar-acak dan dapat diuji.

## Cara kerjanya: isytiharkan dalam konstruktor

```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 membaca jenis parameter konstruktor, mencari penyedia terdaftar yang sesuai, membuatnya (jika belum), dan meneruskannya — secara otomatis menyelesaikan seluruh grafik kebergantungan.

## Alur DI

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

## Pendaftaran dan penyelesaian

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

## Mengapa DI berharga

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

## Kebolehujian — manfaat yang menakjubkan

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

Karena kelas tidak membangun kebergantungannya, Anda dapat menukar dalam mock untuk pengujian — DI membuat aplikasi NestJS sangat dapat diuji.

## Menyuntikkan nilai bukan kelas

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

## Mengapa itu penting

Penyelesaian kebergantungan adalah pola asas yang mendasari seluruh seni bina NestJS — ia adalah cara pengawal mendapat perkhidmatan, perkhidmatan mendapat repositori dan perkhidmatan lain, dan seluruh aplikasi diwayarkan bersama.

Memahaminya adalah penting kerana hampir setiap kelas NestJS mengambil bahagian dalam DI: Anda mendeklarasikan kebergantungan dalam konstruktor dan bekas IoC kerangka kerja secara otomatis menyelesaikannya dan menyediakannya, menghilangkan penciptaan manual dan paduan ketat.

Manfaatnya adalah signifikan dan pusat kepada sebab-sebab NestJS dihargai: **paduan longgar** (bergantung pada abstraksi), **kebolehujian** (suntik mock bukan ketergantungan sebenar — membuat pengujian unit yang menyeluruh mudah), kebolehgunaan semula (singleton bersama), dan kebolehselenggaran.

DI dipinjam daripada kerangka kerja seperti Angular dan Spring, dan menguasainya — cara mengisytiharkan, mendaftarkan, menyuntikkan, dan memolok kebergantungan — adalah perlu untuk membina aplikasi NestJS yang berstruktur dengan baik dan dapat diuji serta merupakan salah satu konsep paling penting untuk difahami secara mendalam dalam kerangka kerja.