Spring Boot 3.x Complete Guide 2025: Virtual Threads, GraalVM Native, Spring AI

// Before: Spring Boot 2.x
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.validation.constraints.NotNull;

// After: Spring Boot 3.x
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.validation.constraints.NotNull;

# build.gradle
plugins {
    id("org.openrewrite.rewrite") version "6.24.0"
}

rewrite {
    activeRecipe("org.openrewrite.java.spring.boot3.UpgradeSpringBoot_3_3")
}

# Execute migration
./gradlew rewriteRun

// Java 21 features you can use with Spring Boot 3.x

// 1. Record Patterns
public ResponseEntity<?> processPayment(Object payment) {
    return switch (payment) {
        case CreditCardPayment(var card, var amount)
            -> processCard(card, amount);
        case BankTransfer(var account, var amount)
            -> processTransfer(account, amount);
        default -> ResponseEntity.badRequest().build();
    };
}

// 2. Sealed Interfaces for domain modeling
public sealed interface PaymentResult
    permits PaymentSuccess, PaymentFailure, PaymentPending {
}
public record PaymentSuccess(String transactionId) implements PaymentResult {}
public record PaymentFailure(String reason) implements PaymentResult {}
public record PaymentPending(String retryAfter) implements PaymentResult {}

my-app/
  app-api/           # REST controllers, DTOs
  app-domain/        # Entities, repositories, services
  app-infra/         # External integrations, configs
  app-common/        # Shared utilities
  build.gradle       # Root build configuration

// Platform Thread: 1:1 mapping to OS thread, ~1MB stack each
// 10,000 concurrent threads -> 10GB memory

// Virtual Thread: JVM-managed, ~1KB stack each
// 1,000,000 concurrent threads -> ~1GB memory

// Creating Virtual Threads
Thread.ofVirtual().start(() -> {
    System.out.println("Running on: " + Thread.currentThread());
});

// Executor for Virtual Threads
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 100_000).forEach(i ->
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return i;
        })
    );
}

# application.yml
spring:
  threads:
    virtual:
      enabled: true

@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
class VirtualThreadBenchmarkTest {

    @Autowired
    TestRestTemplate restTemplate;

    @Test
    void benchmark10kConcurrentRequests() throws Exception {
        int concurrency = 10_000;
        CountDownLatch latch = new CountDownLatch(concurrency);
        AtomicInteger success = new AtomicInteger(0);

        long start = System.nanoTime();

        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 0; i < concurrency; i++) {
                executor.submit(() -> {
                    try {
                        ResponseEntity<String> response =
                            restTemplate.getForEntity("/api/slow-endpoint", String.class);
                        if (response.getStatusCode().is2xxSuccessful()) {
                            success.incrementAndGet();
                        }
                    } finally {
                        latch.countDown();
                    }
                });
            }
            latch.await(60, TimeUnit.SECONDS);
        }

        long elapsed = Duration.ofNanos(System.nanoTime() - start).toMillis();
        System.out.printf("10K requests: %dms, success: %d%n", elapsed, success.get());
        // Virtual Threads: ~2,500ms with 100ms DB calls
        // Platform Threads (200 pool): ~50,000ms
    }
}

// === Reactive approach (WebFlux) ===
@GetMapping("/users-reactive")
public Mono<List<User>> getUsersReactive() {
    return webClient.get()
        .uri("/api/users")
        .retrieve()
        .bodyToFlux(User.class)
        .collectList()
        .flatMap(users ->
            externalService.enrich(users)
                .map(enriched -> enriched)
        );
}

// === Virtual Thread approach (synchronous code, async performance) ===
@GetMapping("/users-virtual")
public List<User> getUsersVirtual() {
    List<User> users = restClient.get()
        .uri("/api/users")
        .retrieve()
        .body(new ParameterizedTypeReference<>() {});

    return externalService.enrich(users); // Blocking is fine!
}

// 1. NEVER use synchronized -> use ReentrantLock
// Bad: Virtual Thread gets pinned to carrier thread
public synchronized void updateCounter() {
    counter++;
}

