Dependency Injection in JavaScript: Vollständiger Leitfaden mit Beispielen

Dependency Injection in JavaScript: Vollständiger Leitfaden

Dependency Injection (DI) ist ein leistungsstarkes Entwurfsmuster, das dem Prinzip der Inversion of Control (IoC) zugrunde liegt. Anstatt dass ein Objekt seine Abhängigkeiten selbst erstellt, werden diese von außen „injiziert". Dies macht den Code flexibler, testbarer und wartbarer. In diesem Artikel werden wir anhand einfacher und anschaulicher Beispiele erläutern, wie Dependency Injection in JavaScript und Node.js implementiert wird.

Was ist Dependency Injection und warum wird sie benötigt?

Stellen Sie sich vor, Sie haben eine Klasse UserService, die mit einer Datenbank arbeitet. Ohne DI würden Sie höchstwahrscheinlich eine Instanz der Datenbank direkt innerhalb des Dienstes erstellen:

class UserService {  constructor() {    this.db = new Database(); // Feste Kopplung  }

  getUser(id) {    return this.db.findUser(id);  }}

Dieser Code verstößt gegen das Dependency Inversion Principle. Beim Testen von UserService können Sie die echte Datenbank nicht durch ein Mock-Objekt ersetzen, ohne den Code der Klasse zu ändern. DI löst dieses Problem:

class UserService {  constructor(database) {    this.db = database; // Abhängigkeit wird von außen übergeben  }

  getUser(id) {    return this.db.findUser(id);  }}

// Verwendungconst db = new Database();const userService = new UserService(db);

Hauptvorteile von DI:

• Testbarkeit: Abhängigkeiten können leicht durch Mocks oder Stubs ersetzt werden.
• Lockere Kopplung: Klassen hängen von Abstraktionen (Schnittstellen) ab, nicht von konkreten Implementierungen.
• Flexibilität: Das Verhalten des Systems kann durch Austausch von Implementierungen einfach geändert werden.
• Wiederverwendbarkeit von Code: Komponenten werden unabhängig und können in verschiedenen Kontexten verwendet werden.

Methoden der Abhängigkeitsinjektion in JavaScript

In JavaScript gibt es drei Hauptmethoden zur Abhängigkeitsinjektion:

1. Konstruktor-Injektion (Constructor Injection)

Die gebräuchlichste und empfohlene Methode. Abhängigkeiten werden zum Zeitpunkt der Objekterstellung übergeben.

class Logger {  log(message) {    console.log(`[LOG]: ${message}`);  }}

class OrderService {  constructor(logger) {    this.logger = logger;  }

  createOrder(data) {    this.logger.log('Neue Bestellung erstellt');    // Logik zur Bestellungserstellung  }}

const logger = new Logger();const orderService = new OrderService(logger);orderService.createOrder({ product: 'Laptop', price: 1500 });

2. Setter-Injektion (Setter Injection)

Abhängigkeiten werden nach der Objekterstellung über Setter-Methoden gesetzt. Geeignet für optionale Abhängigkeiten.

class EmailService {  constructor() {    this.transporter = null;  }

  setTransporter(transporter) {    this.transporter = transporter;  }

  send(email) {    if (!this.transporter) {      throw new Error('Transporter nicht gesetzt');    }    this.transporter.sendMail(email);  }}

const emailService = new EmailService();emailService.setTransporter(someMailTransporter);

3. Schnittstellen-Injektion (Interface Injection – bedingt)

JavaScript hat keine nativen Schnittstellen, aber TypeScript oder Dokumentation können zur Beschreibung von Verträgen verwendet werden. In der Praxis läuft dies auf die Überprüfung der Existenz von Methoden hinaus.

Erstellung eines einfachen DI-Containers in Node.js

Für die Verwaltung von Abhängigkeiten in großen Anwendungen ist die Verwendung eines DI-Containers praktisch. Er speichert alle Abhängigkeiten und löst sie automatisch auf. Hier ist eine minimale Implementierung:

class Container {  constructor() {    this.services = new Map();    this.singletons = new Map();  }

  // Registrierung einer Factory für einen Service  register(name,