Wat is de eigenschap van Dependency Injection?

De eigenschap van dependency injection (DI) is dat het creëren en beheren van de afhankelijkheden van een object buiten het object zelf wordt gedaan, meestal in een IoC-container (Inversion of Control). In plaats van dat het object zelf zijn afhankelijkheden creëert of vindt, worden ze van buitenaf in het object 'geïmplementeerd'.

De belangrijkste voordelen en kenmerken van DI:

• Verantwoordelijkheden scheiden: De klasse is niet verantwoordelijk voor het creëren van zijn afhankelijkheden.
• Testbaarheid: Afhankelijkheden kunnen gemakkelijk worden vervangen door mocks of stubs tijdens module-testen.
• Flexibiliteit: Het is gemakkelijk om implementaties van afhankelijkheden te wijzigen zonder de code die ze gebruikt te veranderen.
• Minder koppeling: Componenten worden minder sterk gekoppeld, wat het onderhoud verbetert.

Manieren van implementatie:

• Via constructor (Constructor Injection): Afhankelijkheden worden via de constructor van de klasse doorgegeven. Dit is de meest aanbevolen methode, omdat het de aanwezigheid van afhankelijkheden vanaf het moment van creatie garandeert.

  // Klasse met afhankelijkheid
  public class MyService {
      private MyDependency dependency;
  
      // Injectie via constructor
      public MyService(MyDependency dependency) {
          this.dependency = dependency;
      }
  
      // Gebruik van afhankelijkheid
      public void doSomething() {
          dependency.performAction();
      }
  }
  
  // Afhankelijkheid
  public interface MyDependency {
      void performAction();
  }
  
  // Voorbeeld van implementatie van afhankelijkheid
  public class MyDependencyImpl implements MyDependency {
      @Override
      public void performAction() {
          System.out.println("Actie uitgevoerd!");
      }
  }
  

• Via setter (Setter Injection): Afhankelijkheden worden via openbare setter-methoden doorgegeven. Dit maakt het mogelijk om objecten met afhankelijkheden op aanvraag te maken, maar vereist null-controles en garandeert niet dat alle afhankelijkheden meteen aanwezig zijn.

  // Klasse met afhankelijkheid
  public class AnotherService {
      private AnotherDependency dependency;
  
      // Lege constructor
      public AnotherService() {
      }
  
      // Injectie via setter
      public void setDependency(AnotherDependency dependency) {
          this.dependency = dependency;
      }
  
      // Gebruik van afhankelijkheid
      public void doSomethingElse() {
          if (dependency != null) {
              dependency.anotherAction();
          } else {
              System.out.println("Afhankelijkheid is niet ingesteld!");
          }
      }
  }
  
  // Afhankelijkheid
  public interface AnotherDependency {
      void anotherAction();
  }
  
  // Voorbeeld van implementatie van afhankelijkheid
  public class AnotherDependencyImpl implements AnotherDependency {
      @Override
      public void anotherAction() {
          System.out.println("Andere actie uitgevoerd!");
      }
  }
  

• Via veld (Field Injection): Afhankelijkheden worden rechtstreeks in de velden van de klasse geïnjecteerd met behulp van annotaties. Het is de eenvoudigste syntaxis, maar maakt de klasse afhankelijk van het DI-framework en bemoeilijkt testen zonder framework.

  import org.springframework.beans.factory.annotation.Autowired;
  
  // Klasse met afhankelijkheid
  public class SomeOtherService {
  
      // Injectie via veld (met Spring annotatie)
      @Autowired
      private YetAnotherDependency dependency;
  
      // Gebruik van afhankelijkheid
      public void doYetAnotherThing() {
          dependency.performYetAnotherAction();
      }
  }
  
  // Afhankelijkheid
  public interface YetAnotherDependency {
      void performYetAnotherAction();
  }
  
  // Voorbeeld van implementatie van afhankelijkheid
  public class YetAnotherDependencyImpl implements YetAnotherDependency {
      @Override
      public void performYetAnotherAction() {
          System.out.println("Yana bir harakat bajarildi!");
      }
  }
  

Vergelijking van implementatiemethoden:

Methode van implementatie	Voordelen	Nadelen
Via constructor	Garandeert aanwezigheid van afhankelijkheden, gemakkelijke testbaarheid, onveranderlijk	Kan leiden tot "parameter afhankelijkheid" in de constructor bij veel afhankelijkheden
Via setter	Optionele afhankelijkheden, mogelijkheid om afhankelijkheden na creatie te wijzigen	Vereist null-controles, garandeert niet de volledige staat van het object na creatie
Via veld	Korte syntaxis	Sterke afhankelijkheid van het DI-framework, bemoeilijkt testen zonder framework

DI is een kernprincipe in veel moderne frameworks (bijvoorbeeld Spring, CDI) en bevordert het creëren van losgekoppelde en gemakkelijk te testen applicaties.