Dependency Injection

Entwurfsmuster mit Regeln zu den Abhängigkeiten eines Objekts zur Laufzeit

Als Dependency Injection (DI, englisch dependency ‚Abhängigkeit‘ und injection ‚Injektion‘, deutsch Abhängigkeitsinjektion[1] oder Einbringen von Abhängigkeiten) wird in der objektorientierten Programmierung ein Entwurfsmuster bezeichnet, welches die Abhängigkeiten eines Objekts zur Laufzeit reglementiert: Benötigt ein Objekt beispielsweise bei seiner Initialisierung ein anderes Objekt, ist diese Abhängigkeit an einem zentralen Ort hinterlegt – es wird also nicht vom initialisierten Objekt selbst erzeugt.

WortbedeutungBearbeiten

Die Bezeichnung Dependency Injection wurde 2004 vom Softwareentwickler Martin Fowler eingeführt, um den damaligen Begriff Inversion of Control zu präzisieren: „Inversion of Control is too generic a term, and thus people find it confusing. As a result with a lot of discussion with various [Inversion of Control] advocates we settled on the name Dependency Injection.“ (Martin Fowler: martinfowler.com)[2]

HintergründeBearbeiten

Mit Dependency Injection ist es möglich – entsprechend dem Single-Responsibility-Prinzip – die Verantwortlichkeit für den Aufbau des Abhängigkeitsnetzes zwischen den Objekten eines Programmes aus den einzelnen Klassen in eine zentrale Komponente zu überführen.

In einem herkömmlichen System objektorientierter Programmierung ist dagegen jedes Objekt selbst dafür zuständig, seine Abhängigkeiten, also benötigte Objekte und Ressourcen, zu verwalten. Dafür muss jedes Objekt einige Kenntnisse seiner Umgebung mitbringen, die es zur Erfüllung seiner eigentlichen Aufgabe normalerweise nicht benötigen würde.

Dependency Injection überträgt die Verantwortung für das Erzeugen und die Verknüpfung von Objekten an eine eigenständige Komponente, wie beispielsweise ein extern konfigurierbares Framework. Dadurch wird der Code des Objektes unabhängiger von seiner Umgebung. Das kann Abhängigkeiten von konkreten Klassen beim Kompilieren vermeiden und erleichtert besonders die Erstellung von Unit-Tests.

Vorteile und NachteileBearbeiten

VorteileBearbeiten

  • Der Client hat die Flexibilität, konfigurierbar zu sein. Nur das Verhalten des Clients ist festgelegt. Der Client kann auf alles reagieren, was die vom Client erwartete intrinsische Schnittstelle unterstützt.
  • Die Konfigurationsdetails eines Systems kann in Konfigurationsdateien ausgelagert werden, sodass das System ohne Neukompilierung neu konfiguriert werden kann. Es können separate Konfigurationen für verschiedene Situationen geschrieben werden, die unterschiedliche Implementierungen von Komponenten erfordern. Dies beinhaltet, ohne darauf beschränkt zu sein, Tests.
  • Weil keine Änderung des Codeverhaltens erforderlich ist, kann sie als Refactoring auf Legacy-Code angewendet werden. Das Ergebnis sind Clients, die unabhängiger sind und die sich einfacher isoliert isoliert testen lassen, indem Stubs oder Scheinobjekte verwendet werden, die andere Objekte simulieren, die nicht getestet werden. Diese einfache Prüfung ist oft der erste Vorteil, der bei der Verwendung der Abhängigkeitsinjektion festgestellt wird.
  • Der Client kann das gesamte Wissen über eine konkrete Implementierung entfernen, die er verwenden muss. Dies hilft, den Kunden von den Auswirkungen von Designänderungen und -fehlern zu isolieren. Es fördert die Wiederverwendbarkeit, Testbarkeit und Wartbarkeit.
  • Reduzierung des Boilerplate-Codes in den Anwendungsobjekten, da alle Arbeiten zum Initialisieren oder Einrichten von Abhängigkeiten von einer Anbieterkomponente ausgeführt werden.
  • Gleichzeitige oder unabhängige Entwicklung. Zwei Entwickler können unabhängig voneinander Klassen entwickeln, die sich gegenseitig verwenden, während sie nur die Schnittstelle kennen müssen, über die die Klassen kommunizieren. Plug-ins werden oft von Drittanbietern entwickelt, die nicht einmal mit den Entwicklern sprechen, die das Produkt erstellt haben, das die Plug-ins verwendet.
  • Die Kopplung zwischen einer Klasse und ihrer Dependency wird verringert.

