In the Spring Framework, dependency injection is a design pattern used to implement inversion of control (IoC). There are two main ways to inject dependencies into a Spring bean: constructor injection and setter injection. Below is an explanation of both, along with when and how to use them.

Constructor Injection

With constructor injection, dependencies are provided through the class constructor. This means that the required dependencies are injected while the bean is being instantiated.

Example:

package org.kodejava.spring;

import org.springframework.stereotype.Component;

@Component
public class ExampleService {

    private final Dependency dependency;

    // Constructor Injection
    public ExampleService(Dependency dependency) {
        this.dependency = dependency;
    }

    public void performAction() {
        dependency.doSomething();
    }
}

Benefits of Constructor Injection:

1. Immutability:
   • Dependencies must be provided at the time of object creation, making the object immutable after construction.
   • This makes the object safer and helps reduce bugs.
2. Mandatory dependencies:
   • Forces the consumer of the class to supply all required dependencies, avoiding the risk of . NullPointerException
3. Better for testing:
   • Enables better support for testing because the dependencies can be easily mocked or injected during object creation.
4. Cleaner design:
   • Encourages proper design by clearly stating required dependencies upfront.

Drawbacks:

• Not as flexible when you need to inject optional dependencies, since constructors get unwieldy with too many parameters.

Setter Injection

With setter injection, the dependencies are provided via public setter methods after the bean is instantiated.

Example:

package org.kodejava.spring;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class ExampleService {

   private Dependency dependency;

   // Setter Injection
   @Autowired
   public void setDependency(Dependency dependency) {
      this.dependency = dependency;
   }

   public void performAction() {
      if (dependency != null) {
         dependency.doSomething();
      } else {
         throw new IllegalStateException("Dependency not initialized");
      }
   }
}

Benefits of Setter Injection:

1. Optional dependencies:
   • Suitable for when some dependencies are optional, as they can be assigned (or remain unassigned) after the bean instance is created.
2. Flexibility:
   • Allows updating/replacing dependencies later if needed (though this may lead to issues with immutability).
3. Better for backward compatibility:
   • Useful for older codebases where constructors may already exist, and introducing a large constructor could break existing code.

Drawbacks:

• Dependencies can be set or modified at any time, leaving the object in an inconsistent or unpredictable state.
• There is no guarantee that mandatory dependencies are set, which increases the risk of runtime errors if they are missing.

When to Use Constructor Injection vs Setter Injection?

Factor	Constructor Injection	Setter Injection
Mandatory dependencies	Use when a dependency is essential for the bean to function properly.	Not ideal for mandatory dependencies since they can be forgotten or missed.
Optional dependencies	Use if you can design your code with multiple constructors for optional behaviors (slightly more complex).	Better for optional dependencies, since the setters are invoked as needed.
Immutability	Guarantees immutability after bean instantiation.	Object remains mutable.
Object complexity	Becomes harder to manage when there are too many dependencies.	Useful when the bean has several dependencies and not all need to be injected.
Testing	Easier to test with mocks or stubs because all dependencies are set when constructing the object.	Slightly more verbose for tests as setters might need to be initialized.

Using @Autowired in Spring

Spring automates injection using the @Autowired annotation, which works with both constructor and setter injection.

Constructor Injection with @Autowired:

package org.kodejava.spring;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class ExampleService {

    private final Dependency dependency;

    @Autowired // Optional in Spring (constructor with 1 argument is auto-detected)
    public ExampleService(Dependency dependency) {
        this.dependency = dependency;
    }
}

Setter Injection with @Autowired:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class ExampleService {

    private Dependency dependency;

    @Autowired
    public void setDependency(Dependency dependency) {
        this.dependency = dependency;
    }
}

Best Practices

1. Generally, default to constructor injection, because:
   • It ensures all required dependencies are injected at creation time.
   • It aligns with good object-oriented practices (e.g., immutability, better encapsulation).
2. Use setter injection sparingly, mostly for:
   • Optional dependencies.
   • Situations where backward compatibility is a concern.
3. Avoid mixing setter and constructor injection for the same dependency, as it can lead to confusion.
4. For constructor injection with a large number of dependencies, consider refactoring (e.g., using a helper class to encapsulate related dependencies).

---

Maven Dependencies

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.2.6</version>
</dependency>