Spring Boot Dependency Injection
Apply Spring Boot constructor injection and bean wiring patterns so agent-generated services stay testable and aligned with Spring best practices.
Overview
Spring Boot Dependency Injection is an agent skill for the Build phase that demonstrates constructor-based Spring DI patterns from basic services through multi-bean registration flows.
Install
npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill spring-boot-dependency-injectionWhat is this skill?
- Constructor injection with Lombok @RequiredArgsConstructor as the recommended mandatory-dependency pattern
- Explicit constructor injection with Objects.requireNonNull for teams avoiding Lombok
- Multi-dependency service examples (repository, email, password encoder) mirroring real registration flows
- Examples progress from basic to advanced Spring Boot DI scenarios
- Aligns agent output with Spring’s preference for immutable final collaborators
Adoption & trust: 1.2k installs on skills.sh; 271 GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You are shipping Spring Boot services but your agent keeps suggesting field injection or ambiguous wiring that is hard to test and review.
Who is it for?
Indie builders or solo devs adding Spring Boot REST or worker services who want consistent, reviewable DI in agent-generated Java.
Skip if: Teams on non-Spring frameworks, pure frontend work, or projects that already enforce DI via an internal archetype the skill would duplicate.
When should I use this skill?
Implementing or refactoring Spring Boot services and you need constructor injection examples for repositories, encoders, and collaborator beans.
What do I get? / Deliverables
Your backend services use constructor injection with final dependencies and idiomatic Lombok or explicit patterns your team can mock in tests.
- Constructor-injected service class patterns
- Multi-dependency wiring examples ready to adapt
Recommended Skills
Journey fit
Dependency injection is implemented while writing Spring Boot backend code, before ship-phase testing hardens the stack. Backend is the canonical shelf because DI governs how services, repositories, and cross-cutting beans are composed in JVM APIs.
How it compares
Use as procedural Spring DI guidance instead of asking the model to improvise @Autowired patterns from generic Java tutorials.
Common Questions / FAQ
Who is spring-boot-dependency-injection for?
Solo and indie builders writing Spring Boot APIs who want their agent to follow constructor injection and realistic service wiring examples.
When should I use spring-boot-dependency-injection?
During Build backend work when creating @Service classes, refactoring legacy field injection, or onboarding an agent to your Spring 3.x stack before you write ship-phase unit tests.
Is spring-boot-dependency-injection safe to install?
Treat it like any third-party skill: review the Security Audits panel on this Prism page and inspect the SKILL.md in your repo before granting shell or network tools.
SKILL.md
READMESKILL.md - Spring Boot Dependency Injection
# Spring Boot Dependency Injection - Examples Comprehensive examples demonstrating dependency injection patterns, from basic to advanced scenarios. ## Example 1: Constructor Injection (Recommended) The preferred pattern for mandatory dependencies. ```java // With Lombok @RequiredArgsConstructor (RECOMMENDED) @Service @RequiredArgsConstructor @Slf4j public class UserService { private final UserRepository userRepository; private final EmailService emailService; private final PasswordEncoder passwordEncoder; public User registerUser(CreateUserRequest request) { log.info("Registering user: {}", request.getEmail()); User user = User.builder() .email(request.getEmail()) .name(request.getName()) .password(passwordEncoder.encode(request.getPassword())) .build(); User saved = userRepository.save(user); emailService.sendWelcomeEmail(saved.getEmail()); return saved; } } // Without Lombok (Explicit) @Service public class UserService { private final UserRepository userRepository; private final EmailService emailService; private final PasswordEncoder passwordEncoder; public UserService(UserRepository userRepository, EmailService emailService, PasswordEncoder passwordEncoder) { this.userRepository = Objects.requireNonNull(userRepository); this.emailService = Objects.requireNonNull(emailService); this.passwordEncoder = Objects.requireNonNull(passwordEncoder); } public User registerUser(CreateUserRequest request) { // Implementation } } ``` ### Test (Easy - No Spring Needed) ```java @Test void shouldRegisterUserAndSendEmail() { // Arrange - Create mocks manually UserRepository mockRepository = mock(UserRepository.class); EmailService mockEmailService = mock(EmailService.class); PasswordEncoder mockEncoder = mock(PasswordEncoder.class); UserService service = new UserService(mockRepository, mockEmailService, mockEncoder); User user = User.builder().email("test@example.com").build(); when(mockRepository.save(any())).thenReturn(user); when(mockEncoder.encode("password")).thenReturn("encoded"); // Act User result = service.registerUser(new CreateUserRequest("test@example.com", "Test", "password")); // Assert assertThat(result.getEmail()).isEqualTo("test@example.com"); verify(mockEmailService).sendWelcomeEmail("test@example.com"); } ``` --- ## Example 2: Setter Injection for Optional Dependencies Use setter injection ONLY for optional dependencies with sensible defaults. ```java @Service public class ReportService { private final ReportRepository reportRepository; private EmailService emailService; // Optional private CacheService cacheService; // Optional // Constructor for mandatory dependency public ReportService(ReportRepository reportRepository) { this.reportRepository = Objects.requireNonNull(reportRepository); } // Setters for optional dependencies @Autowired(required = false) public void setEmailService(EmailService emailService) { this.emailService = emailService; } @Autowired(required = false) public void setCacheService(CacheService cacheService) { this.cacheService = cacheService; } public Report generateReport(ReportRequest request) { Report report = reportRepository.create(request.getTitle()); // Use optional services if available if (emailService != null) { emailService.sendReport(report); } if (cacheService != null) { cacheService.cache(report); } return report; } } ``` --- ## Example 3: Configuration with Multiple Bean Definitions ```java @Configuration public class AppConfig { // Bean 1: Database @Bean public DataSource dataSource(