Dependency-Inversion-Prinzip

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche

Das Dependency Inversion Principle (DIP; engl. „Abhängigkeits-Invertierungs-Prinzip“) ist ein Prinzip beim objektorientierten Entwurf von Software. Es beschäftigt sich mit der Abhängigkeit von Modulen.

Strukturierung von Modulen nach DIP

Im Allgemeinen wird das DIP beschrieben durch:

Module höherer Ebenen sollten nicht von Modulen niedrigerer Ebenen abhängen.
Beide sollten von Abstraktionen abhängen.
Abstraktionen sollten nicht von Details abhängen.
Details sollten von Abstraktionen abhängen.

Problemstellung und Lösung[Bearbeiten]

Objektorientierte Entwürfe werden in Module strukturiert, die unterschiedliche Verantwortlichkeiten umsetzen. Eine gängige Praxis ist das Anordnen der Module in Ebenen. Je niedriger die Ebene eines Modul, desto spezieller sind die Vorgänge, die es definiert. In Modulen höherer Ebenen werden allgemeine Abläufe umgesetzt, welche von Modulen niedrigerer Ebenen benutzt werden.

Falls diese Anordnung falsch umgesetzt wird, also Module höherer Ebenen von Modulen niedrigerer Ebenen abhängen, entsteht ein Problem. Änderungen in Modulen niedrigerer Ebenen führen unweigerlich zu Änderungen in Modulen höherer Ebenen. Dies widerspricht aber einerseits dem eigentlichen Ansatz der Hierarchie, andererseits führt es zu zyklischen Abhängigkeiten. Dadurch kommt es zu einer erhöhten Kopplung der Module, welche Änderungen in Architektur und Design unnötig verkomplizieren.

Der Lösungsansatz ist die Invertierung der Abhängigkeit. Das Modul der höheren Ebene definiert die Schnittstelle, mit der es arbeitet. Module niedrigerer Ebene realisieren die Schnittstelle.

Beispiel[Bearbeiten]

Wir betrachten ein einfaches Schalter-Lampe-Modell. Das Drücken des Schalters soll die Lampe an- oder ausschalten.

Eine einfache Implementierung in Java:

public class Lampe {
   private boolean leuchtet = false;
 
   public void anschalten() {
      leuchtet = true;
   }
 
   public void ausschalten() {
      leuchtet = false;
   }
}
 
public class Schalter {
   private Lampe lampe;
   private boolean gedrueckt;
 
   public Schalter(Lampe lampe) {
      this.lampe = lampe;
   }
 
   public void drueckeSchalter() {
      gedrueckt = !gedrueckt;
      if(gedrueckt) {
         lampe.anschalten();
      } else {
         lampe.ausschalten();
      }
   }
}

Schalter steuert den Ablauf des Verhaltens und benutzt dazu Lampe. Demnach sollte es einem Modul höherer Ebene angehören. Jedoch verletzt das beschriebene Modell das 'DIP', da Schalter abhängig von Lampe ist. Wird entschieden, dass die Methoden von Lampe umbenannt werden, muss auch Schalter geändert werden.

Das grundlegende Problem ist, dass Schalter direkt mit Lampe arbeitet, welches zu einem niedrigeren Modul gehört. Schalter sollte selbst definieren, wie das Objekt aussehen sollte, mit dem es arbeitet.

Die Lösung in Java:

public interface SchalterKlient {
   public void geheAn();
   public void geheAus();
}
 
public class Schalter {
   private SchalterKlient klient;
   private boolean gedrueckt;
 
   public Schalter(SchalterKlient klient) {
      this.klient= klient;
   }
 
   public void drueckeSchalter() {
      gedrueckt = !gedrueckt;
      if(gedrueckt) {
         klient.geheAn();
      } else {
         klient.geheAus();
      }
   }
}
 
public class LampeDIP implements SchalterKlient{
   private boolean leuchtet = false;
 
   public void geheAn() {
      leuchtet = true;
   }
 
   public void geheAus() {
      leuchtet = false;
   }
}

Die Schnittstelle SchalterKlient gehört zum gleichen Modul wie Schalter. Spezifischere Module müssen diese Schnittstelle realisieren, damit Schalter mit ihnen arbeiten kann. Somit wurde die Abhängigkeit invertiert.

Zusätzlich zum Brechen der Abhängigkeit wurde ein weiterer Vorteil erarbeitet: Schalter kann nun mit beliebigen Klienten arbeiten.

Das Beispiel lässt sich weiterführen. Schalter selbst wird vermutlich von einem anderen Modul aus genutzt, das entscheidet, wann der Schalter gedrückt wurde. Demnach sollte dieses Modul wiederum eine Schnittstelle definieren, die Schalter realisieren muss.

Weblinks[Bearbeiten]

Artikel von Robert C. Martin (PDF; 30 kB)

Literatur[Bearbeiten]

  • Robert C. Martin: The Dependency Inversion Principle. 5/1996