Provides dependency injection patterns for Spring Boot projects, including constructor-first design, optional collaborator handling, bean selection, and wiring validation. Use when creating services and configurations, replacing field injection, or troubleshooting ambiguous or fragile Spring wiring.
Provides dependency injection patterns for Spring Boot projects, including constructor-first design, optional collaborator handling, bean selection, and wiring validation. Use when creating services and configurations, replacing field injection, or troubleshooting ambiguous or fragile Spring wiring.
allowed-tools
Read, Write, Edit, Bash, Glob, Grep
Spring Boot Dependency Injection
Overview
Provides constructor-first dependency injection patterns for Spring Boot:
mandatory collaborators via constructor injection
optional collaborators via ObjectProvider or no-op fallbacks
bean selection via @Primary and @Qualifier
validation via minimal context tests before full integration
When to Use
Use this skill when:
creating a new @Service, @Component, @Repository, or @Configuration class
replacing field injection in legacy Spring code
resolving multiple beans of the same type with qualifiers or primary beans
handling optional features, adapters, or integrations without null-driven wiring
reviewing circular dependencies or brittle context startup failures
preparing code for direct constructor-based unit testing
Instructions
1. Separate mandatory and optional collaborators
For each class, identify:
mandatory collaborators required for correct behavior
optional collaborators that enable integrations, caching, notifications, or feature-flagged behavior
Mandatory collaborators belong in the constructor. Optional ones need an explicit strategy such as ObjectProvider, conditional beans, or a no-op implementation.
2. Default to constructor injection
For application services and adapters:
inject mandatory dependencies through the constructor
keep injected fields final
instantiate the class directly in unit tests without starting Spring
A single constructor is usually enough; @Autowired is unnecessary in that case.
3. Resolve optional behavior intentionally
Good options include:
ObjectProvider<T> when lazy access is useful
@ConditionalOnProperty or @ConditionalOnMissingBean when wiring should change by configuration
a no-op implementation when the caller should not care whether the feature is enabled
Avoid nullable collaborators that leave runtime behavior ambiguous.
4. Use bean selection annotations only when needed
When multiple beans share the same type:
use @Primary for the default implementation
use @Qualifier for named variants
keep the qualifier names stable and easy to grep
If selection rules become complex, move them into a dedicated configuration class instead of spreading them across services.
5. Keep wiring in configuration, not business code
Use @Configuration and @Bean methods when:
the object comes from a third-party library
conditional creation logic is needed
you need environment-specific wiring or explicit composition
Business services should not know how infrastructure collaborators are instantiated.
6. Validate wiring explicitly
After writing a new service or configuration:
Verify the bean loads with a minimal context test:
