Inversify TypeScript: Vollständige Anleitung mit Beispielen

Was ist Inversify und warum wird es benötigt?

Inversify ist ein leistungsstarker und leichtgewichtiger IoC (Inversion of Control) Container für TypeScript und JavaScript. Es implementiert das Dependency Injection (DI) Pattern, eines der Kernprinzipien von SOLID. Inversify verwaltet Abhängigkeiten zwischen Klassen und macht den Code modularer, testbarer und wartbarer.

Warum wird das benötigt? In der traditionellen Programmierung erstellen Klassen ihre Abhängigkeiten selbst (z.B. mit new). Dies führt zu einer starken Kopplung des Codes. Inversify kehrt diesen Prozess um: Abhängigkeiten werden von außen "injiziert" (daher der Name Inversion of Control). Der Container übernimmt die Erstellung und Verwaltung des Lebenszyklus von Objekten.

Die wichtigsten Vorteile von Inversify:

• Geringe Kopplung: Klassen hängen von Abstraktionen (Schnittstellen) ab, nicht von konkreten Implementierungen.
• Einfaches Testen: Sie können echte Abhängigkeiten in Tests problemlos durch Mocks/Stubs ersetzen.
• Lebenszyklus-Management: Der Container kann Objekte als Singletons oder jedes Mal als neue Instanzen erstellen.
• Lesbarkeit und Wartbarkeit: Alle Abhängigkeiten sind explizit deklariert und leicht nachvollziehbar.
• Skalierbarkeit: Ideal für große Projekte mit vielen Modulen.

Inversify Installation

Inversify wird über npm installiert. Für die Arbeit mit TypeScript müssen Sie außerdem reflect-metadata (eine Bibliothek für die Arbeit mit Dekoratoren) installieren und die tsconfig.json konfigurieren.

# Installation von Inversify und reflect-metadata
npm install inversify reflect-metadata --save

# Installation der Typen für TypeScript (falls nicht vorhanden)
npm install @types/node --save-dev

Konfiguration der tsconfig.json:

{
  "compilerOptions": {
    "target": "ES6",
    "module": "commonjs",
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "outDir": "./dist",
    "rootDir": "./src",
    "types": ["reflect-metadata"]
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

Wichtig: Die Dekoratoren @injectable() und @inject() funktionieren nur, wenn experimentalDecorators und emitDecoratorMetadata aktiviert sind.

Schnellstart mit Codebeispiel

Erstellen wir ein einfaches Beispiel: einen Dienst zum Senden von Benachrichtigungen. Wir haben ein Interface INotificationService, seine Implementierung EmailNotificationService und eine Klasse UserService, die diesen Dienst verwendet.

// 1. Importieren der benötigten Module
import "reflect-metadata";
import { Container, injectable, inject } from "inversify";

// 2. Definition des Interfaces (Abstraktion)
interface INotificationService {
  send(message: string): void;
}

// 3. Implementierung des Interfaces
@injectable()
class EmailNotificationService implements INotificationService {
  send(message: string): void {
    console.log(`E-Mail senden: ${message}`);
  }
}

// 4. Klasse, die von INotificationService abhängt
@injectable()
class UserService {
  private notificationService: INotificationService;

  constructor(
    @inject("INotificationService") notificationService: INotificationService
  ) {
    this.notificationService = notificationService;
  }

  notifyUser(userId: string): void {
    this.notificationService.send(`Benachrichtigung für Benutzer ${userId}`);
  }
}

// 5. Container erstellen und Abhängigkeiten registrieren
const container = new Container();
container.bind("INotificationService").to(EmailNotificationService);
container.bind(