커스텀 스타터 만들기 — 공통 기능을 라이브러리로 배포하는 방법

my-spring-boot-starter/            ← starter 모듈 (의존성만)
my-spring-boot-autoconfigure/      ← autoconfigure 모듈 (자동 설정 로직)

my-spring-boot-starter/
├── build.gradle
└── src/main/java/
│   └── com/example/starter/
│       ├── MyAutoConfiguration.java
│       ├── MyProperties.java
│       └── MyService.java
└── src/main/resources/
    └── META-INF/
        └── spring/
            └── org.springframework.boot.autoconfigure.AutoConfiguration.imports

@ConfigurationProperties(prefix = "my.logging")
@Getter
@Setter
public class MyLoggingProperties {

    /** 요청/응답 로깅 활성화 여부 */
    private boolean enabled = true;

    /** 요청 바디 로깅 여부 */
    private boolean includeRequestBody = false;

    /** 응답 바디 로깅 여부 */
    private boolean includeResponseBody = false;

    /** 로깅 제외 경로 패턴 */
    private List<String> excludePatterns = List.of(
        "/actuator/**", "/health"
    );
}

public class RequestLoggingFilter extends OncePerRequestFilter {

    private final MyLoggingProperties properties;

    public RequestLoggingFilter(MyLoggingProperties properties) {
        this.properties = properties;
    }

    @Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain filterChain) throws ServletException, IOException {

        long startTime = System.currentTimeMillis();

        // 요청 ID 생성
        String requestId = UUID.randomUUID().toString().substring(0, 8);
        MDC.put("requestId", requestId);

        try {
            log.info("[{}] {} {} 시작", requestId,
                request.getMethod(), request.getRequestURI());

            filterChain.doFilter(request, response);

            long duration = System.currentTimeMillis() - startTime;
            log.info("[{}] {} {} 완료 - {}ms, status={}",
                requestId,
                request.getMethod(),
                request.getRequestURI(),
                duration,
                response.getStatus());
        } finally {
            MDC.clear();
        }
    }

    @Override
    protected boolean shouldNotFilter(HttpServletRequest request) {
        String path = request.getRequestURI();
        return properties.getExcludePatterns().stream()
            .anyMatch(pattern ->
                new AntPathMatcher().match(pattern, path));
    }
}

@AutoConfiguration
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnProperty(
    prefix = "my.logging",
    name = "enabled",
    havingValue = "true",
    matchIfMissing = true  // 기본 활성화
)
@EnableConfigurationProperties(MyLoggingProperties.class)
public class MyLoggingAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean  // 사용자가 직접 정의하면 우선
    public RequestLoggingFilter requestLoggingFilter(
            MyLoggingProperties properties) {
        return new RequestLoggingFilter(properties);
    }

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnClass(
        name = "io.micrometer.core.instrument.MeterRegistry")
    public RequestMetricsCollector requestMetricsCollector(
            MeterRegistry registry) {
        return new RequestMetricsCollector(registry);
    }
}

# src/main/resources/META-INF/spring/
# org.springframework.boot.autoconfigure.AutoConfiguration.imports

com.example.starter.MyLoggingAutoConfiguration

plugins {
    id 'java-library'
    id 'maven-publish'
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-autoconfigure'

    // 선택적 의존성 — 없어도 동작하지만 있으면 추가 기능 제공
    compileOnly 'org.springframework.boot:spring-boot-starter-web'
    compileOnly 'io.micrometer:micrometer-core'

    // 프로퍼티 메타데이터 생성
    annotationProcessor \
        'org.springframework.boot:spring-boot-configuration-processor'
}

// 사용하는 프로젝트에서 불필요한 의존성을 끌고 오지 않도록
java {
    withSourcesJar()
    withJavadocJar()
}

{
  "groups": [
    {
      "name": "my.logging",
      "type": "com.example.starter.MyLoggingProperties",
      "sourceType": "com.example.starter.MyLoggingProperties"
    }
  ],
  "properties": [
    {
      "name": "my.logging.enabled",

      "type": "java.lang.Boolean",
      "description": "요청/응답 로깅 활성화 여부",
      "defaultValue": true
    },
    {
      "name": "my.logging.include-request-body",
      "type": "java.lang.Boolean",
      "description": "요청 바디 로깅 여부",
      "defaultValue": false
    }
  ]
}

// build.gradle
implementation 'com.example:my-logging-spring-boot-starter:1.0.0'

# application.yml — 프로퍼티 커스터마이징
my:
  logging:
    enabled: true
    include-request-body: true
    exclude-patterns:
      - /actuator/**
      - /static/**

// 사용자가 직접 필터를 정의하면 자동 설정의 필터는 무시됨
@Configuration
public class MyConfig {
    @Bean
    public RequestLoggingFilter requestLoggingFilter(
            MyLoggingProperties properties) {
        // 커스텀 구현
        return new CustomRequestLoggingFilter(properties);
    }
}

@SpringBootTest
class MyLoggingAutoConfigurationTest {

    @Autowired
    private ApplicationContext context;

    @Test
    void autoConfigurationEnabled() {
        assertThat(context.getBean(RequestLoggingFilter.class))
            .isNotNull();
    }
}

// 조건부 테스트
class ConditionalTest {

    private final ApplicationContextRunner contextRunner =
        new ApplicationContextRunner()
            .withConfiguration(AutoConfigurations.of(
                MyLoggingAutoConfiguration.class));

    @Test
    void disabledWhenPropertyFalse() {
        contextRunner
            .withPropertyValues("my.logging.enabled=false")
            .run(context -> {
                assertThat(context)
                    .doesNotHaveBean(RequestLoggingFilter.class);
            });
    }

    @Test
    void userBeanTakesPrecedence() {
        contextRunner
            .withBean(RequestLoggingFilter.class,
                () -> new CustomFilter())
            .run(context -> {
                RequestLoggingFilter filter =
                    context.getBean(RequestLoggingFilter.class);
                assertThat(filter).isInstanceOf(CustomFilter.class);
            });
    }
}