19.3. Types of Dependency Injection

1. Constructor Injection Dependencies are passed via constructor parameters.

class Engine {
  public void start() {
    System.out.println("Engine started.");
  }
}
class Car {
  private Engine engine;
  public Car(Engine engine) {
    this.engine = engine;
  }
  public void drive() {
    engine.start();
    System.out.println("Car is driving.");
  }
}

In constructor injection, the dependencies a class requires are provided as constructor parameters. This means that when you create an instance of the Car class, you must also provide an Engine object. The constructor initializes the Car instance and assigns the provided Engine to the engine field. When the drive() method is called on a Car, it uses the injected Engine to start, effectively decoupling the Car from the creation of the Engine.

Think of a car that requires an engine to operate. When the car is being manufactured (constructed), it must have the engine fitted into it. Just as a car factory needs to receive an engine as part of the assembly process, a Car class needs an Engine injected into it at the time of creation.

2. Setter Injection Dependencies are set through public setters.

class Car {
  private Engine engine;
  public void setEngine(Engine engine) {
    this.engine = engine;
  }
  public void drive() {
    engine.start();
    System.out.println("Car is driving.");
  }
}

Setter injection allows the dependencies to be set after the object is created. With setter methods, you can configure the engine for a Car instance even after you've constructed it. This gives more flexibility in changing the engine after the Car has been initialized. However, for this method to work, you must ensure that the setEngine method is called before you use the drive() method, or else you might encounter a NullPointerException.

Imagine having a bicycle where you can change the type of wheels it has after buying it. Initially, you can buy the bicycle without special wheels and set them later. Similarly, with setter injection, a Car can have its engine set at a later time rather than just at the moment of construction.

3. Field Injection (used in frameworks like Spring via annotations) Dependencies are directly injected into fields.

class Car {
  @Autowired
  private Engine engine;
  public void drive() {
    engine.start();
    System.out.println("Car is driving.");
  }
}

Field injection involves using annotations like @Autowired to mark fields in a class that should be automatically filled by the dependency injection container. This approach is straightforward because you don’t explicitly set the engine through a constructor or a setter. However, it reduces the visibility of dependencies and makes it less clear how the class is constructed, which can be problematic for readability and maintainability.

Consider a robot that can be equipped automatically when it enters a charging station. Just as the robot doesn't have to pick up its charging cable but has it connected automatically, in field injection, the framework handles the assignment of dependencies without the developer's manual input.

--