Types of Dependency Injection

Dependency Injection (DI) is a core concept of the Spring Framework. It allows the Spring IoC container to supply required dependencies to a class, instead of the class creating them itself. This results in loose coupling, better testability, and cleaner code.

Spring mainly supports three types of Dependency Injection.

Constructor Injection

Constructor Injection is a type of Dependency Injection where Spring provides required dependencies through the class constructor at the time of object creation.

What it does

• Ensures all mandatory dependencies are available when the object is created
• Prevents creation of partially initialized objects
• Promotes immutability using final fields
• Makes the class safe, clean, and predictable

Key Characteristics

• Preferred and recommended by Spring
• Best for mandatory dependencies
• Easy to test using mocks
• Errors are detected at application startup
• Does not allow object creation without required dependencies

Example:

Step 1: Create a Dependency (PaymentService)

public interface PaymentService {
    void pay();
}

---

Step 2: Provide an Implementation

import org.springframework.stereotype.Service;

@Service
public class CreditCardPaymentService implements PaymentService {

    @Override
    public void pay() {
        System.out.println("Payment done using Credit Card");
    }
}

---

Step 3: Inject Dependency Using Constructor Injection

import org.springframework.stereotype.Component;

@Component
public class OrderService {

    private final PaymentService paymentService;

    // @Autowired is optional (Spring 4.3+)
    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void processOrder() {
        paymentService.pay();
    }
}

---

Step 4: Run the Application (Spring Boot)

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class MyApplication {

    public static void main(String[] args) {

        ApplicationContext context =
                SpringApplication.run(MyApplication.class, args);

        OrderService orderService = context.getBean(OrderService.class);
        orderService.processOrder();
    }
}

---

Output

Payment done using Credit Card

---

What Happens Internally (IoC Container Flow)

1. Spring starts and creates the ApplicationContext
2. It scans classes annotated with @Component / @Service
3. Finds OrderService
4. Sees constructor needs PaymentService
5. Finds CreditCardPaymentService
6. Creates PaymentService bean first
7. Injects it into OrderService constructor
8. OrderService bean is created fully initialized

➡️ If PaymentService is missing → Application fails to start

---

Why Constructor Injection is Best

• Makes dependencies explicit
• Ensures objects are always valid
• Works perfectly with IoC container lifecycle
• Preferred in enterprise & production systems

---

Setter Injection

Setter Injection is a type of Dependency Injection where Spring injects dependencies via public setter methods after the object has been created.

It’s especially useful for optional dependencies or dependencies that may change during runtime.

---

What it does

• Allows dependencies to be set or changed after object creation
• Supports optional dependencies
• Makes the class flexible but slightly less strict
• Introduces a small risk of null if the setter is not called

---

Key Characteristics

• Flexible and easy to modify dependencies at runtime
• Not ideal for mandatory dependencies
• Allows partial initialization of objects
• Less suitable for immutable classes
• Easy to combine with profiles or conditional beans

Example

Step 1: Dependency Interface

public interface PaymentService {
    void pay();
}

Step 2: Dependency Implementation

import org.springframework.stereotype.Service;

@Service
public class PaypalPaymentService implements PaymentService {

    @Override
    public void pay() {
        System.out.println("Payment processed using PayPal");
    }
}

Step 3: Service Using Setter Injection

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

@Component
public class OrderService {

    private PaymentService paymentService;

    @Autowired
    public void setPaymentService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void processOrder() {
        if(paymentService != null) {
            paymentService.pay();
        } else {
            System.out.println("No payment service available");
        }
    }
}

---

Step 4: Main Application

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class MyApplication {

    public static void main(String[] args) {

        ApplicationContext context =
                SpringApplication.run(MyApplication.class, args);

        OrderService orderService = context.getBean(OrderService.class);
        orderService.processOrder();
    }
}

---

What Happens Internally (IoC Flow)

1. Spring creates an OrderService bean using the default constructor.
2. Spring identifies the @Autowired setter method.
3. Finds a matching PaymentService bean (PaypalPaymentService).
4. Calls setPaymentService() to inject the dependency.
5. The OrderService bean is now fully initialized.

If no matching PaymentService exists → paymentService may remain null. Always check in code or use @Required / Optional beans.

---

Use Cases

• Optional dependencies that may not always be required
• Configurations that vary at runtime
• Circular dependencies (can sometimes resolve using setter injection)

---

Field Injection

Field Injection is a type of Dependency Injection where Spring injects dependencies directly into the class fields using @Autowired, bypassing constructors or setter methods.

This method makes code shorter and quicker to write, but it comes with limitations.

---

What it does

• Automatically injects dependencies into fields
• Removes the need for constructors or setters
• Makes code compact but less transparent
• Harder to maintain in complex applications

---

Key Characteristics

• Quick and easy to implement
• Not test-friendly (difficult to inject mocks for unit testing)
• Breaks encapsulation, hiding dependencies
• Not recommended for enterprise or large applications
• Leads to tight coupling and hidden dependencies

Example

Step 1: Dependency Interface

public interface PaymentService {
    void pay();
}

Step 2: Implementation

import org.springframework.stereotype.Service;

@Service
public class PaypalPaymentService implements PaymentService {

    @Override
    public void pay() {
        System.out.println("Payment processed using PayPal");
    }
}

Step 3: Service with Field Injection

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

@Component
public class OrderService {

    @Autowired
    private PaymentService paymentService;

    public void processOrder() {
        paymentService.pay();
    }
}

Step 4: Main Application

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class MyApplication {

    public static void main(String[] args) {

        ApplicationContext context =
                SpringApplication.run(MyApplication.class, args);

        OrderService orderService = context.getBean(OrderService.class);
        orderService.processOrder();
    }
}

---

Why is it discouraged?

1. Testing challenges: Cannot easily inject mock dependencies for unit tests.
2. Hidden dependencies: Dependencies are not visible in the constructor, making code less readable.
3. Tight coupling: Class depends directly on Spring, reducing flexibility.
4. Maintenance issues: Harder to refactor or extend in large applications.

---

Constructor vs Setter vs Field Injection

Feature	Constructor Injection	Setter Injection	Field Injection
Mandatory Dependencies	Yes – ensures all required dependencies are provided at object creation	No – dependencies are optional	No – dependencies are hidden and optional
Optional Dependencies	No – strictly for mandatory dependencies	Yes – useful for optional or changeable dependencies	Yes – can be injected directly into fields
Immutability	Yes – makes the class immutable and safe	No – fields can be modified after object creation	No – fields are mutable and hidden
Testability	Easy – dependencies can be mocked in unit tests	Medium – requires setter setup for tests	Hard – difficult to inject mocks without reflection
Code Quality	High – clean, readable, and maintainable	Medium – readable but can be misused	Low – hidden dependencies, less maintainable
Recommended by Spring	Yes – preferred for mandatory dependencies	Sometimes – use for optional dependencies	No – discouraged in production-grade applications

---

Best Practices

• Use Constructor Injection for required dependencies
• Use Setter Injection for optional dependencies
• Avoid Field Injection in real-world projects
• Prefer final fields for immutability
• Use Lombok @RequiredArgsConstructor to reduce boilerplate

---

Conclusion

Spring supports three types of Dependency Injection, but not all are equal.

• Constructor Injection → Best, safest, and recommended
• Setter Injection → Flexible and useful for optional dependencies
• Field Injection → Simple but discouraged

? Choosing the correct injection type ensures your Spring Boot application is clean, testable, scalable, and production-ready.