NachteileBearbeiten

  • Es werden Clients erstellt, deren Konfigurationsdetails vom Konstruktionscode bereitgestellt werden müssen. Dies kann lästig sein, wenn offensichtliche Standardeinstellungen verfügbar sind.
  • Das Lesen von Code kann erschwert werden, da sie das Verhalten von der Konstruktion trennt. Dies bedeutet, dass Entwickler auf weitere Dateien verweisen müssen, um die Leistung eines Systems zu verfolgen.
  • Dependency Injection Frameworks werden mit Reflexion oder dynamischer Programmierung implementiert. Dies kann die Verwendung der IDE-Automatisierung behindern, z. B. "Referenzen finden", "Anrufhierarchie anzeigen" und sichere Refactorings.
  • In der Regel ist mehr Entwicklungsaufwand im Voraus erforderlich, da man nicht vorhersagen kann, wann und wo es benötigt wird, sondern anfragen muss, dass es injiziert wird, und dann sicherstellen muss, dass es injiziert wurde.
  • Es ist Aufwand erforderlich, aus Klassen heraus und in die Verknüpfungen zwischen Klassen zu gelangen, die möglicherweise nicht immer wünschenswert oder einfach zu verwalten sind.
  • Die Abhängigkeit von einem Dependency Injection Framework kann gefördert werden.[3]

StrukturBearbeiten

 
Ein Beispiel für ein UML-Klassendiagramm und Sequenzdiagramm für das Dependency Injection Entwurfsmuster.

Im UML-Klassendiagramm instanziiert die Client-Klasse, für die ServiceA und ServiceB Objekte erforderlich sind, die ServiceA1 und ServiceB1 Klassen nicht direkt. Stattdessen erstellt eine Injector-Klasse die Objekte und injiziert sie in den Client, wodurch der Client unabhängig davon wird, wie die Objekte erstellt werden.

Das UML-Sequenzdiagramm zeigt die Laufzeitinteraktionen: Das Injector-Objekt erstellt die ServiceA1 und ServiceB1 Objekte. Danach erstellt der Injector das Client-Objekt und injiziert die ServiceA1 und ServiceB1 Objekte.

UmsetzungBearbeiten

Martin Fowler beschreibt drei verschiedene Arten zum Setzen benötigter Referenzen, die er mit dem Begriff Dependency Injection verbindet: Constructor Injection, Interface Injection und Setter Injection (Abschnitt Forms of Dependency Injection in [2]). Alle von ihm geschilderten Verfahrensweisen verwenden dabei Methodenaufrufe, bei denen die zu setzenden Abhängigkeiten nicht Rückgabewerte, sondern Parameter sind.

Constructor InjectionBearbeiten

Abhängigkeiten von anderen Klassen werden über Konstruktoren zur Verfügung gestellt.

class Abhängiges {
  private Abhängigkeit abhängigkeit;

  //Konstruktor
  public Abhängiges(final Abhängigkeit abhängigkeit) {
    this.abhängigkeit = abhängigkeit;
  }
}

class Injizierer {
  void methode() {
    final Abhängigkeit abhängigkeit = ... ;
    final Abhängiges abhängiges = new Abhängiges(abhängigkeit);
  }
}

Interface InjectionBearbeiten

Das Modul der injizierenden Klasse definiert eine Schnittstelle, die von abhängigen Klassen implementiert werden muss, um zur Laufzeit die Abhängigkeiten zur Verfügung gestellt zu bekommen.

