What is the feature of dependency injection?

The feature of Dependency Injection (DI) is that the creation and management of an object's dependencies are delegated outside of the object, usually to an IoC container (Inversion of Control). Instead of the object creating or finding its dependencies itself, they are "injected" into it from outside.

Main advantages and features of DI:

• Separation of concerns: The class is not responsible for creating its dependencies.
• Testability: Dependencies can be easily replaced with mocks or stubs during unit testing.
• Flexibility: It is easy to change dependency implementations without modifying the code that uses them.
• Less coupling: Components become less tightly coupled, which improves maintainability.

Methods of injection:

• Constructor Injection: Dependencies are passed through the class constructor. This is the preferred method as it guarantees the presence of dependencies from the moment of object creation.

  // Class with dependency
  public class MyService {
      private MyDependency dependency;
  
      // Injection via constructor
      public MyService(MyDependency dependency) {
          this.dependency = dependency;
      }
  
      // Using the dependency
      public void doSomething() {
          dependency.performAction();
      }
  }
  
  // Dependency
  public interface MyDependency {
      void performAction();
  }
  
  // Implementation of dependency
  public class MyDependencyImpl implements MyDependency {
      @Override
      public void performAction() {
          System.out.println("Action performed!");
      }
  }
  

• Setter Injection: Dependencies are passed through public setter methods. It allows creating objects with dependencies on demand but requires null checks and does not guarantee all dependencies are set immediately.

  // Class with dependency
  public class AnotherService {
      private AnotherDependency dependency;
  
      // Empty constructor
      public AnotherService() {
      }
  
      // Injection via setter
      public void setDependency(AnotherDependency dependency) {
          this.dependency = dependency;
      }
  
      // Using the dependency
      public void doSomethingElse() {
          if (dependency != null) {
              dependency.anotherAction();
          } else {
              System.out.println("Dependency is not set!");
          }
      }
  }
  
  // Dependency
  public interface AnotherDependency {
      void anotherAction();
  }
  
  // Implementation of dependency
  public class AnotherDependencyImpl implements AnotherDependency {
      @Override
      public void anotherAction() {
          System.out.println("Another action performed!");
      }
  }
  

• Field Injection: Dependencies are injected directly into class fields using annotations. The most syntactically simple but makes the class dependent on the DI framework and complicates testing without the framework.

  import org.springframework.beans.factory.annotation.Autowired;
  
  // Class with dependency
  public class SomeOtherService {
  
      // Injection via field (using Spring annotation)
      @Autowired
      private YetAnotherDependency dependency;
  
      // Using the dependency
      public void doYetAnotherThing() {
          dependency.performYetAnotherAction();
      }
  }
  
  // Dependency
  public interface YetAnotherDependency {
      void performYetAnotherAction();
  }
  
  // Implementation of dependency
  public class YetAnotherDependencyImpl implements YetAnotherDependency {
      @Override
      public void performYetAnotherAction() {
          System.out.println("Yet another action performed!");
      }
  }
  

Comparison of injection methods:

Injection method	Advantages	Disadvantages
Constructor	Guarantees dependencies, easy testing, immutability	Can lead to "parameter dependency" in constructors with many dependencies
Setter	Optional dependencies, ability to change dependencies after creation	Requires null checks, does not guarantee full object state after creation
Field	Concise syntax	Strong dependency on DI framework, complicates testing without framework

DI is a key principle in many modern frameworks (e.g., Spring, CDI) and promotes the creation of loosely coupled and easily testable applications.