// Good: ReentrantLock allows yielding
private final ReentrantLock lock = new ReentrantLock();
public void updateCounter() {
    lock.lock();
    try {
        counter++;
    } finally {
        lock.unlock();
    }
}

// 2. Minimize ThreadLocal usage
// Virtual Threads can number in millions
// ThreadLocal abuse causes memory explosion
// -> Use ScopedValue (Preview) instead

// 3. CPU-bound tasks still benefit from Platform Threads
@Bean
TaskExecutor cpuIntensiveExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(Runtime.getRuntime().availableProcessors());
    executor.setMaxPoolSize(Runtime.getRuntime().availableProcessors() * 2);
    return executor;
}

// 4. Detect pinning with JVM flag
// -Djdk.tracePinnedThreads=short

// build.gradle
plugins {
    id 'org.graalvm.buildtools.native' version '0.10.3'
}

graalvmNative {
    binaries {
        main {
            imageName = 'my-app'
            mainClass = 'com.example.MyApplication'
            buildArgs.addAll(
                '--no-fallback',
                '-H:+ReportExceptionStackTraces',
                '--enable-url-protocols=http,https'
            )
        }
    }
}

# Build native image
./gradlew nativeCompile

# Run
./build/native/nativeCompile/my-app
# Started in 0.087 seconds!

@Configuration
@ImportRuntimeHints(AppRuntimeHints.class)
public class NativeImageConfig {
}

public class AppRuntimeHints implements RuntimeHintsRegistrar {

    @Override
    public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
        // Register types for reflection
        hints.reflection()
            .registerType(UserDto.class, MemberCategory.values())
            .registerType(OrderDto.class, MemberCategory.values());

        // Register resources
        hints.resources()
            .registerPattern("templates/*")
            .registerPattern("static/**")
            .registerPattern("messages/*.properties");

        // Register JDK proxies
        hints.proxies()
            .registerJdkProxy(MyRepository.class);

        // Register serialization
        hints.serialization()
            .registerType(MyEvent.class);
    }
}

// Simpler alternative: annotation-based
@RegisterReflectionForBinding({UserDto.class, OrderDto.class})
@Configuration
public class ReflectionConfig {
}

# Stage 1: Build native image
FROM ghcr.io/graalvm/native-image-community:21 AS builder
WORKDIR /app
COPY . .
RUN ./gradlew nativeCompile --no-daemon

# Stage 2: Minimal runtime
FROM debian:bookworm-slim
RUN addgroup --system spring && adduser --system --ingroup spring spring
USER spring:spring
COPY --from=builder /app/build/native/nativeCompile/my-app /app
EXPOSE 8080
ENTRYPOINT ["/app"]

docker build -t my-app:native .
docker run -p 8080:8080 my-app:native
# Started in 0.071 seconds, 42MB RSS

// Issue: Dynamic class loading won't work
// Solution: Register at build time

// Issue: Reflection-heavy libraries (Jackson, Hibernate)
// Solution: Spring AOT auto-generates most hints

// Issue: Build time is long (5-10 minutes)
// Solution: Use JVM mode for dev, Native for production
// Use Cloud Native Buildpacks for CI/CD:
// ./gradlew bootBuildImage --imageName=my-app:native

dependencies {
    // Choose your provider
    implementation 'org.springframework.ai:spring-ai-openai-spring-boot-starter'
    // implementation 'org.springframework.ai:spring-ai-anthropic-spring-boot-starter'
    // implementation 'org.springframework.ai:spring-ai-ollama-spring-boot-starter'

    // Vector Store for RAG
    implementation 'org.springframework.ai:spring-ai-pgvector-store-spring-boot-starter'
}

# application.yml
spring:
  ai:
    openai:
      api-key: your-api-key-here
      chat:
        options:
          model: gpt-4o
          temperature: 0.7

@RestController
@RequiredArgsConstructor
public class AiController {

    private final ChatClient.Builder chatClientBuilder;

