How does dependency injection work in Spring, and why do you prefer constructor injection?

The container builds beans and supplies their collaborators, so classes declare what they need rather than constructing it. Constructor injection is preferred because the dependencies are mandatory and visible, the fields can be final so the object is immutable and fully initialized, the class is testable with plain new and no reflection, and a circular dependency fails loudly at startup instead of hiding behind lazy field injection.

The container owns object creation, so my class asks for what it needs in its constructor and Spring resolves and injects it. I use constructor injection because it makes the contract obvious: if a class takes five collaborators, that is now visible in the signature rather than hidden across five annotated fields, and it usually tells me the class is doing too much. The fields can be final, so the object is fully constructed and safe to publish across threads, and I can instantiate it in a test with plain constructor arguments and no Spring context at all, which keeps unit tests fast. Circular dependencies also surface at startup as a failure rather than being papered over. On scope, beans are singletons by default, so I keep them stateless; a mutable field on a singleton service is a race condition waiting for concurrent requests. When I need per request state I pass it as a method parameter rather than reaching for a request scoped bean. Field injection I actively avoid, since it hides dependencies and needs reflection to set up in a test.