Dependency Injection in Spring Boot

Introduction

Dependency injection (DI) is the mechanism that makes Spring applications loosely coupled and easy to test, and it is just as central in Spring Boot as it is in plain Spring. The difference in Boot is mostly about ceremony: auto-configuration and component scanning mean you rarely write XML or manual bean wiring, so DI tends to feel almost invisible. In this lesson you will revisit dependency injection specifically in the Spring Boot context - wiring a service into a controller with constructor injection, the recommended approach for virtually every project.

A Quick Recap of DI

Without DI, a class that needs a collaborator typically creates it directly with new, which hard-codes the dependency and makes the class difficult to test in isolation. With DI, the class simply declares what it needs - usually through its constructor - and the Spring container supplies a ready-made instance at startup. The class never calls new on its dependencies; it just receives them.

// Without DI - tightly coupled, hard to test
public class OrderService {
    private final EmailSender emailSender = new SmtpEmailSender();
}

// With DI - the container supplies the dependency
@Service
public class OrderService {
    private final EmailSender emailSender;

    public OrderService(EmailSender emailSender) {
        this.emailSender = emailSender;
    }
}

Constructor Injection in Boot

Constructor injection means dependencies are passed in through the class constructor and stored in final fields. Since Spring 4.3, if a class has exactly one constructor, the @Autowired annotation on it is optional - Spring Boot will use that constructor automatically to build the bean.

@Service
public class TaskService {

    private final TaskRepository taskRepository;

    // @Autowired is optional here because there is only one constructor
    public TaskService(TaskRepository taskRepository) {
        this.taskRepository = taskRepository;
    }

    public List<Task> findAll() {
        return taskRepository.findAll();
    }
}

Marking the field final gives you a compiler-enforced guarantee that the dependency is set exactly once, at construction time, and can never be reassigned later. This also makes the class trivially testable - in a unit test you can call new TaskService(mockRepository) directly, with no Spring container involved at all.

Injecting a Service into a Controller

The most common wiring pattern in a Spring Boot web application is a controller depending on a service, and the service depending on a repository. Each layer only knows about the layer directly beneath it.

@RestController
@RequestMapping("/api/tasks")
public class TaskController {

    private final TaskService taskService;

    public TaskController(TaskService taskService) {
        this.taskService = taskService;
    }

    @GetMapping
    public List<Task> getAllTasks() {
        return taskService.findAll();
    }

    @PostMapping
    public Task createTask(@RequestBody Task task) {
        return taskService.save(task);
    }
}

Notice that TaskController never constructs a TaskService itself and never touches TaskRepository directly. Each class depends only on its immediate collaborator, which keeps responsibilities cleanly separated and makes each layer easy to swap or mock independently.

Why Not Field Injection?

Field injection - annotating a field directly with @Autowired instead of using a constructor - is common in older tutorials but is now widely discouraged, including by the Spring team itself.

// Discouraged: field injection
@Service
public class TaskService {

    @Autowired
    private TaskRepository taskRepository;
}

Injecting Multiple Implementations

When more than one bean implements the same interface, Spring cannot guess which one you want and throws a NoUniqueBeanDefinitionException at startup. Use @Qualifier to tell it exactly which implementation to inject.

public interface NotificationSender {
    void send(String message);
}

@Component("emailSender")
public class EmailNotificationSender implements NotificationSender {
    public void send(String message) {
        System.out.println("Email: " + message);
    }
}

@Component("smsSender")
public class SmsNotificationSender implements NotificationSender {
    public void send(String message) {
        System.out.println("SMS: " + message);
    }
}

@Service
public class AlertService {

    private final NotificationSender sender;

    public AlertService(@Qualifier("emailSender") NotificationSender sender) {
        this.sender = sender;
    }
}

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Dependency injection in Spring Boot works the same way it does in plain Spring, but auto-configuration and component scanning remove most of the manual wiring. Favor constructor injection with final fields, keep each layer depending only on the layer beneath it, and reach for @Qualifier or @Primary when a bean has more than one implementation.