    // Simple chat
    @GetMapping("/ai/chat")
    public String chat(@RequestParam String message) {
        return chatClientBuilder.build()
            .prompt()
            .user(message)
            .call()
            .content();
    }

    // Streaming response
    @GetMapping(value = "/ai/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public Flux<String> chatStream(@RequestParam String message) {
        return chatClientBuilder.build()
            .prompt()
            .user(message)
            .stream()
            .content();
    }

    // Structured output
    @GetMapping("/ai/analyze")
    public SentimentResult analyzeSentiment(@RequestParam String text) {
        return chatClientBuilder.build()
            .prompt()
            .user("Analyze the sentiment of this text: " + text)
            .call()
            .entity(SentimentResult.class);
    }
}

record SentimentResult(String sentiment, double confidence, String explanation) {}

@Service
@RequiredArgsConstructor
public class RagService {

    private final ChatClient.Builder chatClientBuilder;
    private final VectorStore vectorStore;

    // Ingest documents into vector store
    public void ingestDocuments(List<Document> documents) {
        vectorStore.add(documents);
    }

    // Query with RAG context
    public String queryWithContext(String question) {
        // 1. Similarity search for relevant documents
        List<Document> relevantDocs = vectorStore.similaritySearch(
            SearchRequest.query(question).withTopK(5)
        );

        // 2. Build context from results
        String context = relevantDocs.stream()
            .map(Document::getContent)
            .collect(Collectors.joining("\n\n"));

        // 3. Query LLM with context
        return chatClientBuilder.build()
            .prompt()
            .system(s -> s.text("""
                You are a helpful assistant. Answer based on the provided context.
                If the answer is not in the context, say you don't know.

                Context:
                {context}
                """).param("context", context))
            .user(question)
            .call()
            .content();
    }
}

@Configuration
public class AiFunctionConfig {

    @Bean
    @Description("Get current weather for a given city")
    public Function<WeatherRequest, WeatherResponse> currentWeather() {
        return request -> {
            // Call actual weather API
            return new WeatherResponse(request.city(), 25.0, "Sunny");
        };
    }

    @Bean
    @Description("Search products in the catalog")
    public Function<ProductSearchRequest, List<Product>> searchProducts(
            ProductRepository productRepository) {
        return request -> productRepository
            .findByNameContaining(request.query());
    }
}

record WeatherRequest(String city) {}
record WeatherResponse(String city, double temperature, String condition) {}
record ProductSearchRequest(String query) {}

