Spring Framework — Admin & Architecture Guide

Internals, module map, deployment topology, configuration reference, security posture, and operations playbook for the Spring Framework codebase. Audience: developers, architects, contributors, and operators who need to understand what Spring is doing under the hood, how to operate Spring-based applications safely, and how to navigate the source tree.

1. Executive Summary

Spring Framework is a multi-module, layered, reflection-and-AOP-driven JVM platform that provides Inversion-of-Control containers, declarative transactions, the Spring MVC and Spring WebFlux web stacks, the TestContext framework, and integration modules for messaging, scheduling, caching, JMS, JMX, mail, and observability. It is the foundation of the Spring portfolio (Boot, Security, Data, Cloud, Batch, etc.).

Important

Spring Framework 7.x requires Jakarta EE 10+ APIs (jakarta.* namespace). Applications still on javax.* must migrate before upgrading. This is a hard breaking change from the 5.x era.

What This Guide Covers

This Admin Guide targets three personas:

1. Operators deploying and tuning Spring-based applications in production — configuration knobs, JVM flags, connection pool sizing, thread pool tuning, health probes.
2. Architects evaluating Spring for new projects or auditing existing ones — module dependency graph, extension points, security boundaries, concurrency model.
3. Contributors and framework developers navigating the source tree — build system, code conventions, test infrastructure, release process.

2. Architecture Overview

2.1 Layered Module Architecture

Spring Framework follows a strict layered dependency model. Lower layers never depend on higher layers. The entire framework compiles from a single Gradle multi-module build rooted at build.gradle.

┌─────────────────────────────────────────────────────────────────┐
│                     APPLICATION LAYER                           │
│  spring-webmvc · spring-webflux · spring-websocket · spring-jms │
│  spring-messaging · spring-orm · spring-oxm                     │
├─────────────────────────────────────────────────────────────────┤
│                     DATA ACCESS LAYER                           │
│  spring-jdbc · spring-r2dbc · spring-tx                         │
├─────────────────────────────────────────────────────────────────┤
│                     CONTAINER LAYER                             │
│  spring-context · spring-context-support · spring-context-indexer│
│  spring-aop · spring-aspects · spring-instrument                │
├─────────────────────────────────────────────────────────────────┤
│                     CORE LAYER                                  │
│  spring-core · spring-beans · spring-expression · spring-core-test│
├─────────────────────────────────────────────────────────────────┤
│                     BOM / PLATFORM                              │
│  framework-bom · framework-platform                             │
├─────────────────────────────────────────────────────────────────┤
│                     BUILD INFRASTRUCTURE                        │
│  buildSrc (6 custom Gradle plugins) · framework-docs (Antora)  │
└─────────────────────────────────────────────────────────────────┘

2.2 Module Inventory

The framework contains 22 publishable modules plus build and documentation infrastructure. Every module ships as a separate JAR with its own module-info.java (JPMS support).

Note

Package prefix o.s. is shorthand for org.springframework. throughout this guide.

2.3 BOM and Platform Modules

Two non-code modules manage dependency alignment across the ecosystem:

• framework-bom — Bill of Materials importing all 22 Spring Framework module JARs at the same version. Consumers import this in their <dependencyManagement> to avoid version mismatches.
• framework-platform — Enforced platform (Gradle enforcedPlatform) that pins all third-party dependency versions used by the framework's own modules. Every spring-* module inherits this via the root build.gradle configuration.

2.4 Build Infrastructure (buildSrc/)

The build uses 6 custom Gradle plugins defined in buildSrc/:

Additional build tooling:

• Checkstyle — Spring Java Format (io.spring.javaformat) enforced via buildSrc and checked at JAR time (jar.dependsOn check).
• Dokka — Kotlin documentation generation via org.jetbrains.dokka plugin.
• AspectJ — io.freefair.aspectj plugin (version 8.13.1) applied selectively for CTW modules.
• JMH — me.champeau.jmh plugin for micro-benchmarks (spring-core/src/jmh/).
• Nullability — io.spring.nullability plugin (0.0.11) for jspecify @Nullable/@NonNull enforcement.

