How do you use dependency injection in your projects?

I use DI for managing component dependencies in the application. This enhances testability, modularity, and flexibility of the code.

Main ways I apply DI:

• Constructor injection: Preferred method, as dependencies become mandatory and explicit.
• Setter injection: Used for optional dependencies or when working with frameworks that require setters.
• Field injection: Often used in testing scenarios or with frameworks that support annotation-based injection directly into fields.

I actively use frameworks supporting DI, such as Spring or Guice.

Example of constructor injection in Spring:

// Service that depends on another service
@Service
public class OrderService {

    private final InventoryService inventoryService;

    // Injecting dependency via constructor
    @Autowired
    public OrderService(InventoryService inventoryService) {
        this.inventoryService = inventoryService;
    }

    public void placeOrder(String item, int quantity) {
        // Using the injected dependency
        inventoryService.reserveItem(item, quantity);
        // ... other logic
    }
}

// Another service to be injected
@Service
public class InventoryService {
    public void reserveItem(String item, int quantity) {
        // Reservation logic
    }
}

Example of setter injection in Spring:

@Component
public class ReportGenerator {

    private ReportFormatter formatter;

    @Autowired // Can be omitted if there is only one setter
    public void setFormatter(ReportFormatter formatter) {
        this.formatter = formatter;
    }

    public void generateReport() {
        // Using the injected dependency via setter
        formatter.format("Report data");
    }
}

@Component
public class ReportFormatter {
    public String format(String data) {
        return "Formatted: " + data;
    }
}

Example of field injection in Spring:

@Component
public class UserController {

    @Autowired // Injecting dependency directly into the field
    private UserService userService;

    public User findUser(Long id) {
        return userService.findUserById(id);
    }
}

@Service
public class UserService {
    public User findUserById(Long id) {
        // User lookup logic
        return new User(id, "Test User");
    }
}

class User {
    private Long id;
    private String name;

    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

Comparison of approaches:

Injection method	Advantages	Disadvantages	Use cases
Constructor	Explicit mandatory dependencies, easier testing	Can lead to "bloated" constructors	Mandatory dependencies
Setter	Optional dependencies, convenient configuration	Dependency is optional, requires setter call	Optional dependencies, frameworks
Field	Concise syntax	Violates encapsulation principles, harder manual testing	Tests, frameworks

DI allows me to create applications with more flexible and maintainable architecture.