// Usage: LLM automatically calls registered functions
@GetMapping("/ai/assistant")
public String assistant(@RequestParam String question) {
    return chatClientBuilder.build()
        .prompt()
        .user(question) // "What's the weather in Seoul?"
        .functions("currentWeather", "searchProducts")
        .call()
        .content();
}

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(csrf -> csrf
                .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse())
            )
            .cors(cors -> cors.configurationSource(corsConfigurationSource()))
            .sessionManagement(session -> session
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            )
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/public/**").permitAll()
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .requestMatchers(HttpMethod.GET, "/api/posts/**").permitAll()
                .requestMatchers(HttpMethod.POST, "/api/posts/**").authenticated()
                .anyRequest().authenticated()
            )
            .oauth2ResourceServer(oauth2 -> oauth2
                .jwt(jwt -> jwt.jwtDecoder(jwtDecoder()))
            )
            .exceptionHandling(ex -> ex
                .authenticationEntryPoint(
                    new HttpStatusEntryPoint(HttpStatus.UNAUTHORIZED))
            )
            .build();
    }

    @Bean
    public JwtDecoder jwtDecoder() {
        return NimbusJwtDecoder
            .withJwkSetUri("https://auth.example.com/.well-known/jwks.json")
            .build();
    }
}

@Configuration
@EnableMethodSecurity // replaces @EnableGlobalMethodSecurity
public class MethodSecurityConfig {}

@Service
public class PostService {

    @PreAuthorize("hasRole('ADMIN') or #authorId == authentication.principal.id")
    public void deletePost(Long postId, Long authorId) {
        // Only admin or the author can delete
    }

    @PostAuthorize("returnObject.author.id == authentication.principal.id")
    public Post getMyPost(Long postId) {
        return postRepository.findById(postId).orElseThrow();
    }
}

@Bean
@Profile("prod")
public SecurityFilterChain productionSecurity(HttpSecurity http) throws Exception {
    return http
        .headers(headers -> headers
            .contentSecurityPolicy(csp -> csp
                .policyDirectives("default-src 'self'; script-src 'self'"))
            .frameOptions(frame -> frame.deny())
            .httpStrictTransportSecurity(hsts -> hsts
                .includeSubDomains(true)
                .maxAgeInSeconds(31536000))
            .permissionsPolicy(pp -> pp
                .policy("camera=(), microphone=(), geolocation=()"))
        )
        .build();
}

@Entity
@Table(name = "posts")
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class Post {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, length = 200)
    private String title;

    @Column(columnDefinition = "TEXT")
    private String content;

    @Enumerated(EnumType.STRING)
    private PostStatus status;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "author_id")
    private User author;

    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Comment> comments = new ArrayList<>();

    @CreatedDate
    private LocalDateTime createdAt;

    @LastModifiedDate
    private LocalDateTime updatedAt;

    // Business method
    public void publish() {
        if (this.status != PostStatus.DRAFT) {
            throw new IllegalStateException("Only draft posts can be published");
        }
        this.status = PostStatus.PUBLISHED;
    }
}

public interface PostRepository extends JpaRepository<Post, Long> {

    // Solution 1: EntityGraph
    @EntityGraph(attributePaths = {"author", "comments"})
    List<Post> findByStatus(PostStatus status);

    // Solution 2: Fetch Join
    @Query("SELECT DISTINCT p FROM Post p JOIN FETCH p.author WHERE p.status = :status")
    List<Post> findByStatusWithAuthor(@Param("status") PostStatus status);

    // Solution 3: Batch Size (global in application.yml)
    // spring.jpa.properties.hibernate.default_batch_fetch_size: 100
}

@Repository
@RequiredArgsConstructor
public class PostQueryRepository {

    private final JPAQueryFactory queryFactory;

    public Page<PostDto> searchPosts(PostSearchCondition condition, Pageable pageable) {
        QPost post = QPost.post;
        QUser user = QUser.user;

        List<PostDto> content = queryFactory
            .select(Projections.constructor(PostDto.class,
                post.id, post.title, post.status,
                user.name, post.createdAt))
            .from(post)
            .join(post.author, user)
            .where(
                titleContains(condition.title()),
                statusEquals(condition.status()),
                createdAfter(condition.fromDate())
            )
            .orderBy(post.createdAt.desc())
            .offset(pageable.getOffset())
            .limit(pageable.getPageSize())
            .fetch();

        Long total = queryFactory
            .select(post.count())
            .from(post)
            .where(
                titleContains(condition.title()),
                statusEquals(condition.status()),
                createdAfter(condition.fromDate())
            )
            .fetchOne();

        return new PageImpl<>(content, pageable, total != null ? total : 0);
    }

    private BooleanExpression titleContains(String title) {
        return title != null ? QPost.post.title.contains(title) : null;
    }

    private BooleanExpression statusEquals(PostStatus status) {
        return status != null ? QPost.post.status.eq(status) : null;
    }

    private BooleanExpression createdAfter(LocalDateTime from) {
        return from != null ? QPost.post.createdAt.after(from) : null;
    }
}

public interface PostR2dbcRepository extends ReactiveCrudRepository<Post, Long> {

    Flux<Post> findByStatus(PostStatus status);

    @Query("SELECT * FROM posts WHERE title LIKE :keyword ORDER BY created_at DESC LIMIT :limit")
    Flux<Post> searchByTitle(String keyword, int limit);
}

@SpringBootTest
@Testcontainers
class PostServiceIntegrationTest {

    @Container
    @ServiceConnection
    static PostgreSQLContainer<?> postgres =
        new PostgreSQLContainer<>("postgres:16-alpine");

    @Container
    @ServiceConnection
    static GenericContainer<?> redis =
        new GenericContainer<>("redis:7-alpine")
            .withExposedPorts(6379);

    @Autowired
    private PostService postService;

    @Test
    void shouldCreateAndRetrievePost() {
        CreatePostRequest request = new CreatePostRequest("Title", "Content");
        Post created = postService.createPost(request);

        Post found = postService.getPost(created.getId());
        assertThat(found.getTitle()).isEqualTo("Title");
        assertThat(found.getStatus()).isEqualTo(PostStatus.DRAFT);
    }
}

@TestConfiguration(proxyBeanMethods = false)
public class TestcontainersConfig {

    @Bean
    @ServiceConnection
    PostgreSQLContainer<?> postgresContainer() {
        return new PostgreSQLContainer<>("postgres:16-alpine")
            .withReuse(true);
    }

    @Bean
    @ServiceConnection(name = "redis")
    GenericContainer<?> redisContainer() {
        return new GenericContainer<>("redis:7-alpine")
            .withExposedPorts(6379)
            .withReuse(true);
    }
}

// Run as development server with test containers
public class TestMyApplication {
    public static void main(String[] args) {
        SpringApplication.from(MyApplication::main)
            .with(TestcontainersConfig.class)
            .run(args);
    }
}

@SpringBootTest
@Testcontainers
class KafkaIntegrationTest {

    @Container
    @ServiceConnection
    static KafkaContainer kafka = new KafkaContainer(
        DockerImageName.parse("confluentinc/cp-kafka:7.6.0")
    );

    @Autowired
    private KafkaTemplate<String, OrderEvent> kafkaTemplate;

    @Test
    void shouldProcessOrderEvent() throws Exception {
        OrderEvent event = new OrderEvent("order-123", "CREATED", BigDecimal.valueOf(99.99));

        kafkaTemplate.send("orders", event).get();

        await().atMost(Duration.ofSeconds(10))
            .untilAsserted(() ->
                assertThat(consumer.getProcessedOrders())
                    .hasSize(1)
                    .first()
                    .extracting(OrderEvent::orderId)
                    .isEqualTo("order-123")
            );
    }
}

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
  metrics:
    distribution:
      percentiles-histogram:
        http.server.requests: true
    tags:
      application: my-spring-app
  tracing:
    sampling:
      probability: 1.0
  otlp:
    metrics:
      export:
        url: http://otel-collector:4318/v1/metrics
    tracing:
      endpoint: http://otel-collector:4318/v1/traces

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
    implementation 'io.micrometer:micrometer-tracing-bridge-otel'
    implementation 'io.opentelemetry:opentelemetry-exporter-otlp'
    runtimeOnly 'io.micrometer:micrometer-registry-prometheus'
}

@Service
public class OrderService {

    private final Counter orderCounter;
    private final Timer orderProcessingTimer;
    private final MeterRegistry meterRegistry;

    public OrderService(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.orderCounter = Counter.builder("orders.created")
            .description("Total orders created")
            .register(meterRegistry);
        this.orderProcessingTimer = Timer.builder("orders.processing.time")
            .description("Order processing duration")
            .register(meterRegistry);
    }

    public Order createOrder(CreateOrderRequest request) {
        return orderProcessingTimer.record(() -> {
            Order order = processOrder(request);
            orderCounter.increment();
            meterRegistry.gauge("orders.pending",
                orderRepository.countByStatus(OrderStatus.PENDING));
            return order;
        });
    }
}

@RestController
@RequiredArgsConstructor
public class OrderController {

    private final OrderService orderService;
    private final ObservationRegistry observationRegistry;

    @PostMapping("/api/orders")
    public ResponseEntity<Order> createOrder(@RequestBody CreateOrderRequest request) {
        return Observation.createNotStarted("order.creation", observationRegistry)
            .lowCardinalityKeyValue("order.type", request.type())
            .observe(() -> {
                Order order = orderService.createOrder(request);
                return ResponseEntity.created(
                    URI.create("/api/orders/" + order.getId())
                ).body(order);
            });
    }
}

# docker-compose-observability.yml
services:
  otel-collector:
    image: otel/opentelemetry-collector-contrib:latest
    ports:
      - "4317:4317"
      - "4318:4318"
    volumes:
      - ./otel-config.yaml:/etc/otelcol-contrib/config.yaml

  prometheus:
    image: prom/prometheus:latest
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin

  tempo:
    image: grafana/tempo:latest
    ports:
      - "3200:3200"
    command: [ "-config.file=/etc/tempo.yaml" ]

# Use layered JAR for optimal Docker caching
FROM eclipse-temurin:21-jre-alpine AS builder
WORKDIR /app
COPY build/libs/*.jar app.jar
RUN java -Djarmode=layertools -jar app.jar extract

FROM eclipse-temurin:21-jre-alpine
WORKDIR /app
RUN addgroup -S spring && adduser -S spring -G spring
USER spring:spring

COPY --from=builder /app/dependencies/ ./
COPY --from=builder /app/spring-boot-loader/ ./
COPY --from=builder /app/snapshot-dependencies/ ./
COPY --from=builder /app/application/ ./

EXPOSE 8080
ENTRYPOINT ["java", "org.springframework.boot.loader.launch.JarLauncher"]

# No Dockerfile needed!
./gradlew bootBuildImage --imageName=myregistry/my-app:latest

# For native image
./gradlew bootBuildImage \
  --imageName=myregistry/my-app:native \
  --builder=paketobuildpacks/builder-jammy-tiny

apiVersion: apps/v1
kind: Deployment
metadata:
  name: spring-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: spring-app
  template:
    metadata:
      labels:
        app: spring-app
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "8080"
        prometheus.io/path: "/actuator/prometheus"
    spec:
      containers:
        - name: spring-app
          image: myregistry/spring-app:latest
          ports:
            - containerPort: 8080
          env:
            - name: SPRING_PROFILES_ACTIVE
              value: "prod"
            - name: JAVA_OPTS
              value: "-XX:MaxRAMPercentage=75.0 -XX:+UseZGC"
          resources:
            requests:
              memory: "256Mi"
              cpu: "250m"
            limits:
              memory: "512Mi"
              cpu: "1000m"
          readinessProbe:
            httpGet:
              path: /actuator/health/readiness
              port: 8080
            initialDelaySeconds: 10
            periodSeconds: 5
          livenessProbe:
            httpGet:
              path: /actuator/health/liveness
              port: 8080
            initialDelaySeconds: 30
            periodSeconds: 10
          startupProbe:
            httpGet:
              path: /actuator/health
              port: 8080
            failureThreshold: 30
            periodSeconds: 2
---
apiVersion: v1
kind: Service
metadata:
  name: spring-app-service
spec:
  selector:
    app: spring-app
  ports:
    - port: 80
      targetPort: 8080
  type: ClusterIP
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: spring-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: spring-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70

# application-prod.yml
server:
  shutdown: graceful

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

@Component
@Slf4j
public class GracefulShutdownHandler {

    @PreDestroy
    public void onShutdown() {
        log.info("Shutting down gracefully...");
        // Finish in-flight requests
        // Close connection pools
        // Flush metrics
    }
}

spring:
  datasource:
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      connection-timeout: 3000
      idle-timeout: 600000
      max-lifetime: 1800000
  jpa:
    open-in-view: false
    hibernate:
      ddl-auto: none
    properties:
      hibernate:
        default_batch_fetch_size: 100
        jdbc.batch_size: 50
        order_inserts: true
        order_updates: true
  threads:
    virtual:
      enabled: true

server:
  shutdown: graceful
  tomcat:
    max-connections: 10000
    accept-count: 200
    connection-timeout: 5s

logging:
  level:
    root: WARN
    com.myapp: INFO
  pattern:
    console: "%d [%thread] %-5level %logger - traceId=%X{traceId} - %msg%n"