In Spring, Dependency Injection (DI) means you let the Spring container create and provide the objects your class depends on, instead of manually creating them with new.
The recommended approach in modern Spring is constructor injection.
1. Define a dependency as a Spring bean
import org.springframework.stereotype.Component;
@Component
public class EmailSender {
public void send(String message) {
System.out.println("Sending email: " + message);
}
}
@Component tells Spring: “Create and manage an instance of this class.”
2. Inject it into another bean
import org.springframework.stereotype.Service;
@Service
public class NotificationService {
private final EmailSender emailSender;
public NotificationService(EmailSender emailSender) {
this.emailSender = emailSender;
}
public void notifyUser(String message) {
emailSender.send(message);
}
}
Because NotificationService is also a Spring bean, Spring sees its constructor and automatically provides an EmailSender.
In modern Spring, if there is only one constructor, you usually do not need @Autowired on the constructor.
3. Use the service from a controller or another bean
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class NotificationController {
private final NotificationService notificationService;
public NotificationController(NotificationService notificationService) {
this.notificationService = notificationService;
}
@GetMapping("/notify")
public String notifyUser() {
notificationService.notifyUser("Hello from Spring!");
return "Notification sent";
}
}
Common DI styles in Spring
Constructor injection — recommended
@Service
public class MyService {
private final MyDependency myDependency;
public MyService(MyDependency myDependency) {
this.myDependency = myDependency;
}
}
Use this most of the time because it:
- makes dependencies explicit
- supports immutability with
final - is easier to test
- avoids partially initialized objects
Setter injection
@Service
public class MyService {
private MyDependency myDependency;
@Autowired
public void setMyDependency(MyDependency myDependency) {
this.myDependency = myDependency;
}
}
Use setter injection mainly for optional dependencies or dependencies that may change after construction.
Field injection — usually avoid
@Service
public class MyService {
@Autowired
private MyDependency myDependency;
}
This works, but it is generally discouraged because it makes testing harder and hides the class’s required dependencies.
Injecting interfaces
A common pattern is to inject an interface rather than a concrete class:
public interface MessageSender {
void send(String message);
}
import org.springframework.stereotype.Component;
@Component
public class EmailSender implements MessageSender {
@Override
public void send(String message) {
System.out.println("Email: " + message);
}
}
import org.springframework.stereotype.Service;
@Service
public class NotificationService {
private final MessageSender messageSender;
public NotificationService(MessageSender messageSender) {
this.messageSender = messageSender;
}
public void notifyUser(String message) {
messageSender.send(message);
}
}
If there is only one implementation of MessageSender, Spring injects it automatically.
When there are multiple implementations
If multiple beans match the same type, use @Qualifier:
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service
public class NotificationService {
private final MessageSender messageSender;
public NotificationService(@Qualifier("emailSender") MessageSender messageSender) {
this.messageSender = messageSender;
}
}
The qualifier value usually matches the bean name, which by default is the class name with a lowercase-first letter.
Creating beans with @Bean
You can also define beans in a configuration class:
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean
public EmailSender emailSender() {
return new EmailSender();
}
}
This is useful when:
- the class comes from a third-party library
- construction requires custom setup
- you do not want to annotate the class with
@Component
Summary
Use this pattern most of the time:
@Service
public class MyService {
private final MyDependency myDependency;
public MyService(MyDependency myDependency) {
this.myDependency = myDependency;
}
public void doWork() {
myDependency.doSomething();
}
}
And make sure the dependency is a Spring bean:
@Component
public class MyDependency {
public void doSomething() {
System.out.println("Dependency logic executed.");
}
}
In short: annotate your classes with Spring stereotypes like @Component, @Service, or @Repository, then inject dependencies through constructors.