Spring Boot Internals

@SpringBootApplication(
    scanBasePackages = "com.acme",
    exclude = { DataSourceAutoConfiguration.class }
)
public class OrderApplication {
  public static void main(String[] args) {
    SpringApplication.run(OrderApplication.class, args);
  }
}

// Same as:
@Configuration
@EnableAutoConfiguration(exclude = DataSourceAutoConfiguration.class)
@ComponentScan("com.acme")
class OrderApplicationExplicit {}

org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration
# ... ~130+ entries in spring-boot-autoconfigure.jar

@AutoConfiguration
@ConditionalOnClass(DataSource.class)
@ConditionalOnProperty(name = "spring.datasource.url")
@EnableConfigurationProperties(DataSourceProperties.class)
public class DataSourceAutoConfiguration {

  @Bean
  @ConditionalOnMissingBean
  DataSource dataSource(DataSourceProperties properties) {
    return properties.initializeDataSourceBuilder().build();
  }
}

@AutoConfiguration
@ConditionalOnClass(NotificationClient.class)
@EnableConfigurationProperties(NotificationProperties.class)
public class NotificationAutoConfiguration {

  @Bean
  @ConditionalOnMissingBean
  NotificationClient notificationClient(NotificationProperties props) {
    return new NotificationClient(props.getApiKey(), props.getBaseUrl());
  }
}

@ConfigurationProperties(prefix = "acme.notification")
record NotificationProperties(
    @NotBlank String apiKey,
    @NotBlank String baseUrl
) {}

com.acme.autoconfigure.NotificationAutoConfiguration

acme:
  notification:
    api-key: ${NOTIFICATION_API_KEY}
    base-url: https://notify.acme.internal

@Component
@Order(1)
class CacheWarmupRunner implements ApplicationRunner {
  private final CacheManager cacheManager;

  CacheWarmupRunner(CacheManager cacheManager) {
    this.cacheManager = cacheManager;
  }

  @Override
  public void run(ApplicationArguments args) {
    cacheManager.getCache("rates").put("USD", loadRates());
  }
}

@Component
class ReadinessHook {
  @EventListener(ApplicationReadyEvent.class)
  void onReady() {
    log.info("Accepting traffic");
  }
}

server.port=8080
spring.application.name=order-service
spring.datasource.url=jdbc:postgresql://localhost:5432/orders
spring.datasource.username=${DB_USER:postgres}
management.endpoints.web.exposure.include=health,info,prometheus

server:
  port: 8080
spring:
  application:
    name: order-service
  datasource:
    url: jdbc:postgresql://localhost:5432/orders
    username: ${DB_USER:postgres}
management:
  endpoints:
    web:
      exposure:
        include: health,info,prometheus

spring:
  datasource:
    url: ${DATABASE_URL}
logging:
  level:
    root: WARN
    com.acme: INFO

@Service
class PricingService {
  @Value("${pricing.markup:1.15}")
  private BigDecimal markup;

  @Value("#{${pricing.tiers}}")
  private List<Integer> tiers;

  @Value("${pricing.enabled:true}")
  private boolean enabled;
}

@ConfigurationProperties(prefix = "pricing")
@Validated
record PricingProperties(
    @NotNull @Positive BigDecimal markup,
    @NotEmpty List<Integer> tiers,
    boolean enabled
) {}

@Configuration
@EnableConfigurationProperties(PricingProperties.class)
class PricingConfig {}

@Service
class PricingService {
  private final PricingProperties props;
  PricingService(PricingProperties props) { this.props = props; }
}

@SpringBootApplication
@ConfigurationPropertiesScan("com.acme.config")
public class OrderApplication {}

spring:
  application:
    name: order-service
  config:
    import: optional:configserver:https://config.internal:8888
  cloud:
    config:
      fail-fast: true

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus,env,beans,conditions,loggers
      base-path: /actuator
  endpoint:
    health:
      show-details: when_authorized
      probes:
        enabled: true

@Component
class PaymentGatewayHealthIndicator implements HealthIndicator {
  private final PaymentGatewayClient client;

  PaymentGatewayHealthIndicator(PaymentGatewayClient client) {
    this.client = client;
  }

  @Override
  public Health health() {
    try {
      client.ping();
      return Health.up().withDetail("provider", "stripe").build();
    } catch (Exception ex) {
      return Health.down(ex).withDetail("provider", "stripe").build();
    }
  }
}

@Service
class OrderMetrics {
  private final Counter ordersCreated;
  private final Timer checkoutTimer;

  OrderMetrics(MeterRegistry registry) {
    this.ordersCreated = registry.counter("orders.created", "channel", "web");
    this.checkoutTimer = registry.timer("orders.checkout.duration");
  }

  void recordOrder() {
    ordersCreated.increment();
  }

  void timeCheckout(Runnable checkout) {
    checkoutTimer.record(checkout);
  }
}

@Timed(value = "payment.charge", percentiles = {0.5, 0.95, 0.99})
@Counted("payment.charge.calls")
public PaymentResult charge(PaymentRequest request) {
  return gateway.charge(request);
}

@Bean
SecurityFilterChain actuatorSecurity(HttpSecurity http) throws Exception {
  return http
      .securityMatcher(EndpointRequest.toAnyEndpoint())
      .authorizeHttpRequests(auth -> auth
          .requestMatchers(EndpointRequest.to("health", "info")).permitAll()
          .requestMatchers(EndpointRequest.toAnyEndpoint()).hasRole("OPS")
      )
      .httpBasic(Customizer.withDefaults())
      .build();
}

@Bean
@Order(2)
SecurityFilterChain appSecurity(HttpSecurity http) throws Exception {
  return http
      .authorizeHttpRequests(auth -> auth.anyRequest().authenticated())
      .oauth2ResourceServer(oauth2 -> oauth2.jwt(Customizer.withDefaults()))
      .build();
}

management.server.port=8081
management.server.address=127.0.0.1

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <exclusions>
    <exclusion>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
    </exclusion>
  </exclusions>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

@Bean
WebServerFactoryCustomizer<TomcatServletWebServerFactory> tomcatCustomizer() {
  return factory -> {
    factory.addConnectorCustomizers(connector -> {
      connector.setProperty("relaxedQueryChars", "|{}[]");
    });
    factory.addContextCustomizers(context ->
        context.addMimeMapping("json", "application/json")
    );
  };
}

server:
  shutdown: graceful
spring:
  lifecycle:
    timeout-per-shutdown-phase: 30s

server:
  port: 8443
  ssl:
    enabled: true
    key-store: classpath:keystore.p12
    key-store-password: ${KEYSTORE_PASSWORD}
    key-store-type: PKCS12
  http2:
    enabled: true