19.3.2. Setter Injection

Dependencies are set through public setters.

Setter Injection is a technique used to provide dependencies to a class after the class has been constructed. In this method, the class exposes a public setter method that allows the user of the class to supply the required dependencies. This makes the class more flexible because its dependencies can be modified without changing the constructor.

Imagine setting up a home theater system. First, you have a TV, but you need to connect it to various devices like a DVD player or speakers. Instead of buying a TV that only connects to one kind of player, you can use cables (setters) to connect any device you want, as long as you have the right connectors. Similarly, Setter Injection allows you to connect different dependencies to your class without being restricted to one specific setup.

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

In this code snippet, we have a class named Car that has a private member variable engine of type Engine. The setEngine method is a public setter which allows the user to inject an instance of Engine into the Car object after its creation. The drive method uses the engine to perform an action (starting the engine and driving) which demonstrates how the injected engine can be utilized by the Car class.

Think of a delivery service that delivers food. When a customer orders, the delivery person (Car) can accept food (Engine) from any restaurant (any Engine type). The delivery person relies on the food they picked up but can change restaurants based on availability or customer preference, just like Setter Injection allows changing dependencies dynamically.

Setter Injection provides several advantages, such as allowing optional dependencies and promoting flexibility.

One of the key advantages of Setter Injection is the flexibility it offers. Unlike constructor injection, which requires all dependencies to be supplied at the time of object creation, setter injection enables developers to set some dependencies optionally. Additionally, it allows for updating dependencies even after the class object has been instantiated, leading to more dynamic systems.

Consider a gardener who can decide to add new plants (optional dependencies) to their garden at any time during the growing season instead of planting everything all at once. Setter Injection allows a similar flexibility in software, enabling updates and modifications even after an object is created.

It is essential to ensure that all necessary dependencies are set appropriately to avoid issues at runtime.

While Setter Injection is flexible, it does come with certain challenges. Specifically, there can be a risk of runtime errors if a dependency is not set correctly before usage. Developers need to manage the state of the object carefully and might need to implement checks to ensure that all required dependencies are present whenever a method that relies on them is called.

Imagine assembling a piece of furniture where the instructions allow you to add parts at any time. If you forget to install a critical piece, the whole structure might collapse or not work correctly. Similarly, in software, forgetting to set a necessary dependency can lead to errors and dysfunction in the application's operation.

--