interface IInjizierbar {
  void injiziere(final Abhängigkeit abhängigkeit);
}

class Abhängiges implements IInjizierbar {
  private final Abhängigkeit abhängigkeit;

  public void injiziere(final Abhängigkeit abhängigkeit) {
    this.abhängigkeit = abhängigkeit;
  }
}

class Injizierer {
  void methode() {
    final Abhängigkeit abhängigkeit = ... ;
    final IInjizierbar injizierbares = ... ;
    injizierbares.injiziere(abhängigkeit);
  }
}

Setter InjectionBearbeiten

Die abhängige Klasse stellt Methoden zur Verfügung, die dazu verwendet werden, die Abhängigkeiten zur Verfügung zu stellen.

class Abhängiges {
  private Abhängigkeit abhängigkeit;

  public void setAbhängigkeit(final Abhängigkeit abhängigkeit) {
    this.abhängigkeit = abhängigkeit;
  }
}

class Injizierer {
  void methode() {
    final Abhängiges abhängiges = ... ;
    final Abhängigkeit abhängigkeit = ... ;
    abhängiges.setAbhängigkeit(abhängigkeit);
  }
}

Weitere UmsetzungsmöglichkeitenBearbeiten

Es ist auch möglich, Dependency Injection auf andere Weisen[4] umzusetzen, wie sie in manchen Frameworks Verwendung finden. Beispielsweise können Abhängigkeiten nach Möglichkeiten der Programmiersprache durch Reflexion oder durch direktes Setzen des Verweises darauf in den Speicher auch ohne Methodenaufrufe gesetzt werden.

Es existieren verschiedene Frameworks für diverse Programmiersprachen und Plattformen zur Umsetzung, die fertige Lösungen zur Verfügung stellen. Diese implementieren das Muster mit zum Teil umfassender, weiterführender Funktionalität, wie beispielsweise das Einlesen der Konfiguration aus Dateien und deren Prüfung auf formale Korrektheit. Siehe dazu die Liste von Dependency Injection Frameworks.

Nachteilig kann sich je nach verwendetem DI-Framework auswirken, dass Programmlogik in Konfigurationsdateien ausgelagert werden muss, was die Übersichtlichkeit vermindern und die Wartung erschweren kann: die Entwickler müssen nun zum Verstehen des Codes noch die Konfiguration berücksichtigen, welche sich zudem manchen Hilfsmitteln der Codeanalyse (z. B. IDE-unterstütztes Finden von Abhängigkeiten oder Refactoring) entzieht.

Dieser Nachteil lässt sich vermeiden, indem die Dependency Injection ähnlich dem Entwurfsmuster Abstrakte Fabrik ohne die Verwendung eines Frameworks als Teil des Programms selbst implementiert wird. Diese Art der Umsetzung wird „Do-It-Yourself Dependency Injection“, kurz „DIY-DI“ genannt[5].

EinzelnachweiseBearbeiten

  1. Dependency Injection in ASP.NET Core, Microsoft Docs
  2. a b Martin Fowler: Inversion of Control Containers and the Dependency Injection pattern. 23. Januar 2004. In englischer Sprache. Abgerufen am 16. Mai 2013.
  3. DZone: How Dependency Injection (DI) Works In Spring Java Application Development
  4. Ben Yu: Dependency Injection Types. (Memento des Originals vom 18. August 2013 im Internet Archive)  Info: Der Archivlink wurde automatisch eingesetzt und noch nicht geprüft. Bitte prüfe Original- und Archivlink gemäß Anleitung und entferne dann diesen Hinweis.@1@2Vorlage:Webachiv/IABot/yan.codehaus.org In englischer Sprache. Abgerufen am 16. Mai 2013.
  5. Chad Parry: DIY-DI 9. März 2010. In englischer Sprache. Abgerufen am 29. Juni 2014.

WeblinksBearbeiten