Dependency Inversion, Inversion of Control und Dependency Injection
https://bildung.social/@oerinformatik/
https://oer-informatik.de/dependency-injection
Dependency Injection, Dependency Inversion Principle, Inversion of Control, SOLID, Entwurfsprinzipien, Entwurfsmuster, lose Kopplung, Interface, UML-Klassendiagramm, Java
tl/dr; (ca. 11 min Lesezeit): Die meisten aktuellen Frameworks wären undenkbar ohne die „Zauberhand“, die im Hintergrund lose gekoppelte Komponenten verknüpft. Der Artikel führt vom Entwurfsprinzip Dependency Inversion über die Umsetzung Inversion of Control zum Entwurfsmuster Dependency Injection – mit Codebeispielen in Java, C# und Python und UML-Klassendiagrammen [AI-Assisted]. (Zuletzt geändert am 09.11.2026)
Dieser Artikel ergänzt die Artikelreihe über Clean Code: Überblick / Klassen schneiden / Vererbung richtig einsetzen / Erweitern statt ändern / SOLID / Vom Entwurf zum Code. Er erklärt die Begriffe allgemein an Client und ConcreteService; wie das Prinzip in der CSB-Rad-Kata der Reihe umgesetzt und mit Stub und Mock getestet wird, zeigt der Artikel SOLID.
Schon fit in diesem Thema? Nutze die Kann-Liste und die Leitfragen unter dem Artikel als Checkliste, ob Du die relevanten Kompetenzen bereits hast.
Als OOP-Grundlagen kann ich nach Durchlesen des Artikels…
… den Unterschied zwischen Entwurfsprinzipien und Entwurfsmustern erklären.
… das Dependency Inversion Principle (DIP) wiedergeben und an einem Beispiel erläutern.
… die Abhängigkeit zwischen zwei Klassen mit Hilfe eines Interfaces auflösen und im UML-Klassendiagramm (auch in Lollipop-Notation) darstellen.
… erklären, was bei Inversion of Control (IoC) umgekehrt wird.
… die Übergabe einer Abhängigkeit per Konstruktor und per Setter in Java umsetzen.
Darüber hinaus kann ich als OOP-Expertenwissen…
… die Rolle des Injectors beim Entwurfsmuster Dependency Injection beschreiben und constructor, setter und field injection unterscheiden.
… Vorteile der Entkopplung für Austauschbarkeit und Testbarkeit (Mock-Objekte) beurteilen.
In der objektorientierten Programmierung (OOP) gibt es eine Reihe von grundlegenden Prinzipien, die die Wartbarkeit, Lesbarkeit und Fehlerresistenz von Code positiv beeinflussen. Diese abstrakten Prinzipien werden Design Principles (Entwurfsprinzipien) genannt. In Anwendung dieser Prinzipien wurden eine Reihe best practices veröffentlicht, die Standardprobleme der OOP lösen und einheitliche Vokabeln für die genutzten Softwarekomponenten festlegen. Diese konkreten Lösungsvorschläge nennt man Design Pattern (Entwurfsmuster). Oft setzen Entwurfsmuster eine Reihe von abstrakten Designprinzipien um – wie hier am Beispiel des Dependency Inversion-Designprinzips und des Entwurfsmusters Dependency Injection gezeigt wird.
Das Dependency Inversion Prinzip
Das Dependency Inversion Principle beschäftigt sich mit der Entkopplung von Softwaremodulen untereinander. Vereinfacht gesagt besagt es, dass zwei konkrete Klassen nicht direkt voneinander abhängen sollen (und damit eng gekoppelt sind), sondern die Abhängigkeit über ein Interface (eine abstrakte Struktur) realisiert werden sollte.
Es ist eines der fünf grundlegenden SOLID-Prinzipien, die Robert C. Martin bekannt gemacht hat (u. a. im Buch „Agile Software Development: Principles, Patterns, and Practices“, 2002). Erstmals beschrieben hat er es 1996 im C++ Report. Einen Überblick über alle fünf Prinzipien gibt der Artikel SOLID; das Open Closed Principle und das Interface Segregation Principle stehen ausführlich im Artikel Erweitern statt ändern, das Single Responsibility Principle im Artikel Klassen schneiden.
Konkreter besagt es, dass high level-Module nicht direkt von low level-Modulen abhängen sollen. Diese Abhängigkeit lässt sich im UML-Klassendiagramm folgendermaßen darstellen:
Ein Beispiel mit Quelltext. Wir betrachten einen High-Level Client, der eine Instanz des Low-Level Services erzeugt und nutzt (hier: als Attribut). Der Client hängt von der Implementierung des Services ab:
Die Codebeispiele stehen in Java, C# und Python zur Auswahl; die Auswahl gilt für alle Beispiele dieses Artikels. In Python gibt es keine Interfaces als eigenes Sprachmittel, dort übernimmt eine abstrakte Basisklasse (ABC) diese Rolle.
public class Client {
private ConcreteService service;
public Client(){
service = new ConcreteService();
}
}
public class ConcreteService {/*...*/};Die Abhängigkeit in diesem Beispiel ist konkret eine einseitig navigierbare Assoziation:
Das Dependency Inversion Prinzip besagt:
High-Level-Module sollen nicht von Low-Level-Modulen abhängen. Beide sollen von Abstraktionen abhängen. Abstraktionen sollen nicht von Details abhängen. Details sollen von Abstraktionen abhängen.
Die Abhängigkeit soll also aufgelöst werden, indem ein Interface die Abhängigkeit zwischen Client und Service entkoppelt. Das Interface wird von der High-Level-Klasse genutzt und von der Low-Level-Klasse implementiert:
public class Client {
private ServiceInterface service;
public Client(){
service = new ConcreteService();
}
}
public class ConcreteService implements ServiceInterface {/*...*/};
public interface ServiceInterface {/*...*/};Im UML-Klassendiagramm bleibt die einseitig navigierbare Assoziation erhalten, zielt jedoch auf das Interface. Auch die Abhängigkeit des ConcreteService (Implementierung) zeigt auf das Interface. Beide hängen also nur noch von der abstrakten Struktur des ServiceInterface ab.
Wenn Assoziationen über Interfaces realisiert werden, werden diese in UML-Klassendiagrammen häufig in der “Lollipop”-Notation dargestellt, die das Interface nicht mehr ausführlich, sondern nur noch als Stecker/Buchse skizziert darstellt:
Objekterzeugung entkoppeln: Inversion of Control (IoC)
Ein weiterer Schritt der Entkopplung wird unter dem Prinzip Inversion of Control (IoC) zusammengefasst:
Die Kontrolle darüber, welche konkrete Implementierung eines Service aufgerufen wird, wird vom eigentlichen Aufruf der Methode entkoppelt – die Kontrolle also umgekehrt.
Die Erzeugung einer Objektinstanz einer abstrahierten Klasse (hier: ServiceInterface) soll von deren Nutzung (hier: durch Client) entkoppelt werden. Wir übergeben die Kontrolle über die Objektinstanz nach außen (z.B. über Setter oder Konstruktoren):
Im Code einer Client-Klasse soll also nicht selbst festgelegt werden, welche Klassen (oder Bibliotheken) die aufgerufenen Methoden des ServiceInterface implementieren, sondern dies soll an anderer Stelle (i.d.R. durch ein Framework) erfolgen.
Dies setzt zunächst das dependency inversion principle (DIP) voraus.
Im einfachsten Fall geschieht dies über Parameter, die bei Methodenaufrufen von extern übergeben werden.
Ein Beispiel mit Konstruktoren:
public class Client {
private ServiceInterface service;
public Client(ServiceInterface service){
this.service = service;
}
}oder ein Beispiel mit Setter-Methoden:
public class Client {
private ServiceInterface service;
public void setService(ServiceInterface service){
this.service = service;
}
}Das konkrete Verhalten des jeweiligen Methodenaufrufs kann somit außerhalb der Klasse geändert werden - abhängig davon, welche konkrete Implementierung mit dem Methodenaufruf später verknüpft wird. Hierzu werden in den implementierten Codeabschnitten abstrakte Strukturen genutzt, die beispielsweise im Framework implementiert werden müssen.
Vorteil dieser Technik ist eine Entkopplung des Methodenaufrufs von der Implementierung, damit verbunden
bessere Modularität, Klassen können beispielsweise auch leicht getauscht werden,
leichtere Testbarkeit, da Abhängigkeiten leichter durch Test-Doubles (Stubs und Mocks) ersetzt werden können; ein Beispiel zeigt der Artikel SOLID
Praktisch umgesetzt werden kann IoC über die Design Pattern:
Dependency Injection
Factory Pattern
Strategy Pattern (Anwendung von DIP/OCP)
Service Locator Pattern
Beim Service Locator fragt die Klasse eine zentrale Registry nach ihren Abhängigkeiten. Das versteckt die Abhängigkeit zur Registry und wird deshalb heute meist zugunsten von Dependency Injection gemieden.
Dependency Injection
Bei dependency injection (DI) wird die Übergabe der konkreten Instanz nicht mehr (wie noch im obigen Beispiel) über die Implementierung des Codes selbst umgesetzt, sondern durch das Framework. Neben den beiden Klassen Client und ConcreteService, die per DIP entkoppelt wurden, gibt es nun einen weiteren Akteur: den Injector, der i.d.R. im Framework implementiert ist. Der Injector muss aber kein Framework sein: In kleinen Programmen übernimmt eine Kompositionswurzel (composition root) diese Rolle, also eine Stelle beim Programmstart, die alle Objekte erzeugt und verdrahtet.
Hierbei werden drei unterschiedliche Arten der Injektion genutzt:
constructor injection (Konstruktor-Injektion): Die konkrete Instanz wird als Parameter eines Konstruktors übergeben
setter injection: Die konkrete Instanz wird als Parameter eines Setters übergeben
field injection: Das Framework setzt die konkrete Instanz direkt in ein Attribut, meist gesteuert über eine Annotation (z. B.
@Injectoder@Autowiredin Spring).
Den Teil eines Frameworks, der als Injector arbeitet, nennt man IoC-Container (auch DI-Container), in Spring etwa den ApplicationContext. Er erzeugt beim Start die Objekte der markierten Klassen (z. B. @Component, @Service) und übergibt sie anhand der Konstruktorparameter. Für Pflichtabhängigkeiten ist die Konstruktor-Injektion die erste Wahl: Das Objekt existiert nie ohne seine Abhängigkeiten, und Tests können ohne Container Test-Doubles übergeben. Die field injection ist bequem, lässt sich in Tests aber nur mit Hilfe des Frameworks oder per Reflection befüllen. Wann ein Container sich lohnt und wann die Verdrahtung von Hand besser ist, beschreibt der Artikel SOLID.
Leitfragen
- Was besagt das Dependency Inversion Principle?
High-Level-Module sollen nicht von Low-Level-Modulen abhängen, beide sollen von Abstraktionen abhängen. Praktisch nutzt die High-Level-Klasse ein Interface, das die Low-Level-Klasse implementiert – siehe Abschnitt „Das Dependency Inversion Prinzip“.
- Wie wird die Abhängigkeit zwischen
ClientundConcreteServiceim UML-Klassendiagramm aufgelöst?
Die gerichtete Assoziation des Client zeigt nicht mehr auf ConcreteService, sondern auf das ServiceInterface, das ConcreteService implementiert. Verkürzt lässt sich das in der Lollipop-Notation als Stecker und Buchse darstellen – siehe Abschnitt „Das Dependency Inversion Prinzip“.
- Was wird bei Inversion of Control „umgekehrt“?
Die Kontrolle darüber, welche konkrete Implementierung genutzt wird: Der Client erzeugt das Objekt nicht mehr selbst, sondern bekommt es von außen übergeben, etwa über einen Konstruktor oder einen Setter – siehe Abschnitt „Objekterzeugung entkoppeln: Inversion of Control (IoC)“.
- Welche Vorteile bringt es, Abhängigkeiten von außen zu übergeben?
Klassen sind modularer und lassen sich leicht austauschen, und sie sind leichter zu testen, weil Abhängigkeiten durch Mock-Objekte ersetzt werden können – siehe Abschnitt „Objekterzeugung entkoppeln: Inversion of Control (IoC)“.
- Welche Aufgabe hat der Injector beim Entwurfsmuster Dependency Injection, und welche Arten der Injektion gibt es?
Der Injector, meist Teil eines Frameworks, erzeugt die konkrete Instanz und übergibt sie dem Client. Das geschieht per Konstruktor (constructor injection), per Setter (setter injection) oder direkt in ein Attribut (field injection) – siehe Abschnitt „Dependency Injection“.
Links und weitere Informationen
Auf oer-informatik.de: SOLID im Überblick, Erweitern statt ändern, Klassen schneiden, Unit-Tests, JUnit und Mockito
Martin Fowler: Inversion of Control Containers and the Dependency Injection pattern
Baeldung: Intro to Inversion of Control and Dependency Injection with Spring
Stackify: Design Patterns Explained – Dependency Injection with Code Examples
Hinweis zur Nachnutzung als Open Educational Resource (OER)
Dieser Artikel und seine Texte, Bilder, Grafiken, Code und sonstiger Inhalt sind - sofern nicht anders angegeben - lizenziert unter CC BY 4.0. Nennung gemäß TULLU-Regel bitte wie folgt: “Dependency Inversion, Inversion of Control und Dependency Injection” von oer-informatik.de (H. Stein), Lizenz: CC BY 4.0. Der Artikel wurde unter https://oer-informatik.de/dependency-injection veröffentlicht, die Quelltexte sind in weiterverarbeitbarer Form verfügbar im Repository unter https://gitlab.com/oer-informatik/design-prinzipien/clean-code. Erstellt mit KI-Assistenz; von mir umfassend redaktionell überarbeitet, geprüft und freigegeben. Stand: 09.11.2026.
[Kommentare zum Artikel lesen, schreiben] / [Artikel teilen] / [gitlab-Issue zum Artikel schreiben]
