giuseppe-trisciuoglio/developer-kit

spring-boot-dependency-injection

Provides dependency injection patterns for Spring Boot projects, including constructor-first design, optional collaborator handling, bean selection, and wiring validation.

소스 보기

사용 방법

  1. 설치 명령을 복사하고 자신의 에이전트 환경에 설치하기 전에 소스 패키지를 확인하세요.
  2. 필요한 도구, 인증 정보, 지원 환경은 원본 문서에서 확인하세요.
  3. 입력과 원하는 산출물을 설명하고 출처와 결과를 대조하세요.
npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill spring-boot-dependency-injection

시작 전 확인

  • 설치에는 모델 구독, API 한도, 파일 접근 권한이 포함되지 않습니다.
  • 별점 수와 설치 수는 활동 지표이며 독립적인 품질·보안 검증이 아닙니다.
원본 Skill 문서

원본 저장소의 제목, 예시, 코드, 표, 링크, 이미지를 유지해 표시합니다.

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:

  1. Verify the bean loads with a minimal context test:
java
   @SpringBootTest
   @ContextConfiguration(classes = UserService.class)
   class UserServiceWiringTest {
       @Autowired UserService userService;
       @Test void serviceIsInstantiated() { assertNotNull(userService); }
   }
  1. Run constructor-based unit tests for service behavior (no Spring needed).
  2. Add slice tests only when MVC, JPA, or messaging integration must be verified.
  3. Reserve `@SpringBootTest` for container-wide wiring validation.

Failures at step 1 indicate wiring issues before business logic is added.

Examples

Example 1: Constructor-first application service

java
@Service
public class UserService {

    private final UserRepository userRepository;
    private final EmailSender emailSender;

    public UserService(UserRepository userRepository, EmailSender emailSender) {
        this.userRepository = userRepository;
        this.emailSender = emailSender;
    }

    public User register(UserRegistrationRequest request) {
        User user = userRepository.save(User.from(request));
        emailSender.sendWelcome(user);
        return user;
    }
}

This class is easy to instantiate directly in a unit test with mocks.

Example 2: Optional dependency with a no-op fallback

java
@Service
public class ReportService {

    private final ReportRepository reportRepository;
    private final NotificationGateway notificationGateway;

    public ReportService(
        ReportRepository reportRepository,
        ObjectProvider<NotificationGateway> notificationGatewayProvider
    ) {
        this.reportRepository = reportRepository;
        this.notificationGateway = notificationGatewayProvider.getIfAvailable(NotificationGateway::noOp);
    }
}

This keeps optional behavior explicit without leaking null handling through the rest of the class.

Example 3: Multiple beans with clear selection

java
@Configuration
public class PaymentConfiguration {

    @Bean
    @Primary
    PaymentGateway stripeGateway() {
        return new StripePaymentGateway();
    }

    @Bean
    @Qualifier("fallbackGateway")
    PaymentGateway mockGateway() {
        return new MockPaymentGateway();
    }
}

Use @Primary for the default path and @Qualifier only where a specific variant is required.

Best Practices

  • Prefer constructor injection for mandatory dependencies.
  • Keep service constructors small; if a class needs too many collaborators, the design probably wants another abstraction.
  • Use no-op or conditional beans instead of nullable optional dependencies.
  • Keep framework-specific creation logic in configuration classes.
  • Test services without Spring first, then add container tests only where they add value.
  • Remove field injection during refactors instead of extending it.

Constraints and Warnings

  • Field injection hides dependencies and makes tests harder to write.
  • Circular dependencies are usually a design problem, not a wiring trick to solve with @Lazy.
  • Overusing qualifiers can make the codebase hard to reason about; prefer better abstractions or clearer configuration.
  • Optional collaborators still need deterministic behavior when absent.
  • Full-context tests can hide the real source of wiring failures if used too early.

References

  • references/reference.md
  • references/examples.md
  • references/spring-official-dependency-injection.md

Related Skills

  • spring-boot-crud-patterns
  • spring-boot-rest-api-standards
  • unit-test-service-layer

관련 작업

같은 저장소의 Skills

더 많은 Skills

모든 Skills
giuseppe-trisciuoglio
커뮤니티

drizzle-orm-patterns

Provides comprehensive Drizzle ORM patterns for schema definition, CRUD operations, relations, queries, transactions, and migrations. Proactively use for any Drizzle ORM development including defining database schemas, writing type-safe queries, implementing relations, managing transactions, and setting up migrations with Drizzle Kit. Supports PostgreSQL, MySQL, SQLite, MSSQL, and CockroachDB.

1시간 설치 수
3
GitHub Stars
372
업데이트
9월 10일
giuseppe-trisciuoglio
커뮤니티

tailwind-css-patterns

Provides comprehensive Tailwind CSS utility-first styling patterns including responsive design, layout utilities, flexbox, grid, spacing, typography, colors, and modern CSS best practices. Use when styling React/Vue/Svelte components, building responsive layouts, implementing design systems, or optimizing CSS workflow.

1시간 설치 수
1
GitHub Stars
372
업데이트
9월 10일
giuseppe-trisciuoglio
커뮤니티

dynamodb-toolbox-patterns

Provides TypeScript patterns for DynamoDB-Toolbox v2 including schema/table/entity modeling, .build() command workflow, query/scan access patterns, batch and transaction operations, and single-table design with computed keys. Use when implementing type-safe DynamoDB access layers with DynamoDB-Toolbox v2 in TypeScript services or serverless applications.

1시간 설치 수
1
GitHub Stars
371
업데이트
9월 10일
giuseppe-trisciuoglio
커뮤니티

typescript-security-review

Provides security review capability for TypeScript/Node.js applications, validates code against XSS, injection, CSRF, JWT/OAuth2 flaws, dependency CVEs, and secrets exposure. Use when performing security audits, before deployment, reviewing authentication/authorization implementations, or ensuring OWASP compliance for Express, NestJS, and Next.js. Triggers on "security review", "check for security issues", "TypeScript security audit".

1시간 설치 수
1
GitHub Stars
371
업데이트
9월 10일