What are the three styles of dependency injection in Spring, and how does each supply a bean its collaborators?
answer
- ctor args / setter methods / field reflection
- single ctor since 4.3 = @Autowired optional
- final fields = constructor only
- optional+reconfigurable = setter
- field = discouraged
basics
~10 sConstructor injection passes dependencies as constructor arguments. Setter injection calls setter methods after construction. Field injection sets private fields directly (via reflection), usually with @Autowired on the field.
solid answer
~30 sSpring supports three injection styles. Constructor injection declares dependencies as constructor parameters; Spring creates the bean by calling that constructor, so the object is fully initialized and its fields can be final. Setter injection uses a no-arg constructor plus setter methods that Spring calls after instantiation — good for optional or reconfigurable dependencies. Field injection annotates the field itself with @Autowired and Spring sets it directly through reflection, bypassing any constructor or setter. Constructor injection is the Spring-recommended default because it guarantees required dependencies are present and enables immutability; field injection is discouraged because it hides dependencies and hurts testability.
code
java · 24 lines// Constructor injection (recommended) — single ctor, @Autowired optional
@Service
class OrderService {
private final PaymentGateway gateway;
private final InventoryClient inventory;
OrderService(PaymentGateway gateway, InventoryClient inventory) {
this.gateway = gateway;
this.inventory = inventory;
}
}
// Setter injection — optional dependency
@Service
class ReportService {
private MailSender mailSender;
@Autowired(required = false)
void setMailSender(MailSender s) { this.mailSender = s; }
}
// Field injection — discouraged
@Service
class NotificationService {
@Autowired private PaymentGateway gateway; // hidden, hard to unit-test
}go deeper
Must name all three styles and how each delivers the dependency.
Should know the single-constructor 4.3 rule and final-field implication.
Explains testability and immutability trade-offs behind the recommendation.
Frames the choice as an API/design contract about required vs optional dependencies.
**Dependency Injection (DI)** means a class does not create its own collaborators (dependencies); instead the **Spring IoC container** supplies them. Spring offers three ways to inject them. **1. Constructor injection.** Dependencies are declared as parameters of the class constructor. Spring resolves each parameter to a matching bean and calls the constructor to build the object. ```java @Service class OrderService { private final PaymentGateway gateway; OrderService(PaymentGateway gateway) { this.gateway = gateway; } } ``` Since Spring Framework 4.3, if a class has exactly **one constructor**, `@Autowired` on it is optional — Spring auto-wires it implicitly. The fields can be `final`, giving **immutability**: once built, the reference never changes. **2. Setter injection.** The bean has a no-arg constructor, and Spring calls setter methods after instantiation. ```java @Service class ReportService { private MailSender mailSender; @Autowired(required = false) void setMailSender(MailSender s) { this.mailSender = s; } } ``` Useful for **optional** dependencies (`required = false`) and dependencies you may want to **reconfigure** later. Fields cannot be `final`. **3. Field injection.** `@Autowired` (or `@Inject`/`@Resource`) is placed directly on a field; Spring sets it via **reflection**, bypassing constructors and setters. ```java @Service class BadService { @Autowired private PaymentGateway gateway; } ``` Concise but discouraged (IntelliJ even warns "Field injection is not recommended"). **Key mechanisms & terms.** - **@Autowired**: marks an injection point Spring should satisfy by type. - **IoC container**: the `ApplicationContext` that instantiates and wires beans. - **Reflection**: field injection writes even into `private final`-less fields without a public accessor. **When to use which.** Prefer constructor injection for **required** dependencies (the Spring team's official recommendation). Use setter injection for **optional/reconfigurable** ones. Avoid field injection except perhaps in test code. **Gotchas.** With multiple constructors you must mark one with `@Autowired` or Spring won't know which to use. Field injection cannot be used to build the object in a plain unit test — you'd need reflection or a Spring context — which is exactly why it hurts testability.
- Since which Spring version is @Autowired optional on a single constructor?Spring Framework 4.3. If a bean class declares exactly one constructor, Spring auto-wires it without an explicit @Autowired annotation.
- Can a field-injected dependency be final?No. final fields must be assigned during construction, and field injection happens after the object is constructed (via reflection), so the field cannot be final. Only constructor injection allows final.
saying these in an interview costs you the question
- Claiming field injection is the recommended default
- Saying you must always put @Autowired on the constructor (not since 4.3 for single-ctor)
- Thinking setter injection allows final fields