spring-boot4-skill 1.0.0

package/skills/java-spring-framework/references/build-templates.md

@@ -0,0 +1,304 @@
+# Build Templates — Spring Boot 4 / Spring Framework 7 (2026)
+
+---
+
+## Table of Contents
+1. [Gradle KTS — Full Application Template](#1-gradle-kts--full-application-template)
+2. [Maven POM — Full Application Template](#2-maven-pom--full-application-template)
+3. [Key BOM Versions (2026)](#3-key-bom-versions-2026)
+4. [Spring Initializr CLI Quick Start](#4-spring-initializr-cli-quick-start)
+
+---
+
+## 1. Gradle KTS — Full Application Template
+
+```kotlin
+// build.gradle.kts
+import org.springframework.boot.gradle.tasks.bundling.BootJar
+
+plugins {
+    java
+    id("org.springframework.boot")          version "4.0.3"
+    id("io.spring.dependency-management")   version "1.1.7"
+    id("org.graalvm.buildtools.native")     version "0.10.4"   // optional: native image
+}
+
+group   = "com.example"
+version = "0.0.1-SNAPSHOT"
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(25)
+    }
+}
+
+// Enable preview features (Structured Concurrency, Scoped Values GA in Java 25)
+tasks.withType<JavaCompile> {
+    options.compilerArgs.addAll(listOf("--enable-preview"))
+}
+
+tasks.withType<Test> {
+    jvmArgs("--enable-preview")
+    useJUnitPlatform()
+}
+
+tasks.named<BootJar>("bootJar") {
+    jvmArguments.addAll(listOf("--enable-preview"))
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencyManagement {
+    imports {
+        mavenBom("org.springframework.modulith:spring-modulith-bom:2.0.3")
+    }
+}
+
+dependencies {
+    // --- Web ---
+    implementation("org.springframework.boot:spring-boot-starter-web")
+    // implementation("org.springframework.boot:spring-boot-starter-webflux")  // reactive
+
+    // --- Data ---
+    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
+    implementation("org.springframework.boot:spring-boot-starter-jdbc")
+    runtimeOnly("org.postgresql:postgresql")
+    // runtimeOnly("com.h2database:h2")   // dev/test
+
+    // --- Validation ---
+    implementation("org.springframework.boot:spring-boot-starter-validation")
+
+    // --- Security ---
+    implementation("org.springframework.boot:spring-boot-starter-security")
+    implementation("org.springframework.boot:spring-boot-starter-oauth2-resource-server")
+
+    // --- Observability ---
+    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")
+
+    // --- Null Safety ---
+    implementation("org.jspecify:jspecify:1.0.0")
+
+    // --- Spring Modulith (optional) ---
+    implementation("org.springframework.modulith:spring-modulith-starter-core")
+    implementation("org.springframework.modulith:spring-modulith-starter-jpa")
+
+    // --- Dev Tools ---
+    developmentOnly("org.springframework.boot:spring-boot-devtools")
+    annotationProcessor("org.springframework.boot:spring-boot-configuration-processor")
+
+    // --- Testing ---
+    testImplementation("org.springframework.boot:spring-boot-starter-test")
+    testImplementation("org.springframework.security:spring-security-test")
+    testImplementation("org.springframework.modulith:spring-modulith-starter-test")
+    testImplementation("org.testcontainers:postgresql")
+    testImplementation("org.testcontainers:junit-jupiter")
+}
+```
+
+---
+
+## 2. Maven POM — Full Application Template
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
+             https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>4.0.3</version>
+        <relativePath/>
+    </parent>
+
+    <groupId>com.example</groupId>
+    <artifactId>my-app</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <packaging>jar</packaging>
+
+    <properties>
+        <java.version>25</java.version>
+        <spring-modulith.version>2.0.3</spring-modulith.version>
+        <jspecify.version>1.0.0</jspecify.version>
+    </properties>
+
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>org.springframework.modulith</groupId>
+                <artifactId>spring-modulith-bom</artifactId>
+                <version>${spring-modulith.version}</version>
+                <scope>import</scope>
+                <type>pom</type>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+    <dependencies>
+        <!-- Web -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+
+        <!-- Data -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-jpa</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.postgresql</groupId>
+            <artifactId>postgresql</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+
+        <!-- Validation -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+        </dependency>
+
+        <!-- Security -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-security</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
+        </dependency>
+
+        <!-- Observability -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-actuator</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.micrometer</groupId>
+            <artifactId>micrometer-tracing-bridge-otel</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.opentelemetry</groupId>
+            <artifactId>opentelemetry-exporter-otlp</artifactId>
+        </dependency>
+
+        <!-- Null Safety -->
+        <dependency>
+            <groupId>org.jspecify</groupId>
+            <artifactId>jspecify</artifactId>
+            <version>${jspecify.version}</version>
+        </dependency>
+
+        <!-- Spring Modulith -->
+        <dependency>
+            <groupId>org.springframework.modulith</groupId>
+            <artifactId>spring-modulith-starter-core</artifactId>
+        </dependency>
+
+        <!-- Testing -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.modulith</groupId>
+            <artifactId>spring-modulith-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>postgresql</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <compilerArgs>
+                        <arg>--enable-preview</arg>
+                    </compilerArgs>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <!-- GraalVM Native Image (optional) -->
+    <profiles>
+        <profile>
+            <id>native</id>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.graalvm.buildtools</groupId>
+                        <artifactId>native-maven-plugin</artifactId>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+    </profiles>
+</project>
+```
+
+---
+
+## 3. Key BOM Versions (2026)
+
+| Library | Version |
+|---|---|
+| Spring Boot | 4.0.3 |
+| Spring Framework | 7.0.5 |
+| Spring Modulith | 2.0.3 |
+| Spring Security | 7.x (managed by Boot) |
+| Spring Data | 4.x (managed by Boot) |
+| Hibernate ORM | 7.0 |
+| JSpecify | 1.0.0 |
+| Jackson | 3.x |
+| GraalVM Build Tools | 0.10.4 |
+| Testcontainers | 1.21.x |
+| JUnit 5 | 5.12.x |
+| Micrometer | 1.15.x |
+| io.spring.dependency-management | 1.1.7 |
+
+---
+
+## 4. Spring Initializr CLI Quick Start
+
+```bash
+# Using Spring CLI (spring init)
+spring init \
+  --boot-version=4.0.3 \
+  --java-version=25 \
+  --build=gradle-project-kotlin \
+  --dependencies=web,data-jpa,postgresql,security,actuator,validation,devtools \
+  --group-id=com.example \
+  --artifact-id=my-service \
+  --name=MyService \
+  my-service
+
+# Or via curl to start.spring.io
+curl https://start.spring.io/starter.tgz \
+  -d type=gradle-project-kotlin \
+  -d bootVersion=4.0.3 \
+  -d javaVersion=25 \
+  -d dependencies=web,data-jpa,postgresql,security,actuator,validation \
+  -d groupId=com.example \
+  -d artifactId=my-service \
+  | tar -xzvf -
+```

package/skills/java-spring-framework/references/spring-boot-4.md

@@ -0,0 +1,347 @@
+# Spring Boot 4.0.x — Feature Reference
+
+**Version**: 4.0.3 (Stable) | **Framework**: Spring 7.0.x | **Java baseline**: 17 (25 recommended)
+
+---
+
+## Table of Contents
+1. [Platform Requirements](#1-platform-requirements)
+2. [Auto-Configuration Changes](#2-auto-configuration-changes)
+3. [Testing — @SpringBootTest & Slices](#3-testing--springboottest--slices)
+4. [Actuator & Observability](#4-actuator--observability)
+5. [GraalVM Native Image](#5-graalvm-native-image)
+6. [Virtual Threads (Project Loom)](#6-virtual-threads-project-loom)
+7. [Structured Concurrency (Java 25)](#7-structured-concurrency-java-25)
+8. [Scoped Values (Java 25)](#8-scoped-values-java-25)
+9. [Docker Compose Support](#9-docker-compose-support)
+10. [Spring Security 7 Basics](#10-spring-security-7-basics)
+
+---
+
+## 1. Platform Requirements
+
+| Component | Version |
+|---|---|
+| Java (minimum) | 17 |
+| Java (recommended) | 25 |
+| GraalVM | 24+ |
+| Spring Framework | 7.0.x |
+| Jakarta EE | 11 |
+| Servlet | 6.1 |
+| JPA (Hibernate ORM) | 3.2 / 7.0 |
+| Bean Validation | 3.1 |
+| Jackson | 3.x |
+| Kotlin | 2.2 |
+
+---
+
+## 2. Auto-Configuration Changes
+
+### Functional Bean Registration (Native-Friendly)
+
+Avoid `@ComponentScan` when targeting GraalVM. Use functional registration in `ApplicationContext` initialization:
+
+```java
+@SpringBootApplication(proxyBeanMethods = false)
+public class Application {
+
+    public static void main(String[] args) {
+        new SpringApplicationBuilder(Application.class)
+            .initializers(ctx -> {
+                ctx.registerBean(UserService.class, UserServiceImpl::new);
+                ctx.registerBean(UserRepository.class, UserRepositoryImpl::new);
+            })
+            .run(args);
+    }
+}
+```
+
+### Condition-Based Auto-Configuration
+
+```java
+@AutoConfiguration
+@ConditionalOnClass(DataSource.class)
+@ConditionalOnMissingBean(JdbcClient.class)
+public class JdbcClientAutoConfiguration {
+
+    @Bean
+    JdbcClient jdbcClient(DataSource dataSource) {
+        return JdbcClient.create(dataSource);
+    }
+}
+```
+
+---
+
+## 3. Testing — @SpringBootTest & Slices
+
+### Full Context Test
+
+```java
+@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
+class ApplicationIntegrationTest {
+
+    @Autowired RestTestClient client;
+
+    @Test
+    void healthEndpointIsUp() {
+        client.get().uri("/actuator/health")
+              .exchange().expectStatus().isOk();
+    }
+}
+```
+
+### Web Layer Slice
+
+```java
+@WebMvcTest(ProductController.class)
+class ProductControllerTest {
+
+    @Autowired MockMvc mvc;
+    @MockitoBean ProductService productService;
+
+    @Test
+    void shouldReturn200() throws Exception {
+        given(productService.findAll()).willReturn(List.of(new Product(1L, "Widget")));
+        mvc.perform(get("/api/products"))
+           .andExpect(status().isOk())
+           .andExpect(jsonPath("$[0].name").value("Widget"));
+    }
+}
+```
+
+### Data Layer Slice
+
+```java
+@DataJpaTest
+class UserRepositoryTest {
+
+    @Autowired UserRepository repository;
+
+    @Test
+    void shouldPersistUser() {
+        User saved = repository.save(new User("Alice", "alice@example.com"));
+        assertThat(saved.id()).isNotNull();
+    }
+}
+```
+
+---
+
+## 4. Actuator & Observability
+
+Spring Boot 4 ships first-class **Micrometer Tracing + OpenTelemetry** support.
+
+```yaml
+# application.yaml
+management:
+  endpoints:
+    web:
+      exposure:
+        include: health,info,metrics,prometheus,traces
+  tracing:
+    sampling:
+      probability: 1.0
+  otlp:
+    metrics:
+      export:
+        url: http://otel-collector:4318/v1/metrics
+    tracing:
+      endpoint: http://otel-collector:4318/v1/traces
+```
+
+```kotlin
+// build.gradle.kts
+implementation("io.micrometer:micrometer-tracing-bridge-otel")
+implementation("io.opentelemetry:opentelemetry-exporter-otlp")
+```
+
+Custom span:
+
+```java
+@Service
+public class OrderService {
+
+    private final Tracer tracer;
+
+    @Observed(name = "order.process", contextualName = "Processing order")
+    public Order process(OrderRequest request) {
+        Span span = tracer.nextSpan().name("validate").start();
+        try (Tracer.SpanInScope ws = tracer.withSpan(span)) {
+            validate(request);
+        } finally {
+            span.end();
+        }
+        return persist(request);
+    }
+}
+```
+
+---
+
+## 5. GraalVM Native Image
+
+```kotlin
+// build.gradle.kts
+plugins {
+    id("org.graalvm.buildtools.native") version "0.10.4"
+}
+
+graalvmNative {
+    binaries {
+        named("main") {
+            imageName.set("app")
+            buildArgs.add("--enable-preview")
+        }
+    }
+}
+```
+
+Build native image:
+
+```bash
+./gradlew nativeCompile
+./build/native/nativeCompile/app
+```
+
+**AOT hints** when reflection is unavoidable:
+
+```java
+@RegisterReflectionForBinding(MyDto.class)
+@Configuration(proxyBeanMethods = false)
+public class NativeHintsConfig {}
+```
+
+---
+
+## 6. Virtual Threads (Project Loom)
+
+Enable via single property — no code changes needed for existing Spring MVC apps:
+
+```yaml
+# application.yaml
+spring:
+  threads:
+    virtual:
+      enabled: true
+```
+
+Programmatic usage:
+
+```java
+try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
+    executor.submit(() -> callExternalService());
+}
+```
+
+---
+
+## 7. Structured Concurrency (Java 25)
+
+Use `StructuredTaskScope` for fan-out patterns with lifecycle guarantees.
+
+```java
+import java.util.concurrent.StructuredTaskScope;
+
+@Service
+public class DashboardService {
+
+    public Dashboard loadDashboard(String userId) throws Exception {
+        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
+
+            var orders   = scope.fork(() -> orderService.findByUser(userId));
+            var profile  = scope.fork(() -> profileService.find(userId));
+            var payments = scope.fork(() -> paymentService.findByUser(userId));
+
+            scope.join().throwIfFailed();
+
+            return new Dashboard(profile.get(), orders.get(), payments.get());
+        }
+    }
+}
+```
+
+---
+
+## 8. Scoped Values (Java 25)
+
+`ScopedValue` replaces `ThreadLocal` for context propagation in virtual threads.
+
+```java
+public final class RequestContext {
+    public static final ScopedValue<String> TENANT_ID = ScopedValue.newInstance();
+    public static final ScopedValue<User>   CURRENT_USER = ScopedValue.newInstance();
+}
+
+// Set in a filter
+ScopedValue.where(RequestContext.TENANT_ID, tenantId)
+           .where(RequestContext.CURRENT_USER, user)
+           .run(() -> filterChain.doFilter(request, response));
+
+// Read anywhere in the call stack
+String tenant = RequestContext.TENANT_ID.get();
+```
+
+---
+
+## 9. Docker Compose Support
+
+Spring Boot 4 auto-detects `compose.yaml` and starts services before the application.
+
+```yaml
+# compose.yaml
+services:
+  postgres:
+    image: postgres:17
+    environment:
+      POSTGRES_DB: appdb
+      POSTGRES_USER: app
+      POSTGRES_PASSWORD: secret
+    ports: ["5432:5432"]
+  redis:
+    image: redis:8
+    ports: ["6379:6379"]
+```
+
+```yaml
+# application.yaml
+spring:
+  docker:
+    compose:
+      enabled: true
+      lifecycle-management: start-and-stop
+```
+
+No manual connection properties needed — Boot auto-configures `DataSource` and `RedisTemplate`.
+
+---
+
+## 10. Spring Security 7 Basics
+
+Lambda DSL is the only supported style in Spring Security 7.
+
+```java
+@Configuration
+@EnableWebSecurity
+public class SecurityConfig {
+
+    @Bean
+    SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+        return http
+            .authorizeHttpRequests(auth -> auth
+                .requestMatchers("/api/public/**").permitAll()
+                .requestMatchers("/api/admin/**").hasRole("ADMIN")
+                .anyRequest().authenticated())
+            .oauth2ResourceServer(oauth2 -> oauth2
+                .jwt(jwt -> jwt.decoder(jwtDecoder())))
+            .sessionManagement(session -> session
+                .sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+            .build();
+    }
+
+    @Bean
+    JwtDecoder jwtDecoder() {
+        return NimbusJwtDecoder.withJwkSetUri("https://auth.example.com/.well-known/jwks.json").build();
+    }
+}
+```