Lore

The Spring Framework codebase has been continuously evolving since at least 2003 (the project's first public release was Spring 1.0 in March 2004). The git history present in this repository goes back to July 2008, when the project moved to its current Subversion-then-Git layout. This page is a narrative timeline of how the codebase has changed since then.

Origins (pre-July 2008)

The earliest commits in this repository are dated 2008-07-10 and are titled "Initial structure" and "Added spring-build". They migrate an already-mature codebase from older infrastructure rather than starting from scratch. By that point Spring 2.5 had shipped (November 2007) with annotation-driven configuration (@Autowired, @Component), and the framework was already widely deployed in production.

The first substantive commit, "Initial code checkin" on 2008-07-11, lands the bulk of spring-core and spring-beans content. Within weeks, 2008-08-12 sees "First drop of SPEL" — the Spring Expression Language was being introduced as a brand-new module that would ship with Spring 3.0.

Eras

The Spring 3.x era (2008–2013)

Spring 3.0 was the first major release after the move to git in this repository.

Key events:

• 2008-08-12 — SpEL (Spring Expression Language) lands as a new module
• Spring 3.0 (Dec 2009) — Annotation-based configuration matures (@Configuration, @Bean); SpEL becomes general-purpose
• Spring 3.1 (Dec 2011) — Java configuration completeness; cache abstraction; Environment/Profile API
• Spring 3.2 (Dec 2012) — Servlet 3.0 async support; first reactive-feel APIs (DeferredResult, WebAsyncTask)

This era established the module layout that's still recognizable today: spring-core, spring-beans, spring-context, spring-aop, spring-expression, spring-jdbc, spring-orm, spring-tx, spring-web, spring-webmvc.

The Spring 4.x and Java 8 era (2013–2017)

Spring 4 raised the floor to Java 6 (later Java 8 with 4.3) and added first-class Java 8 support.

Key events:

• Spring 4.0 (Dec 2013) — Java 8 support; WebSocket and STOMP messaging; first-class Groovy DSL for bean definitions
• spring-messaging and spring-websocket — added as new top-level modules to support STOMP-over-WebSocket and the broader messaging abstraction reused later by JMS/AMQP/Kafka adapters
• Spring 4.2 (Jul 2015) — @EventListener, @Scheduled enhancements
• Spring 4.3 (Jun 2016) — Last Java 6/7 release; constructor injection becomes idiomatic

The reactive era (Spring 5, 2017–2019)

Spring 5 was a watershed: a brand-new reactive web stack landed alongside the mature MVC stack.

Key events:

• Spring 5.0 (Sep 2017) — Java 8 baseline; spring-webflux module introduced; WebClient, RouterFunction, reactive types throughout spring-web
• Reactor 3 becomes the default reactive library
• Kotlin extensions added (idiomatic DSLs for routing, mock setup, etc.)
• Functional bean registration — GenericApplicationContext.registerBean(...)
• spring-r2dbc later added (in 5.3) as a reactive complement to spring-jdbc

Spring 6: Jakarta EE and ahead-of-time (2022–2024)

Spring 6 was the largest breaking-changes release in years. It moved the Java floor to 17 and migrated from javax.* to jakarta.* namespaces — every Servlet, JMS, and Persistence import changed across the codebase.

Key events:

• Spring 6.0 (Nov 2022) — Java 17 baseline; Jakarta EE 9 namespace migration; first-class AOT processing for native images
• org.springframework.aot.hint — A new package in spring-core for runtime hint registration; every subsystem grew companion *RuntimeHints classes
• HTTP interface clients — @HttpExchange declarative HTTP clients
• Observability — Built-in Micrometer integration replaces older metrics/tracing hooks
• Spring 6.1 (Nov 2023) — Virtual threads (Project Loom) support; CRaC (Coordinated Restore at Checkpoint) integration

Spring 7: the current cycle (2024–2026)

The repository's HEAD is 7.1.0-SNAPSHOT, with the most recent published tag being v7.0.7. Spring 7 continues the Jakarta EE 11 alignment, deepens AOT support, and refines the reactive and HTTP-interface APIs.

Key events visible in recent history:

• Spring 7.0 (late 2025) — Java 21+ optimizations, Jakarta EE 11 migration, expanded HTTP interface clients
• JSpecify nullness annotations — Module-by-module migration from org.springframework.lang.@Nullable to JSpecify
• io.spring.nullability plugin — Build-time nullness checking applied to every spring-* module
• Refined AOT processing — More sophisticated reflection hints, fewer fallbacks
• Continued GraalVM native image investment

Longest-standing features

The following are core APIs whose shape has been remarkably stable:

• BeanFactory / ApplicationContext — Public interfaces have evolved additively since the earliest 2008 commits. getBean(String) and getBean(Class<T>) are still the workhorse lookups.
• JdbcTemplate — Same fundamental method signatures since pre-2008. Has weathered every major release intact.
• PlatformTransactionManager — The transaction abstraction interface has not changed since 2008.
• Resource / ResourceLoader — Spring's "URL with extras" abstraction is one of the framework's earliest contributions and remains untouched at the API level.
• @Autowired — Introduced in Spring 2.5 (2007), still the recommended injection annotation today (alongside constructor injection).

Major rewrites and migrations

Era	Migration	What changed
2008	XML → Java config	@Configuration/@Bean joined XML as a peer; Spring 3.0+
2017 (Spring 5)	Reactive stack added	spring-webflux module created alongside spring-webmvc
2022 (Spring 6)	javax.* → jakarta.*	Every Servlet/JMS/Persistence import in the codebase rewritten
2022 (Spring 6)	AOT processing introduced	spring-core/aot/, per-module RuntimeHints registrations
2024+ (Spring 6.1+)	Virtual threads / Loom adoption	Executors and async paths now Loom-aware
2024+ (Spring 7)	JSpecify nullability	Annotation-by-annotation switch from internal @Nullable to JSpecify

Deprecated subsystems

Some areas have been sunset over the years:

• CORBA / RMI invocation — Removed in Spring 6.0 alongside other older remoting protocols (Hessian, JAX-WS HTTP exporters).
• org.springframework.web.context.request.async.DeferredResult for non-Servlet 3 — Older async bridges removed when Servlet 3.0 became the floor.
• JCA CCI support — Removed in Spring 6.
• Apache CXF / older WS support classes — Trimmed down through the 5.x series.
• javax.* namespace — All removed in Spring 6.0; only jakarta.* remains.

Growth trajectory

The codebase has grown roughly 4–5× in source-file count since 2008, with the largest individual additions being:

1. spring-webflux (2017) — A second full web stack
2. AOT support (2022) — A new top-level package in spring-core plus contributions in every module
3. Observability (2022+) — Micrometer integration touchpoints scattered across modules
4. HTTP interface clients (2023+) — @HttpExchange machinery in spring-web and reactive wiring in spring-webflux

The team size has stayed small. A look at the git shortlog for any of the last five years shows the same ~5 names dominating commit counts: Sam Brannen, Juergen Hoeller, Rossen Stoyanchev, Sébastien Deleuze, and Brian Clozel.