Dependency Injection (DI) is a software design pattern that facilitates component collaboration by externalizing their dependencies. This technique brings several benefits.

Benefits of Dependency Injection

• Component Isolation: Enhances the modularity, reusability, and testability of individual components.
• Flexibility: Allows for interchangeable components, promoting robustness and adaptability.
• Seamless Testing: Makes it simpler to test each component in isolation.

In practical terms, DI consists of three fundamental components:

1. Service Provider: Responsible for managing dependencies.
2. Client Component: Relies on services provided by the service provider.
3. Service Interface: Defines the contract between the service provider and the client component.

Core Principles

• Inversion of Control: Modules should depend on abstractions rather than concrete implementations, and these abstractions will be provided externally.
• Separation of Concerns: Ensures that each module is responsible for its specific task, and dependencies are managed externally.

The 3 Variants of DI

1. Constructor Injection: Dependencies are provided through the constructor.

   Code Example

   public class ClientComponent {
       private final IService service;
       public ClientComponent(IService service) {
           this.service = service;
       }
   }
   

2. Method (Setter) Injection: Dependencies are set via a method, commonly known as a setter method.

   Code Example

   public class ClientComponent {
       private IService service;
       public void setService(IService service) {
           this.service = service;
       }
   }
   

3. Field Injection: Dependencies are directly assigned to a field. This approach is often discouraged due to reduced encapsulation.

   Code Example

   public class ClientComponent {
       @Inject
       private IService service;
   }