2.5 Dependency Resolution Strategy

// From root build.gradle — ALL subprojects inherit this:
configurations.all {
    resolutionStrategy {
        cacheChangingModulesFor 0, "seconds"     // SNAPSHOT never cached
        cacheDynamicVersionsFor 0, "seconds"     // dynamic versions always re-resolved
    }
}

Repository resolution order:

1. Maven Central (always)
2. https://repo.spring.io/milestone — only for milestone versions (version contains -)
3. https://repo.spring.io/snapshot — only for SNAPSHOT versions

2.6 Documentation Infrastructure

Spring Framework uses Antora (version 3.2.0-alpha.11) for its reference documentation site:

• framework-docs/antora-playbook.yml — multi-branch site build (branches: 6.2.x, 7.0.x through 9.x)
• framework-docs/antora.yml — module attributes, asciidoc extensions
• Extensions: @antora/collector-extension, @springio/antora-extensions, @asciidoctor/tabs
• Example code lives in framework-docs/src/main/java/ and framework-docs/src/main/kotlin/

3. System Requirements

3.1 JDK Requirements

Warning

Spring Framework 7.x ships multi-release JARs with Java 21-specific code in META-INF/versions/21/. Running on JDK 17 is supported but misses virtual thread optimizations and structured concurrency integration.

3.2 Jakarta EE Baseline

Spring Framework 7.0 requires Jakarta EE 10+ APIs:

3.3 Third-Party Dependencies

Key runtime dependencies (versions pinned by framework-platform):

3.4 Application Server Compatibility

Caution

