What is an IoC container?

The IoC (Inversion of Control) container is a framework that manages the lifecycle of application objects and their dependencies. Instead of objects creating their dependencies themselves, the container injects them. This inverts the control over object creation and binding.

Main tasks of the IoC container:

• Object creation: The container instantiates objects on demand or at application startup.
• Lifecycle management: Defines when an object is created, used, and destroyed (e.g., singletons, prototypes).
• Dependency injection: Connects application components, providing them with necessary dependencies (e.g., via constructor, setter, or field).
• Configuration: Allows configuring components (e.g., through XML, annotations, or JavaConfig).

Examples of implementation in Java: Spring Framework, Google Guice.

Advantages of using an IoC container:

• Reduced coupling: Components depend less on specific implementations of their dependencies.
• Improved testability: Easier to substitute mock objects for dependencies during testing.
• Enhanced modularity and flexibility: Easier to replace component implementations without changing their consumers.
• Centralized management: Configuration and management of objects are collected in one place.

Dependency Injection (DI) methods:

• Constructor Injection: Dependencies are passed through the constructor when creating an object. It is preferred as it ensures the presence of dependencies.

  // Example of constructor injection
  public class MyService {
      private final MyDependency dependency;
      public MyService(MyDependency dependency) {
          this.dependency = dependency;
      }
      // ...
  }
  

• Setter Injection: Dependencies are set via a public setter after object creation. Suitable for optional dependencies.

  // Example of setter injection
  public class MyService {
      private MyDependency dependency;
      public void setDependency(MyDependency dependency) {
          this.dependency = dependency;
      }
      // ...
  }
  

• Field Injection: Dependencies are injected directly into public or private fields. Often used with annotations (@Autowired in Spring). Not recommended in pure form as it hides dependencies and complicates testing.

  // Example of field injection (often with frameworks)
  public class MyService {
      @Autowired // Example from Spring
      private MyDependency dependency;
      // ...
  }
  

The IoC container implements the IoC principle, and dependency injection is one of the most popular ways to achieve IoC.