Wie funktioniert Dependency Injection in NestJS?

Question

Accepted Answer

**Dependency Injection (DI)** ist ein Kernmuster von NestJS, bei dem das Framework **automatisch die Abhängigkeiten erstellt und bereitstellt**, die eine Klasse benötigt, anstatt dass die Klasse diese selbst konstruiert. Sie deklarieren, was Sie benötigen, im Konstruktor, und NestJS stellt es bereit — was zu lose gekoppeltem, testbarem Code führt.

## Wie es funktioniert: im Konstruktor deklarieren

```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 liest die Parametertypen des Konstruktors, sucht die entsprechend registrierten Provider auf, erstellt diese (falls noch nicht geschehen) und übergibt sie — und löst dabei automatisch den gesamten Abhängigkeitsgraph auf.

## Der DI-Ablauf

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

## Registrierung und Auflösung

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

## Warum DI wertvoll ist

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

## Testbarkeit — der entscheidende Vorteil

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

Da die Klasse ihre Abhängigkeiten nicht selbst konstruiert, können Sie für Tests Mocks einsetzen — DI macht NestJS-Anwendungen hochgradig testbar.

## Nicht-Klassen-Werte injizieren

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

## Warum es wichtig ist

Dependency Injection ist das Grundmuster, das der gesamten Architektur von NestJS zugrunde liegt — es ist die Art, wie Controller Services erhalten, Services Repositories und andere Services erhalten, und wie die ganze Anwendung zusammengefügt wird.

Das Verständnis dafür ist essentiell, da fast jede NestJS-Klasse an DI teilnimmt: Sie deklarieren Abhängigkeiten im Konstruktor und der IoC-Container des Frameworks löst sie automatisch auf und stellt sie bereit, was manuelle Instanziierung und enge Koppelung eliminiert.

Die Vorteile sind erheblich und zentral dafür, warum NestJS geschätzt wird: **lose Kopplung** (Abhängigkeit von Abstraktionen), **Testbarkeit** (Mocks statt echter Abhängigkeiten injizieren — umfassendes Unit-Testing wird einfach), Wiederverwendbarkeit (geteilte Singletons) und Wartbarkeit.

DI ist von Frameworks wie Angular und Spring entlehnt, und um es zu beherrschen — wie man Abhängigkeiten deklariert, registriert, injiziert und mockt — ist notwendig, um gut strukturierte, testbare NestJS-Anwendungen zu bauen und ist eines der wichtigsten Konzepte, die man im Framework tiefgreifend verstehen muss.