Spring Framework 7.0.5 introduced changes that may break certification with some application servers (see GitHub issue #36617). Verify compatibility with your target server before upgrading.

Tested server runtimes:

• Apache Tomcat 11.0+
• Eclipse Jetty 12+
• GlassFish 8+ / Eclipse GlassFish
• WildFly 33+ (Jakarta EE 11)
• Undertow 2.4+ (standalone)

4. Configuration Reference

4.1 XML Namespace Reference

Spring defines several XML namespaces, each backed by NamespaceHandler implementations that register BeanDefinitionParser classes. These are the namespaces available and their elements (from source code):

context Namespace (ContextNamespaceHandler)

URI: http://www.springframework.org/schema/context

tx Namespace (Transaction)

URI: http://www.springframework.org/schema/tx

Key attributes on <tx:annotation-driven>:

• transaction-manager — bean name of the PlatformTransactionManager (default: transactionManager)
• mode — proxy (default, JDK dynamic proxies) or aspectj (compile-time/load-time weaving)
• proxy-target-class — true forces CGLIB class-based proxies instead of interface-based

task Namespace (Scheduling)

URI: http://www.springframework.org/schema/task

Attributes on <task:annotation-driven>:

• executor — bean reference for @Async execution
• scheduler — bean reference for @Scheduled execution
• exception-handler — AsyncUncaughtExceptionHandler bean reference
• mode — proxy or aspectj

aop Namespace

URI: http://www.springframework.org/schema/aop

cache Namespace

URI: http://www.springframework.org/schema/cache

jms Namespace

URI: http://www.springframework.org/schema/jms

jdbc Namespace (DatabasePopulatorConfigUtils)

URI: http://www.springframework.org/schema/jdbc

Attributes on <jdbc:initialize-database>:

• data-source — DataSource bean reference
• ignore-failures — NONE (default), DROPS, or ALL
• separator — SQL statement separator (default: ;)

websocket Namespace

URI: http://www.springframework.org/schema/websocket

4.2 Java Configuration

Java-based configuration supersedes XML in modern Spring applications. The key entry points:

Core Container

@Configuration
@ComponentScan("com.example")
@PropertySource("classpath:app.properties")
public class AppConfig {
    @Bean
    public DataSource dataSource() { /* ... */ }
}

Web MVC Configuration

@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/static/**")
                .addResourceLocations("classpath:/static/");
    }
}

@EnableWebMvc imports DelegatingWebMvcConfiguration, which auto-registers:

• RequestMappingHandlerMapping and RequestMappingHandlerAdapter
• ExceptionHandlerExceptionResolver
• All detected HttpMessageConverter implementations (Jackson, JAXB, Atom, RSS, etc.)
• FormattingConversionService with standard formatters
• Validator (Bean Validation if on classpath)
• ContentNegotiationManager

Note

The AnnotationDrivenBeanDefinitionParser in spring-webmvc auto-detects message converters by classpath presence — Jackson → MappingJackson2HttpMessageConverter, JAXB → Jaxb2RootElementHttpMessageConverter, etc. No explicit registration is needed for standard formats.

WebFlux Configuration

@Configuration
@EnableWebFlux
public class WebFluxConfig implements WebFluxConfigurer {
    @Override
    public void configureApiVersioning(ApiVersionConfigurer configurer) {
        configurer.useRequestHeader("X-API-Version")
                  .useQueryParam("version")
                  .setDefaultVersion("1.0");
    }
}

Important

ApiVersionConfigurer is new in Spring Framework 7.0. It supports four strategies: useRequestHeader(), useQueryParam(), usePathSegment(), and useMediaTypeParameter(). A custom setVersionParser() can handle non-numeric version schemes.

Transaction Configuration

@Configuration
@EnableTransactionManagement  // mode = AdviceMode.PROXY by default
public class TxConfig {
    @Bean
    public PlatformTransactionManager transactionManager(DataSource ds) {
        return new DataSourceTransactionManager(ds);
    }
}

@EnableTransactionManagement attributes:

• mode — AdviceMode.PROXY (default) or AdviceMode.ASPECTJ
• proxyTargetClass — false (JDK proxies) or true (CGLIB proxies)
• order — Advisor ordering (default: Ordered.LOWEST_PRECEDENCE)

The transaction infrastructure registers:

• BeanFactoryTransactionAttributeSourceAdvisor
• TransactionInterceptor
• TransactionalEventListenerFactory (for @TransactionalEventListener)

Scheduling Configuration

@Configuration
@EnableScheduling
@EnableAsync
public class SchedulingConfig implements SchedulingConfigurer, AsyncConfigurer {
    @Override
    public void configureTasks(ScheduledTaskRegistrar registrar) {
        registrar.setScheduler(taskScheduler());
    }
    
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(25);
        executor.setThreadNamePrefix("async-");
        executor.initialize();
        return executor;
    }
}

Cache Configuration

@Configuration
@EnableCaching
public class CacheConfig {
    @Bean
    public CacheManager cacheManager() {
        return new ConcurrentMapCacheManager("users", "products");
    }
}

4.3 Environment & Profiles

Spring's Environment abstraction provides:

1. Property sources — ordered list (System.getProperties() → System.getenv() → @PropertySource files → servlet config/context)
2. Active profiles — activated via spring.profiles.active system property, env var, or programmatically
3. Default profiles — fallback when no profile is active (spring.profiles.default)

Profile activation methods:

# JVM argument
-Dspring.profiles.active=prod,monitoring

# Environment variable
SPRING_PROFILES_ACTIVE=prod,monitoring

# Programmatic
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.getEnvironment().setActiveProfiles("prod", "monitoring");
ctx.register(AppConfig.class);
ctx.refresh();

4.4 SpEL (Spring Expression Language)

SpEL is used in @Value annotations, XML configuration, security expressions, and cache key generation. Key capabilities:

The SpEL compiler (SpelCompiler) can compile expressions to bytecode for improved evaluation performance. Enable via SpelParserConfiguration(SpelCompilerMode.IMMEDIATE, classLoader).

5. Deployment & Operations

5.1 Deployment Models

Spring Framework supports multiple deployment topologies:

Note

AbstractReactiveWebInitializer (in spring-web) bridges the reactive HttpHandler to a Servlet 6.0+ container via ServletHttpHandlerAdapter. It implements ServletContainerInitializer for zero-XML deployment.

5.2 Thread Pool Tuning

MVC Thread Model (Servlet-based)

Spring MVC uses the servlet container's thread pool. Tune these at the container level:

WebFlux Thread Model (Reactive)

WebFlux uses a small, fixed event-loop pool (Reactor Netty default: Runtime.availableProcessors() threads). The key principle: never block the event loop.

Task Execution Thread Pools

@Bean
public ThreadPoolTaskExecutor applicationTaskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(5);
    executor.setMaxPoolSize(20);
    executor.setQueueCapacity(100);
    executor.setKeepAliveSeconds(60);
    executor.setThreadNamePrefix("app-exec-");
    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    executor.setWaitForTasksToCompleteOnShutdown(true);
    executor.setAwaitTerminationSeconds(30);
    return executor;
}

5.3 Connection Pool Sizing

For JDBC applications (spring-jdbc, spring-orm):

For R2DBC applications (spring-r2dbc):

5.4 Caching Operations

Spring's cache abstraction (@Cacheable, @CacheEvict, @CachePut) is provider-agnostic. Production providers:

Caution

ConcurrentMapCacheManager has no eviction, no TTL, and unbounded memory growth. Use only for development/testing. The CacheErrorHandler interface (configured via CachingConfigurer.errorHandler()) controls behavior when cache operations fail — the default propagates exceptions.

5.5 Health & Observability

Spring Framework provides hooks for observability (expanded by Spring Boot Actuator):

• SmartLifecycle — phased startup/shutdown ordering; implement getPhase() to control sequence
• HealthIndicator (Boot) — exposes DataSource, JMS, mail health
• MeterBinder (Micrometer) — auto-instruments JdbcTemplate, RestClient, WebClient
• Lifecycle events — ContextRefreshedEvent, ContextStartedEvent, ContextStoppedEvent, ContextClosedEvent
• Graceful shutdown — SmartLifecycle.stop(Runnable callback) with setPhase() ordering

5.6 JVM Flags for Production

# Essential for Spring Framework applications
-XX:+UseG1GC                          # Or ZGC for low-latency
-XX:MaxGCPauseMillis=200
-Xms2g -Xmx2g                         # Avoid heap resizing
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/var/log/app/

# Spring-specific
-Dspring.profiles.active=prod
-Dspring.jmx.enabled=false             # Disable JMX unless needed (saves ~50ms startup)
-Dspring.aop.proxy-target-class=true   # CGLIB proxies (avoids interface-only proxy issues)

# Virtual threads (JDK 21+)
-Dspring.threads.virtual.enabled=true  # Spring Boot property; Framework uses multi-release JARs

6. Security Analysis

6.1 Security Architecture

Spring Framework provides security building blocks but delegates comprehensive security to Spring Security. The framework-level security surface includes:

Warning

GitHub issue #36695 led to rejection of unsafe static resource locations in MVC and WebFlux. Ensure resource handler paths do not expose sensitive directories. Always constrain addResourceLocations() to specific, known-safe paths.

6.2 Input Validation

Spring integrates Bean Validation (Jakarta Validation 3.0+) at three levels:

1. Controller parameter validation — @Valid / @Validated on @RequestBody, @ModelAttribute
2. Method-level validation — @Validated on service classes activates MethodValidationPostProcessor
3. Configuration properties — @ConfigurationProperties with @Validated (Spring Boot)

The ModelAttributeMethodArgumentResolver performs binding and validation. Extension points validateIfApplicable() and isBindExceptionRequired() are available for customization (GitHub issue #36690 proposes making these protected).

6.3 CORS Configuration

@Configuration
@EnableWebMvc
public class CorsConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**")
                .allowedOrigins("https://app.example.com")
                .allowedMethods("GET", "POST", "PUT", "DELETE")
                .allowedHeaders("Authorization", "Content-Type")
                .allowCredentials(true)
                .maxAge(3600);
    }
}

Caution

Never use allowedOrigins("*") with allowCredentials(true) — this is rejected by browsers and Spring will throw an error. Use allowedOriginPatterns("*") if you genuinely need wildcard patterns with credentials.

6.4 Transaction Security

The @Transactional annotation controls propagation, isolation, and rollback:

6.5 Serialization Safety

• Jackson — Spring auto-configures MappingJackson2HttpMessageConverter without default typing. Do not enable ObjectMapper.enableDefaultTyping() — it is a known deserialization gadget attack vector.
• Java serialization — Not used by default for HTTP. If you expose Serializable objects via JMS or RMI, ensure SerializationUtils or AllowedClassesObjectInputStream whitelisting is in place.
• STOMP/WebSocket — Message payloads are deserialized via configured MessageConverter implementations; ensure Jackson (not Java serialization) is used.

6.6 Secrets Management

Spring Framework's Environment abstraction reads secrets from:

• System properties (-Ddb.password=...) — visible in process listings
• Environment variables (DB_PASSWORD) — preferred for containers
• @PropertySource files — do not commit to version control
• JNDI (application server managed) — strongest isolation for WAR deployments

Important

Spring Framework itself does not provide secret encryption or vault integration. Use Spring Cloud Vault, HashiCorp Vault, AWS Secrets Manager, or similar for production secret management. Never store secrets in application.properties files committed to source control.

7. Performance

7.1 AOT (Ahead-of-Time) Processing

Spring Framework 6+ includes AOT compilation support for GraalVM native images:

• BeanFactoryInitializationAotProcessor — generates code to replace runtime reflection
• RuntimeHints — declare reflection, resources, serialization, and JNI hints
• RuntimeHintsAgent (buildSrc plugin) — validates hints against actual runtime access patterns
• Component Index (spring-context-indexer) — compile-time META-INF/spring.components avoids classpath scanning

7.2 SpEL Compilation

The SpEL compiler converts interpreted expressions to bytecode:

Enable globally: -Dspring.expression.compiler.mode=MIXED

7.3 Bean Initialization Optimization

7.4 HTTP Client Performance

The HttpServiceProxyRegistry (new in 7.0, via @ImportHttpServices) manages HTTP Interface client proxies organized by HttpServiceGroup. Each group binds to either a RestClient or WebClient instance.

8. Troubleshooting

8.1 Container Startup Issues

8.2 Web Tier Issues

8.3 Data Access Issues

8.4 Reactive Stack Issues

8.5 JMS Issues

8.6 Diagnostic Techniques

// Enable detailed bean loading logging
-Dlogging.level.org.springframework.beans.factory=DEBUG

// Trace AOP proxy creation
-Dlogging.level.org.springframework.aop=TRACE

// Log all SQL from JdbcTemplate
-Dlogging.level.org.springframework.jdbc.core=DEBUG
-Dlogging.level.org.springframework.jdbc.core.StatementCreatorUtils=TRACE

// WebFlux request/response logging
-Dlogging.level.org.springframework.web.reactive=DEBUG

// Transaction logging
-Dlogging.level.org.springframework.transaction=TRACE

9. Developer Internals

9.1 Source Tree Navigation

spring-framework/
├── build.gradle              Root build (plugins, allprojects config, javadocLinks)
├── buildSrc/                 6 custom Gradle plugins
│   └── src/main/java/org/springframework/build/
│       ├── architecture/     ArchUnit layer rules
│       ├── ConventionsPlugin.java
│       ├── dev/              LocalDevelopmentPlugin
│       ├── hint/             RuntimeHintsAgentPlugin
│       ├── multirelease/     Multi-release JAR support
│       └── optional/         Optional dependency configuration
├── framework-bom/            BOM POM for consumers
├── framework-platform/       Enforced platform (3rd-party version pins)
├── framework-docs/           Antora documentation site
│   ├── antora-playbook.yml
│   ├── antora.yml
│   ├── package.json          Antora + extensions
│   └── modules/ROOT/         AsciiDoc pages + code examples
├── spring-core/              Foundation: types, resources, env, CGLIB, ASM
├── spring-beans/             BeanFactory, BeanDefinition parsing, property editors
├── spring-expression/        SpEL parser + compiler
├── spring-aop/               AOP Alliance, AspectJ auto-proxy, advisor framework
├── spring-context/           ApplicationContext, events, scheduling, caching
├── spring-tx/                Transaction abstraction, @Transactional
├── spring-jdbc/              JdbcTemplate, JdbcClient, embedded DB
├── spring-r2dbc/             Reactive database client
├── spring-orm/               JPA/Hibernate integration
├── spring-web/               HTTP core, clients (RestClient, WebClient), codecs
├── spring-webmvc/            DispatcherServlet, MVC config, handler mapping
├── spring-webflux/           DispatcherHandler, reactive config, API versioning
├── spring-websocket/         WebSocket/SockJS, STOMP relay
├── spring-jms/               JMS template, listener containers
├── spring-messaging/         Message abstraction, STOMP/SIMP broker
├── spring-oxm/               XML marshalling
├── spring-context-support/   JCache, Quartz, mail, FreeMarker
├── spring-context-indexer/   Compile-time component index
├── spring-aspects/           AspectJ CTW aspects
├── spring-instrument/        JVM class instrumentation agent
├── spring-core-test/         AOT and runtime hints test utilities
├── spring-test/              TestContext, MockMvc, WebTestClient
├── integration-tests/        Cross-module integration tests
└── src/                      IDE settings (IntelliJ, Eclipse), checkstyle, nohttp

9.2 Code Patterns

BeanDefinitionParser Pattern

Most XML namespace elements are handled by BeanDefinitionParser implementations. The standard pattern:

1. NamespaceHandler.init() registers element names → parser classes
2. Parser's parse(Element, ParserContext) creates BeanDefinitionBuilder instances
3. Parsers use parserContext.getRegistry() to register beans atomically
4. CompositeComponentDefinition groups related beans for tooling visibility

Example from AnnotationDrivenBeanDefinitionParser (task namespace):

// Registers AsyncAnnotationBeanPostProcessor (proxy mode)
// or AnnotationAsyncExecutionAspect (aspectj mode)
String mode = element.getAttribute("mode");
if ("aspectj".equals(mode)) {
    registerAsyncExecutionAspect(element, parserContext);
} else {
    // proxy mode - register BeanPostProcessor
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(
        "org.springframework.scheduling.annotation.AsyncAnnotationBeanPostProcessor");
    builder.addPropertyReference("executor", executor);
    // ...
}

Advisor Adapter Pattern (AOP)

The AOP framework uses an adapter pattern to bridge different advice types to the unified MethodInterceptor interface:

1. AdvisorAdapter — SPI for converting Advice types to MethodInterceptor
2. DefaultAdvisorAdapterRegistry — ships adapters for BeforeAdvice, AfterReturningAdvice, ThrowsAdvice
3. AdvisorAdapterRegistrationManager — BeanPostProcessor that auto-registers custom AdvisorAdapter beans

HTTP Service Registry Pattern (7.0+)

The @ImportHttpServices + AbstractHttpServiceRegistrar pattern provides declarative HTTP client proxy registration:

1. AbstractHttpServiceRegistrar implements ImportBeanDefinitionRegistrar
2. Scans for interfaces annotated with @HttpExchange
3. Groups interfaces into HttpServiceGroup instances
4. Registers HttpServiceProxyRegistryFactoryBean to create proxies at runtime
5. Multiple registrar imports merge into a single registry

Event System

Spring's event system (spring-context) follows the observer pattern:

• ApplicationEventPublisher — publish events
• @EventListener / ApplicationListener<E> — receive events
• @TransactionalEventListener — process after transaction commit/rollback
• ApplicationEventMulticaster — dispatches to listeners (default: SimpleApplicationEventMulticaster)
• @Async @EventListener — asynchronous event handling (requires @EnableAsync)

9.3 Testing Infrastructure

Spring's test module (spring-test) provides:

TestContext Framework

• @SpringBootTest (Boot) / @ContextConfiguration — load ApplicationContext for tests
• @MockitoBean, @MockitoSpyBean — bean override in context (new in 6.2+; strict stubbing support: #34419)
• @Sql — execute SQL scripts before/after test methods
• @ActiveProfiles — activate profiles for test context
• @DirtiesContext — mark context for re-creation (use sparingly — expensive)

MockMvc (MVC Testing)

@WebMvcTest(UserController.class)
class UserControllerTest {
    @Autowired MockMvc mockMvc;
    
    @Test
    void shouldReturnUser() throws Exception {
        mockMvc.perform(get("/users/1"))
               .andExpect(status().isOk())
               .andExpect(jsonPath("$.name").value("Alice"));
    }
}

WebTestClient (WebFlux Testing)

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class ReactiveTest {
    @Autowired WebTestClient client;
    
    @Test
    void shouldStreamEvents() {
        client.get().uri("/events")
              .accept(MediaType.TEXT_EVENT_STREAM)
              .exchange()
              .expectStatus().isOk()
              .expectBodyList(Event.class).hasSize(3);
    }
}

AOT Test Support

• @DisabledInAotMode — skip tests incompatible with AOT
• RuntimeHintsPredicates — assert that runtime hints are correctly registered
• TestCompiler (spring-core-test) — compile and load generated AOT code in tests

9.4 Kotlin Integration

Spring Framework provides first-class Kotlin support:

9.5 JPMS (Java Platform Module System)

Every spring-* module includes a module-info.java for JPMS compatibility. Key exports:

• Modules export their public API packages
• Internal packages use exports ... to for framework-internal access
• requires transitive for API dependencies (e.g., spring-beans requires transitive spring-core)
• opens directives for reflection access (required by DI container)

9.6 Contributing & Build

Building from Source

# Clone
git clone https://github.com/spring-projects/spring-framework.git
cd spring-framework

# Full build (requires JDK 17+)
./gradlew build

# Skip tests
./gradlew build -x test

# Build specific module
./gradlew :spring-core:build

# Run checkstyle only
./gradlew checkstyleMain checkstyleTest

# Generate documentation site
cd framework-docs && npx antora antora-playbook.yml

Code Style

• Spring Java Format — enforced via checkstyle plugin at build time
• Tabs for indentation (not spaces)
• Import ordering: java.*, blank line, javax.*/jakarta.*, blank line, all others
• No wildcard imports
• Copyright header on all files: Copyright 2002-present the original author or authors

Test Organization

10. Quick Reference

10.1 XML Namespace URIs

10.2 Key Annotations

10.3 Common System Properties

10.4 Module Maven Coordinates

All modules use group org.springframework and version aligned via framework-bom:

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-framework-bom</artifactId>
            <version>${spring.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

10.5 Logging Configuration

Spring Framework uses commons-logging as its logging API (bridged to SLF4J/Log4j 2 at runtime):

Note

This guide was generated from source analysis of the Spring Framework repository at commit 5e6e223. It reflects the codebase as of that commit and may not cover changes made after 2026-04-23. For the latest information, consult the official Spring Framework reference documentation and release notes.